@sellable/mcp 0.1.158 → 0.1.160

package/agents/source-scout-linkedin-engagement.md

@@ -60,9 +60,14 @@ currentStep: "signal-discovery" })` before sampling so the watched Signal
    sampled/projected headline-fit rate clears the 10% planning floor. Treat the
    10% floor as a reject threshold, not as the scrape-count denominator when the
    actual sample rate is higher.
-8. Select/promote enough right-content posts to plausibly hit the target. If the
-   warm Signals pool is useful but too small, return the expected warm range and
-   recommend Sales Nav/Prospeo for scale instead of padding with noisy posts.
+8. Select/promote enough right-content posts to plausibly hit the target. After
+   the sample math is known, treat the promoted sample set and final scrape set
+   as separate: recommend the smallest right-content post subset whose
+   scrapable/reachable engagers clears the required engager count, with a modest
+   buffer when needed. If one 1,200+ engager post clears a ~1,000-engager target,
+   recommend scraping that one post, not all 3 sample posts. If the warm Signals
+   pool is useful but too small, return the expected warm range and recommend
+   Sales Nav/Prospeo for scale instead of padding with noisy posts.
 9. Return false positives and dead ends explicitly.
 
 Return a concise structured result with:

package/dist/tools/bootstrap.js

@@ -270,7 +270,7 @@ export async function bootstrapCreateCampaign(input = {}) {
         ? resumeDetected
             ? `Bootstrap complete.${workspaceNotice} Resume from campaign state and navigation diagnostics first; treat local draft artifacts as debug-only evidence. Then load ${createCampaignSubskill?.name ?? "create-campaign"} instructions with get_subskill_prompt({ subskillName: "${createCampaignSubskill?.name ?? "create-campaign"}" }); if the response has hasMore=true, continue with nextOffset until hasMore=false.`
             : flowVersion === "v2"
-                ? `Bootstrap complete.${workspaceNotice} Load the compact create-campaign-v2 entry prompt once with get_subskill_prompt({ subskillName: "create-campaign-v2" }); load flow/reference assets lazily only when that stage needs them. Preserve the pre-intake sequence: confirm auth/workspace status, resolve campaign identity, and run lightweight profile/company lookup. Do not call list_senders or sender discovery during setup; sender availability belongs only to Settings after message approval. Then run the short setup/intake, write the campaign brief, call create_campaign once to mint the watchable shell, surface the returned watch link, and hand off to lead finding.`
+                ? `Bootstrap complete.${workspaceNotice} Load the compact create-campaign-v2 entry prompt once with get_subskill_prompt({ subskillName: "create-campaign-v2" }); load flow/reference assets lazily only when that stage needs them. Preserve the pre-intake sequence: confirm auth/workspace status, ask for the LinkedIn profile URL first with company website as fallback, run lightweight profile/company lookup, and ask whether the user has a current offer or wants the researched recommendation. Do not call list_senders or sender discovery during setup; sender availability belongs only to Settings after message approval. Then run the short setup/intake, write the campaign brief, call create_campaign once to mint the watchable shell, surface the returned watch link, and hand off to lead finding.`
                 : `Bootstrap complete.${workspaceNotice} Load ${createCampaignSubskill?.name ?? "create-campaign"} instructions with get_subskill_prompt({ subskillName: "${createCampaignSubskill?.name ?? "create-campaign"}" }); if the response has hasMore=true, continue with nextOffset until hasMore=false. Follow that flow before calling create_campaign.`
         : "Bootstrap incomplete. Resolve blockingErrors and rerun bootstrap_create_campaign before provider/search/import tools.";
     // Strip prompt body from createCampaignSubskill — it's loaded via the host

package/dist/tools/leads.d.ts

@@ -163,6 +163,8 @@ export type SelectPromisingPostsInput = {
     currentStep?: string | null;
     selectionMode?: "add" | "replace";
     mode?: "add" | "replace";
+    targetEngagerCount?: number;
+    maxPostsToScrape?: number;
 };
 export type SetHeadlineICPCriteriaInput = {
     campaignOfferId: string;
@@ -2000,6 +2002,14 @@ export declare const leadToolDefinitions: ({
                 enum: string[];
                 description: string;
             };
+            targetEngagerCount: {
+                type: string;
+                description: string;
+            };
+            maxPostsToScrape: {
+                type: string;
+                description: string;
+            };
             currentStep: {
                 type: string[];
                 description: string;
@@ -2051,8 +2061,6 @@ export declare const leadToolDefinitions: ({
             sourceLeadListId?: undefined;
             targetLeadCount?: undefined;
             mode?: undefined;
-            targetEngagerCount?: undefined;
-            maxPostsToScrape?: undefined;
             tableId?: undefined;
             campaignName?: undefined;
             keepInSync?: undefined;
@@ -2650,6 +2658,16 @@ export declare function selectPromisingPosts(input: SelectPromisingPostsInput):
     unselectedCount: number;
     criteriaCount: number;
     message: string;
+    recommendedPostCount?: undefined;
+    recommendedTargetEngagerCount?: undefined;
+} | {
+    success: boolean;
+    selectedCount: number;
+    recommendedPostCount: number;
+    recommendedTargetEngagerCount: number | null;
+    unselectedCount: number;
+    criteriaCount: number;
+    message: string;
 }>;
 export declare function setHeadlineICPCriteria(input: SetHeadlineICPCriteriaInput): Promise<{
     success: boolean;

package/dist/tools/leads.js

@@ -745,13 +745,21 @@ function buildSignalDiscoveryResultsWatchNarration(postsReturned) {
         safety: "Scrape approval is the next gate.",
     };
 }
-function buildSelectedPostApprovalWatchNarration(selectedPostCount) {
+function buildSelectedPostApprovalWatchNarration(selectedPostCount, recommendedPostCount = selectedPostCount, targetEngagerCount) {
+    const selectedPostCopy = `${selectedPostCount.toLocaleString("en-US")} LinkedIn post${selectedPostCount === 1 ? "" : "s"} selected for the source test`;
+    const recommendedPostCopy = `${recommendedPostCount.toLocaleString("en-US")} recommended LinkedIn post${recommendedPostCount === 1 ? "" : "s"}`;
+    const targetCopy = targetEngagerCount
+        ? ` to cover about ${targetEngagerCount.toLocaleString("en-US")} source candidates`
+        : "";
+    const visibleState = recommendedPostCount < selectedPostCount
+        ? `${selectedPostCopy}; the scrape plan only needs ${recommendedPostCopy}${targetCopy}.`
+        : `${selectedPostCopy}.`;
     return {
         stage: "find-leads",
         headline: "Approve selected-post scrape",
-        visibleState: `${selectedPostCount.toLocaleString("en-US")} LinkedIn post${selectedPostCount === 1 ? "" : "s"} selected for the source test.`,
+        visibleState,
         agentIntent: "Codex is asking before scraping this selected engager pool into a source list.",
-        nextAction: `Approve scraping ${selectedPostCount.toLocaleString("en-US")} selected LinkedIn post${selectedPostCount === 1 ? "" : "s"}`,
+        nextAction: `Approve scraping ${recommendedPostCopy}`,
         safety: "Scrape approval is the next gate.",
     };
 }
@@ -762,41 +770,68 @@ function formatApproxInteger(value) {
     const rounded = value >= 100 ? Math.round(value / 10) * 10 : Math.round(value);
     return `~${rounded.toLocaleString("en-US")}`;
 }
-function buildSignalDiscoverySourceRecommendation({ selectedPosts, }) {
+function normalizeEngagementCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0
+        ? value
+        : 0;
+}
+function buildSignalDiscoverySourceRecommendation({ selectedPosts, targetEngagerCount, maxPostsToScrape, }) {
     const { targetGoodFitLeads, defaultFitRate, minPlanningFitRate, sourceCandidateTarget, reviewBatchSize, } = getSignalDiscoverySourcePlanDefaults();
-    const selectedCount = selectedPosts.length;
-    const totalEngagement = selectedPosts.reduce((sum, post) => sum + (post.likes ?? 0) + (post.comments ?? 0), 0);
-    const tableRows = selectedPosts
+    const effectiveTargetEngagerCount = normalizePositiveInteger(targetEngagerCount) ?? sourceCandidateTarget;
+    const normalizedSelectedPosts = selectedPosts.map((post) => ({
+        ...post,
+        likes: normalizeEngagementCount(post.likes),
+        comments: normalizeEngagementCount(post.comments),
+    }));
+    const scrapePlan = selectSignalPostsForImport(normalizedSelectedPosts, {
+        targetEngagerCount: effectiveTargetEngagerCount,
+        maxPostsToScrape: maxPostsToScrape ?? undefined,
+    });
+    const recommendedPosts = scrapePlan.posts;
+    const selectedCount = normalizedSelectedPosts.length;
+    const recommendedCount = recommendedPosts.length;
+    const totalVisibleEngagement = normalizedSelectedPosts.reduce((sum, post) => sum + post.likes + post.comments, 0);
+    const recommendedVisibleEngagement = recommendedPosts.reduce((sum, post) => sum + post.likes + post.comments, 0);
+    const tableRows = recommendedPosts
         .map((post) => {
-        const engagement = (post.likes ?? 0) + (post.comments ?? 0);
-        return `| ${escapeMarkdownTableCell(post.authorName)} | ${escapeMarkdownTableCell(post.reason)} | ${formatApproxInteger(engagement)} |`;
+        const engagement = post.likes + post.comments;
+        return `| ${escapeMarkdownTableCell(post.authorName)} | ${escapeMarkdownTableCell(post.reason)} | ${formatApproxInteger(engagement)} | ${formatApproxInteger(estimateScrapableSignalEngagers(post))} |`;
     })
         .join("\n");
-    const estimatedGoodFit = totalEngagement * defaultFitRate;
-    return `## Source Recommendation
+    const fitRateForEstimate = targetEngagerCount && effectiveTargetEngagerCount > 0
+        ? Math.min(1, targetGoodFitLeads / effectiveTargetEngagerCount)
+        : defaultFitRate;
+    const estimatedGoodFit = scrapePlan.estimatedEngagers * fitRateForEstimate;
+    const fitRateLabel = targetEngagerCount && effectiveTargetEngagerCount > 0
+        ? "approved source math"
+        : `${Math.round(defaultFitRate * 100)}% working assumption`;
+    const selectedPoolCopy = recommendedCount < selectedCount
+        ? `**Promoted sample pool:** ${selectedCount.toLocaleString("en-US")} selected posts, ${formatApproxInteger(totalVisibleEngagement)} visible / ${formatApproxInteger(scrapePlan.availableEngagers)} scrapable engagers<br>\n**Recommended scrape set:** ${recommendedCount.toLocaleString("en-US")} post${recommendedCount === 1 ? "" : "s"}, ${formatApproxInteger(recommendedVisibleEngagement)} visible / ${formatApproxInteger(scrapePlan.estimatedEngagers)} scrapable engagers<br>`
+        : `**Total visible pool:** ${formatApproxInteger(totalVisibleEngagement)} engagers<br>\n**Scrape-capacity pool:** ${formatApproxInteger(scrapePlan.estimatedEngagers)} scrapable engagers after endpoint caps<br>`;
+    const message = `## Source Recommendation
 
 Use LinkedIn engagement first.
 
 **Goal:** ~${targetGoodFitLeads.toLocaleString("en-US")} headline-fit prospects from relevant LinkedIn engagement<br>
 **Working assumption:** ~${Math.round(defaultFitRate * 100)}% of raw post engagers pass headline filtering unless a real sample supports a different rate<br>
-**Engagers needed:** ~${sourceCandidateTarget.toLocaleString("en-US")} raw engagers<br>
+**Engagers needed:** ~${effectiveTargetEngagerCount.toLocaleString("en-US")} raw engagers<br>
 **Planning floor:** continue with LinkedIn engagement only when sampled/projected headline-fit rate is at least ${Math.round(minPlanningFitRate * 100)}%; below that, switch to Sales Nav recent activity<br>
 **Review checkpoint:** copy the confirmed source list into the campaign, then process the first ${reviewBatchSize.toLocaleString("en-US")} leads for fit and message review before scaling
 
-### Selected posts
+### Recommended scrape set
 
-| Post | Why it fits | Visible engagement |
-|---|---|---:|
-${tableRows || "| Selected posts | Campaign-matched public engagement | - |"}
+| Post | Why it fits | Visible engagement | Scrape capacity |
+|---|---|---:|---:|
+${tableRows || "| Recommended posts | Campaign-matched public engagement | - | - |"}
 
-**Total visible pool:** ${formatApproxInteger(totalEngagement)} engagers<br>
-**Estimated headline-fit pool at ${Math.round(defaultFitRate * 100)}%:** ${formatApproxInteger(estimatedGoodFit)} prospects before enrichment and deeper fit review
+${selectedPoolCopy}
+**Estimated headline-fit pool from ${fitRateLabel}:** ${formatApproxInteger(estimatedGoodFit)} prospects before enrichment and deeper fit review
 
 ### Recommendation
 
-Approve scraping these ${selectedCount} posts.
+Approve scraping these ${recommendedCount} recommended post${recommendedCount === 1 ? "" : "s"}.
 
-This gives enough volume to target ~${targetGoodFitLeads.toLocaleString("en-US")} headline-fit prospects, while keeping the source tied to people already engaging with the campaign's strongest public buying signals.
+This gives enough volume to target ~${targetGoodFitLeads.toLocaleString("en-US")} headline-fit prospects, while keeping the scrape limited to the smallest selected right-content post set that covers the source-candidate target.
 
 **First pass:** build the source list, copy it into the campaign, then use the first ${reviewBatchSize.toLocaleString("en-US")} campaign rows as the internal setup slice for filters and messages before scaling.
 
@@ -804,7 +839,13 @@ This gives enough volume to target ~${targetGoodFitLeads.toLocaleString("en-US")
 
 Approval card should say:
 
-**Approve scraping ${selectedCount} selected LinkedIn post${selectedCount === 1 ? "" : "s"}?**`;
+**Approve scraping ${recommendedCount} recommended LinkedIn post${recommendedCount === 1 ? "" : "s"}?**`;
+    return {
+        message,
+        recommendedPostCount: recommendedCount,
+        estimatedEngagers: scrapePlan.estimatedEngagers,
+        targetEngagerCount: effectiveTargetEngagerCount,
+    };
 }
 function normalizeImportProvider(provider) {
     if (provider === "apollo-ai" || provider === "apollo")
@@ -1480,7 +1521,7 @@ export const leadToolDefinitions = [
     },
     {
         name: "select_promising_posts",
-        description: "Select the most promising LinkedIn posts for lead scraping AND provide headline ICP criteria. Use the selectionTarget returned by search_signals (default 3). In campaign-attached sampling, call select_promising_posts first to promote the sampled posts into the watched UI before fetch_post_engagers.",
+        description: "Select the most promising LinkedIn posts for lead scraping AND provide headline ICP criteria. Use the selectionTarget returned by search_signals (default 3) for the sampling/promoted set. After sample math exists, pass targetEngagerCount so the approval recommendation uses the smallest right-content post subset that covers the source-candidate target instead of scraping every promoted sample post.",
         inputSchema: {
             type: "object",
             properties: {
@@ -1520,6 +1561,14 @@ export const leadToolDefinitions = [
                     enum: ["add", "replace"],
                     description: 'How to apply selections. "add" keeps existing selections; "replace" clears previous selections not included in this call.',
                 },
+                targetEngagerCount: {
+                    type: "number",
+                    description: "Optional source-candidate target from sample math. When provided, the recommendation ranks selected posts by scrapable engagement and asks approval for only enough posts to cover this target. If omitted, uses the default Signal Discovery source target.",
+                },
+                maxPostsToScrape: {
+                    type: "number",
+                    description: "Optional hard cap for the recommended scrape set after ranking selected posts by scrapable engagement. Values above the backend hard cap are clamped.",
+                },
                 currentStep: {
                     type: ["string", "null"],
                     description: "Headless workflow step ID",
@@ -3016,7 +3065,7 @@ export function getProviderPrompt(input) {
 }
 export async function selectPromisingPosts(input) {
     const api = getApi();
-    const { campaignOfferId, selections, headlineICPCriteria, selectionMode, mode, } = input;
+    const { campaignOfferId, selections, headlineICPCriteria, selectionMode, mode, targetEngagerCount, maxPostsToScrape, } = input;
     const effectiveMode = selectionMode ?? mode ?? "add";
     if (selections.length > MAX_SIGNAL_DISCOVERY_POSTS) {
         return {
@@ -3053,11 +3102,9 @@ export async function selectPromisingPosts(input) {
             message: "No Signal Discovery posts were selected for this campaign. Do not import yet. Re-run a campaign-scoped search_signals call, use recommendedPostIds from the current campaign search state, or ask the user to promote posts in the UI before retrying select_promising_posts.",
         };
     }
-    await api.put(`/api/v2/campaign-offers/${campaignOfferId}`, {
-        currentStep: "signal-discovery",
-        watchNarration: buildSelectedPostApprovalWatchNarration(selectionResult.selectedCount),
-    });
     let sourceRecommendation = "";
+    let recommendedPostCount = selectionResult.selectedCount;
+    let recommendationTargetEngagerCount = null;
     try {
         const tabsResponse = await api.get(`/api/v3/campaigns/${campaignOfferId}/signal-discovery/tabs`);
         const reasonsByPostId = new Map(selections.map((selection) => [selection.postId, selection.reason]));
@@ -3086,9 +3133,17 @@ export async function selectPromisingPosts(input) {
                 });
             }
         }
-        sourceRecommendation = buildSignalDiscoverySourceRecommendation({
+        if (selectedByUrl.size === 0) {
+            throw new Error("No selected Signal Discovery posts found in tabs");
+        }
+        const recommendation = buildSignalDiscoverySourceRecommendation({
             selectedPosts: Array.from(selectedByUrl.values()),
+            targetEngagerCount,
+            maxPostsToScrape,
         });
+        sourceRecommendation = recommendation.message;
+        recommendedPostCount = recommendation.recommendedPostCount;
+        recommendationTargetEngagerCount = recommendation.targetEngagerCount;
     }
     catch {
         const { reviewBatchSize } = getSignalDiscoverySourcePlanDefaults();
@@ -3096,22 +3151,28 @@ export async function selectPromisingPosts(input) {
 
 Use LinkedIn engagement first.
 
-**Recommendation:** approve scraping the ${selectionResult.selectedCount} selected LinkedIn post${selectionResult.selectedCount === 1 ? "" : "s"}.
+	**Recommendation:** approve scraping ${selectionResult.selectedCount} recommended LinkedIn post${selectionResult.selectedCount === 1 ? "" : "s"}.
 
 	**First pass:** build the source list, copy it into the campaign, then process only the first ${reviewBatchSize.toLocaleString("en-US")} leads so we can inspect quality before scaling.
 
 Approval card should say:
 
-**Approve scraping ${selectionResult.selectedCount} selected LinkedIn post${selectionResult.selectedCount === 1 ? "" : "s"}?**`;
+	**Approve scraping ${selectionResult.selectedCount} recommended LinkedIn post${selectionResult.selectedCount === 1 ? "" : "s"}?**`;
     }
+    await api.put(`/api/v2/campaign-offers/${campaignOfferId}`, {
+        currentStep: "signal-discovery",
+        watchNarration: buildSelectedPostApprovalWatchNarration(selectionResult.selectedCount, recommendedPostCount, recommendationTargetEngagerCount),
+    });
     return {
         success: true,
         selectedCount: selectionResult.selectedCount,
+        recommendedPostCount,
+        recommendedTargetEngagerCount: recommendationTargetEngagerCount,
         unselectedCount: selectionResult.unselectedCount,
         criteriaCount: selectionResult.criteriaCount,
         message: `${sourceRecommendation}
 
-	Selected ${selectionResult.selectedCount} posts with ${selectionResult.criteriaCount} ICP criteria persisted. Ask the user to approve this specific scraping action once; after approval, call import_leads immediately and do not repeat this source card.`,
+	Selected ${selectionResult.selectedCount} posts with ${selectionResult.criteriaCount} ICP criteria persisted. Ask the user to approve the recommended scrape set once; after approval, call import_leads with targetEngagerCount ${recommendationTargetEngagerCount ?? "from the approved source math"} immediately and do not repeat this source card.`,
     };
 }
 export async function setHeadlineICPCriteria(input) {

package/dist/tools/registry.d.ts

@@ -3150,6 +3150,14 @@ export declare const allTools: ({
                 enum: string[];
                 description: string;
             };
+            targetEngagerCount: {
+                type: string;
+                description: string;
+            };
+            maxPostsToScrape: {
+                type: string;
+                description: string;
+            };
             currentStep: {
                 type: string[];
                 description: string;
@@ -3201,8 +3209,6 @@ export declare const allTools: ({
             sourceLeadListId?: undefined;
             targetLeadCount?: undefined;
             mode?: undefined;
-            targetEngagerCount?: undefined;
-            maxPostsToScrape?: undefined;
             tableId?: undefined;
             campaignName?: undefined;
             keepInSync?: undefined;

package/package.json

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

package/skills/create-campaign/SKILL.md

@@ -86,8 +86,8 @@ instruction loading, file lookup, plugin cache versions, missing linked files,
 or tool discovery. Start in product language:
 
 ```text
-I’ll help you launch this as a Sellable campaign. First I’ll resolve the
-client/company this campaign is for, then I’ll turn that into a campaign brief
+I’ll help you launch this as a Sellable campaign. First I’ll research the
+person/company this campaign is for, then I’ll turn that into a campaign brief
 before we move into lead sourcing.
 ```
 
@@ -163,11 +163,13 @@ precision, and referral paths, but it does not provide hiring-by-role filters;
 say that distinction plainly in the source-plan gate.
 
     After scouting, ask for a second approval on the concrete source action. For
-    LinkedIn engagement (`signal-discovery` internally), name how many selected
-    posts will be scraped and the target engager/source-candidate volume. For
-    Sales Nav or Prospeo, name the specific approved import lane and source lead
-    count. Keep the internal 15-row campaign-table execution slice separate from
-    source sampling.
+    LinkedIn engagement (`signal-discovery` internally), name how many
+    recommended posts will be scraped and the target engager/source-candidate
+    volume. N must be the smallest right-content post set that clears the source
+    target, not the default 3 promoted sample posts. For Sales Nav or Prospeo,
+    name the specific approved import lane and source lead count. Keep the
+    internal 15-row campaign-table execution slice separate from source
+    sampling.
 
 Do not call `import_leads` or `confirm_lead_list` until this second approval is
 granted.
@@ -185,8 +187,8 @@ granted.
     the campaign table and return the initial campaign-table execution slice rows.
 
 For LinkedIn engagement, the customer-facing approval card must use the exact
-action shape "Approve scraping N selected LinkedIn posts?" and the chat summary
-should be a compact `## Source Recommendation` block with:
+action shape "Approve scraping N recommended LinkedIn posts?" and the chat
+summary should be a compact `## Source Recommendation` block with:
 
 - goal: about 300 headline-fit prospects from relevant LinkedIn engagement
 - source-candidate plan: use sample math first: target headline-fit prospects
@@ -396,10 +398,10 @@ customer-facing progress copy.
 
 Do not treat the active Sellable workspace as the campaign subject. The
 workspace only tells you where the campaign will be saved. Before buyer, CTA,
-proof, or source questions, identify the campaign identity: the person/profile
-or company this campaign is for, plus enough company/product context to build
-the brief. This is only the client-prospect/bootstrap identity for
-`clientProspectId` or `senderLinkedinUrl`; it is not a connected-sender check.
+proof, or source questions, identify the person/profile or company this
+campaign is for, plus enough current company/product context to build the
+brief. This client/company lookup feeds `clientProspectId` or
+`senderLinkedinUrl`; it is not a connected-sender check.
 
 Do not call `mcp__sellable__list_senders`, `mcp__sellable__get_sender`, or
 surface connected/missing sender state during setup, brief, source, filter, or
@@ -423,19 +425,20 @@ first:
   only if a URL/domain is also available.
 
 Then summarize what you found in one or two lines and ask the user to confirm
-the campaign identity/focus before continuing. Do not mention connected sender
-availability in this confirmation.
+the current company/focus before continuing, especially if public website data
+may be stale. Do not mention connected sender availability in this confirmation.
 
 If the user did not provide the launch identity, ask in normal chat for the
-LinkedIn profile or company website to use as the campaign identity. Do not ask
+LinkedIn profile URL first, with the company website as the fallback. Do not ask
 them to choose an input type with the structured question tool:
 
 ```text
 I’m ready to build this in {workspace}.
 
-First, paste the LinkedIn profile or company website for the client/company this
-campaign is for. I’ll use that to resolve the campaign identity before we pick
-the target, offer, proof, and lead source.
+What is your LinkedIn profile URL? If you do not have it handy, send your
+company website instead. I’ll research the person and company from that, then
+ask you to correct anything stale before we pick the target, offer, proof, and
+lead source.
 ```
 
 After the user pastes a URL/domain, do the lightweight lookup. For a LinkedIn
@@ -445,10 +448,19 @@ most recent company from the profile. For a company website, call
 LinkedIn profile URL is available, retain it as `senderLinkedinUrl` for
 `create_campaign`; if a `clientProspectId` is available, pass that instead.
 
-After the user confirms the campaign identity, run one lightweight company
-lookup if it has not already run, then ask the campaign setup questions. The
-setup questions should use the confirmed company context so they do not feel
-generic.
+After the user confirms the company/focus, run one lightweight company lookup
+if it has not already run, then ask an offer-readiness question before inferred
+strategy hardens:
+
+```text
+Do you already know the offer for this campaign, should I use the researched
+recommendation, or should we shape the offer together? If the website is stale,
+tell me what is current before I build the brief.
+```
+
+The setup questions should use the confirmed company context so they do not feel
+generic. When you present a recommendation, introduce it as based on the
+research you just did and keep it editable.
 
 ### Sufficient Intake Bypass
 
@@ -476,9 +488,9 @@ If the invocation or any later user message explicitly asks for "yolo mode",
 me", "use best estimates", or "just run it", enable YOLO mode for the rest of
 the run. Treat YOLO as `interactionMode: "autonomous"` plus an intake policy:
 
-- If campaign identity is missing, ask only for the LinkedIn profile or company
-  website in normal chat; do not ask buyer, offer, proof, source, or filter setup
-  questions before that.
+- If the campaign subject is missing, ask only for the LinkedIn profile URL
+  first, with company website as the fallback, in normal chat; do not ask buyer,
+  offer, proof, source, or filter setup questions before that.
 - Treat any freeform directions already provided, or added later by the user, as
   operator directions for the rest of the run. If directions conflict, the newest
   user direction wins.
@@ -500,8 +512,9 @@ Before the identity gate, use this customer-facing shape:
 ```text
 I’m ready to build the campaign in {workspace}.
 
-First I’ll resolve the client/company this campaign is for. I’ll use that
-context to choose the target, offer, proof, and lead source.
+First I’ll research the person/company this campaign is for. I’ll use that
+context to recommend a target, offer, proof, and lead source, then you can
+correct anything stale before I build from it.
 
 Then I’ll turn that into a campaign brief for you to approve before any leads
 are sourced.
@@ -636,9 +649,9 @@ updates.
        ```text
        You're in — {activeWorkspaceName} workspace, ready to roll.
 
-       Now — paste the LinkedIn profile or company website for the client/company this campaign is for. I’ll use that to resolve the campaign identity before we pick the target, offer, proof, and lead source.
+      Now — what is your LinkedIn profile URL? If you do not have it handy, send your company website instead. I’ll research the person and company from that, then ask you to correct anything stale before we pick the target, offer, proof, and lead source.
 
-       e.g. https://example.com or https://www.linkedin.com/in/client-handle
+      e.g. https://www.linkedin.com/in/client-handle or https://example.com
        ```
 
      - If `isReturningUser === false`, prepend ONE line confirming the new
@@ -647,9 +660,9 @@ updates.
        ```text
        You're set up — your {activeWorkspaceName} workspace is ready.
 
-       Now — paste the LinkedIn profile or company website for the client/company this campaign is for. I’ll use that to resolve the campaign identity before we pick the target, offer, proof, and lead source.
+      Now — what is your LinkedIn profile URL? If you do not have it handy, send your company website instead. I’ll research the person and company from that, then ask you to correct anything stale before we pick the target, offer, proof, and lead source.
 
-       e.g. https://example.com or https://www.linkedin.com/in/client-handle
+      e.g. https://www.linkedin.com/in/client-handle or https://example.com
        ```
 
      No other lines. No "all set", no "signed in", no other acknowledgement.

package/skills/create-campaign-v2/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: create-campaign-v2
-description: Execute the compact JSON-gated shell-first campaign flow: resolve campaign identity, create a watchable CampaignOffer shell with the brief, attach and approve the source, copy the confirmed source list into the campaign, internally process the first campaign-table execution slice, persist rubrics and approved message template, validate the first passing generated message, then hand off to Settings, sequence, and start.
+description: Execute the compact JSON-gated shell-first campaign flow from client/offer resolution through source approval, sample/message review, Settings, sequence, and explicit start.
 visibility: internal
 ---
 
@@ -28,15 +28,14 @@ handoff read campaign state first: `campaignId`, `watchUrl`, `campaignBrief`,
 `currentStep`, source/search association, `selectedLeadListId`,
 `workflowTableId`, `leadScoringRubrics`, `approvedMessageTemplate`,
 `senderIds`, `sequenceTemplate`, and running state. Local draft files are
-legacy debug/UAT diagnostics only. In normal customer runs, do not create,
-read, link, or surface local draft artifacts unless the user explicitly asks
-for debug output.
+legacy debug/UAT only; do not create, link, or surface them in normal runs
+unless the user asks for debug output.
 
 ## Normal Flow
 
 1. Bootstrap and tell the user the active Sellable workspace.
-2. Resolve campaign identity before strategy questions.
-3. Research the client/company enough to draft a concrete brief.
+2. Resolve the client/company before strategy questions.
+3. Research the client/company and current offer enough to draft a concrete brief.
 4. Create the watchable campaign shell with `create_campaign` and the v1 brief.
 5. Surface the direct watch link.
 6. Choose and approve the lead source.
@@ -61,18 +60,22 @@ flows and the separate `create-campaign-v2-validation` subskill.
 ## Identity-First Campaign Setup
 
 Do not treat the active Sellable workspace as the campaign subject. Resolve the
-client/company first, then draft the buyer, offer, proof, and source plan.
+client/company first, confirm whether the user already has a current offer, then
+draft the buyer, offer, proof, and source plan.
 
 First visible request when no identity is known:
 
 ```text
-First, paste the LinkedIn profile or company website for the client/company this campaign is for.
+What is your LinkedIn profile URL? If you do not have it handy, send your company website instead.
 ```
 
 After the user pastes a URL/domain, retain it as `senderLinkedinUrl` or the
 resolved `clientProspectId` input for `create_campaign`. Use one lightweight
-profile/company lookup before strategy questions. If multiple product lines or
-offers are plausible, ask one campaign-focus choice before buyer/offer/proof.
+profile/company lookup before strategy questions, then say that public research
+may be stale and invite the user to correct it. Ask whether they already know
+the offer for this campaign, want Sellable's researched recommendation, or want
+to shape one together before buyer/offer/proof hardens. If multiple product
+lines or offers are plausible, ask one campaign-focus choice before the brief.
 
 Do not call `list_senders`, do not infer the campaign from connected senders,
 and do not show a sender picker during setup. Sender availability belongs only
@@ -83,13 +86,33 @@ Use `research-sender` for concise identity/proof research and call
 use the available Sellable profile/company/post tools and carry explicit proof
 gaps into the brief.
 
+## Brief Provenance
+
+When rendering the first brief, label the major strategic choices with compact
+source tags where the basis is known: `[from you]`, `[from LinkedIn]`,
+`[from website]`, `[from case study]`, or `[Sellable recommendation]`. Keep the
+tags lightweight; do not turn the brief into a research dump.
+
+Before asking for approval, say:
+
+```text
+This is based on what I found. If your site or LinkedIn is stale, tell me what
+to update before I build the lead list.
+```
+
+Ask: "Do you agree with this researched campaign direction?" The early brief
+must not include quoted first-message copy. If a message-shape hint is useful,
+keep it as non-final bullets and say: "This is not the message yet; I will write
+real examples after we find and filter leads."
+
 ## YOLO Mode
 
 Enable YOLO mode when the user asks for yolo/autopilot, passes `--yolo` or
 `mode=yolo`, or says to use best guesses/estimates and answer for them. Ask only
-for the LinkedIn profile or company website if identity is missing. After the
-identity lookup, infer buyer, offer/CTA, proof, source, filters, and message
-direction from company evidence plus user directions; newest directions win.
+for the LinkedIn profile URL first, with company website as the fallback, if the
+client/company is missing. After the lookup, infer buyer, offer/CTA, proof,
+source, filters, and message direction from company evidence plus user
+directions; newest directions win.
 Set `interactionMode: "autonomous"` once `campaignId` exists. Auto-select
 pre-launch choices when confidence is sufficient, but show the assumed choice
 briefly. Pause for missing credentials/data, failed quality floors, or final
@@ -186,9 +209,11 @@ After scouting, show a second approval gate for the concrete source action.
 For LinkedIn engagement (`signal-discovery` internally), state selected-post
 count, target engager/source-candidate volume, internal campaign-table
 execution-slice size, cleanup risk, and fallback; label the approval like
-"Approve scraping 3 selected LinkedIn posts?" For Sales Nav or Prospeo, name the
-specific search/import lane and source lead count. Do not call `import_leads` or
-`confirm_lead_list` until this gate is approved.
+"Approve scraping N recommended LinkedIn posts?" where N is the smallest
+right-content post set that clears the approved source-candidate target. Do not
+default to 3 just because `selectionTarget` was 3 for sampling. For Sales Nav or
+Prospeo, name the specific search/import lane and source lead count. Do not call
+`import_leads` or `confirm_lead_list` until this gate is approved.
 
 For Sales Nav and Prospeo, do not ask to import only the internal 15-row
 campaign-table execution slice at the source-action gate. First-page samples are