@sellable/mcp 0.1.256 → 0.1.257

package/dist/tools/engage-discovery.d.ts

@@ -7,6 +7,7 @@ export type EngagementPost = {
         name: string;
         headline: string;
         profileUrl: string;
+        followerCount: number | null;
     };
     engagement: {
         likes: number;
@@ -14,6 +15,16 @@ export type EngagementPost = {
         shares: number;
         total: number;
     };
+    reachSignals: {
+        targetFollowerMin: number | null;
+        targetFollowerMax: number | null;
+        followerBandFit: "in_target_band" | "below_target_band" | "above_target_band" | "unknown";
+        weightedEngagement: number;
+        engagementPer1kFollowers: number | null;
+        weightedEngagementPer1kFollowers: number | null;
+        reachPenaltyMultiplier: number;
+        reachAdjustedScore: number | null;
+    };
     contentPreview: string;
 };
 export type SearchEngagementPostsInput = {
@@ -22,6 +33,8 @@ export type SearchEngagementPostsInput = {
     maxAgeDays?: number;
     minTotalEngagement?: number;
     maxPosts?: number;
+    targetFollowerMin?: number;
+    targetFollowerMax?: number;
     excludePostUrls?: string[];
 };
 export type SearchEngagementPostsResponse = {
@@ -63,6 +76,14 @@ export declare const engageDiscoveryToolDefinitions: {
                 type: string;
                 description: string;
             };
+            targetFollowerMin: {
+                type: string;
+                description: string;
+            };
+            targetFollowerMax: {
+                type: string;
+                description: string;
+            };
             excludePostUrls: {
                 type: string;
                 items: {

package/dist/tools/engage-discovery.js

@@ -27,6 +27,14 @@ export const engageDiscoveryToolDefinitions = [
                     type: "number",
                     description: "Max posts to return after filtering (default 25).",
                 },
+                targetFollowerMin: {
+                    type: "number",
+                    description: "Optional lower bound for the author's follower count when comparing reach-normalized hook performance. Does not hard-filter; adds reach signals and prioritizes the target band when follower data is available.",
+                },
+                targetFollowerMax: {
+                    type: "number",
+                    description: "Optional upper bound for the author's follower count when comparing reach-normalized hook performance. Does not hard-filter; adds reach signals and prioritizes the target band when follower data is available.",
+                },
                 excludePostUrls: {
                     type: "array",
                     items: { type: "string" },
@@ -63,6 +71,101 @@ function safeNumber(value) {
     const n = typeof value === "number" ? value : Number(value);
     return Number.isFinite(n) ? n : 0;
 }
+function parseFollowerCount(value) {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return Math.round(value);
+    }
+    if (typeof value !== "string")
+        return null;
+    const cleaned = value.trim().toLowerCase().replace(/,/g, "");
+    if (!cleaned)
+        return null;
+    const match = cleaned.match(/(\d+(?:\.\d+)?)\s*([kmb])?/);
+    if (!match)
+        return null;
+    const base = Number(match[1]);
+    if (!Number.isFinite(base) || base <= 0)
+        return null;
+    const suffix = match[2] || "";
+    const multiplier = suffix === "b" ? 1_000_000_000 : suffix === "m" ? 1_000_000 : suffix === "k" ? 1_000 : 1;
+    return Math.round(base * multiplier);
+}
+function extractFollowerCount(post) {
+    const candidates = [
+        post?.author?.followerCount,
+        post?.author?.followersCount,
+        post?.author?.followers,
+        post?.author?.follower_count,
+        post?.author?.linkedinFollowers,
+        post?.author?.stats?.followers,
+        post?.followerCount,
+        post?.followersCount,
+        post?.followers,
+        post?.authorFollowerCount,
+    ];
+    for (const candidate of candidates) {
+        const parsed = parseFollowerCount(candidate);
+        if (parsed !== null)
+            return parsed;
+    }
+    return null;
+}
+function normalizeFollowerBound(value) {
+    const parsed = parseFollowerCount(value);
+    return parsed && parsed > 0 ? parsed : null;
+}
+function followerBandFit(followerCount, targetFollowerMin, targetFollowerMax) {
+    if (!followerCount)
+        return "unknown";
+    if (targetFollowerMin && followerCount < targetFollowerMin) {
+        return "below_target_band";
+    }
+    if (targetFollowerMax && followerCount > targetFollowerMax) {
+        return "above_target_band";
+    }
+    if (targetFollowerMin || targetFollowerMax)
+        return "in_target_band";
+    return "unknown";
+}
+function bandMultiplier(fit, followerCount, targetFollowerMax) {
+    if (fit === "in_target_band")
+        return 1;
+    if (fit === "below_target_band")
+        return 0.75;
+    if (fit === "unknown")
+        return 0.4;
+    if (!followerCount || !targetFollowerMax)
+        return 0.45;
+    if (followerCount <= targetFollowerMax * 2)
+        return 0.65;
+    if (followerCount <= targetFollowerMax * 5)
+        return 0.35;
+    return 0.15;
+}
+function reachSignals(engagement, followerCount, targetFollowerMin, targetFollowerMax) {
+    const weightedEngagement = engagement.likes + engagement.comments * 4 + engagement.shares * 12;
+    const fit = followerBandFit(followerCount, targetFollowerMin, targetFollowerMax);
+    const engagementPer1kFollowers = followerCount
+        ? Number(((engagement.total / followerCount) * 1000).toFixed(3))
+        : null;
+    const weightedEngagementPer1kFollowers = followerCount
+        ? Number(((weightedEngagement / followerCount) * 1000).toFixed(3))
+        : null;
+    const reachPenaltyMultiplier = bandMultiplier(fit, followerCount, targetFollowerMax);
+    const reachAdjustedScore = weightedEngagementPer1kFollowers === null
+        ? null
+        : Number((weightedEngagementPer1kFollowers * reachPenaltyMultiplier).toFixed(3));
+    return {
+        targetFollowerMin,
+        targetFollowerMax,
+        followerBandFit: fit,
+        weightedEngagement,
+        engagementPer1kFollowers,
+        weightedEngagementPer1kFollowers,
+        reachPenaltyMultiplier,
+        reachAdjustedScore,
+    };
+}
 export async function searchEngagementPosts(input) {
     const api = getApi();
     const keywords = (input.keywords || [])
@@ -79,6 +182,10 @@ export async function searchEngagementPosts(input) {
     const maxPosts = typeof input.maxPosts === "number" && input.maxPosts > 0
         ? Math.min(50, input.maxPosts)
         : 25;
+    const targetFollowerMin = normalizeFollowerBound(input.targetFollowerMin);
+    const targetFollowerMax = normalizeFollowerBound(input.targetFollowerMax);
+    const useTargetFollowerBand = Boolean(targetFollowerMin || targetFollowerMax);
+    const collectLimit = useTargetFollowerBand ? 50 : maxPosts;
     const exclude = new Set((input.excludePostUrls || [])
         .map((u) => normalizePostUrl(u))
         .filter(Boolean));
@@ -87,11 +194,13 @@ export async function searchEngagementPosts(input) {
         keywords: keywords.map((keyword) => ({ keyword })),
         page,
     });
-    const rawPosts = Array.isArray(response?.topPostsForLLM)
-        ? response.topPostsForLLM
-        : Array.isArray(response?.posts)
-            ? response.posts
-            : [];
+    const rawPosts = useTargetFollowerBand && Array.isArray(response?.posts)
+        ? response.posts
+        : Array.isArray(response?.topPostsForLLM)
+            ? response.topPostsForLLM
+            : Array.isArray(response?.posts)
+                ? response.posts
+                : [];
     const now = Date.now();
     const oldestMs = now - maxAgeDays * 24 * 60 * 60 * 1000;
     let tooOld = 0;
@@ -111,6 +220,7 @@ export async function searchEngagementPosts(input) {
         const comments = safeNumber(p?.engagement?.comments);
         const shares = safeNumber(p?.engagement?.shares);
         const total = likes + comments + shares;
+        const engagement = { likes, comments, shares, total };
         if (total < minTotalEngagement) {
             tooLowEngagement += 1;
             continue;
@@ -121,6 +231,7 @@ export async function searchEngagementPosts(input) {
             tooOld += 1;
             continue;
         }
+        const followerCount = extractFollowerCount(p);
         kept.push({
             postId: String(p?.id || ""),
             url,
@@ -132,15 +243,31 @@ export async function searchEngagementPosts(input) {
                 name: String(p?.author?.name || ""),
                 headline: String(p?.author?.headline || ""),
                 profileUrl: String(p?.author?.profileUrl || ""),
+                followerCount,
             },
-            engagement: { likes, comments, shares, total },
+            engagement,
+            reachSignals: reachSignals(engagement, followerCount, targetFollowerMin, targetFollowerMax),
             contentPreview: previewText(String(p?.content || ""), 220),
         });
-        if (kept.length >= maxPosts)
+        if (kept.length >= collectLimit)
             break;
     }
-    // Sort by total engagement desc for a predictable shortlist.
-    kept.sort((a, b) => b.engagement.total - a.engagement.total);
+    if (useTargetFollowerBand) {
+        kept.sort((a, b) => {
+            const scoreDelta = (b.reachSignals.reachAdjustedScore ?? -1) -
+                (a.reachSignals.reachAdjustedScore ?? -1);
+            if (scoreDelta !== 0)
+                return scoreDelta;
+            return b.engagement.total - a.engagement.total;
+        });
+    }
+    else {
+        // Sort by total engagement desc for a predictable shortlist.
+        kept.sort((a, b) => b.engagement.total - a.engagement.total);
+    }
+    if (kept.length > maxPosts) {
+        kept.length = maxPosts;
+    }
     return {
         success: true,
         posts: kept,

package/dist/tools/registry.d.ts

@@ -1742,6 +1742,14 @@ export declare const allTools: ({
                 type: string;
                 description: string;
             };
+            targetFollowerMin: {
+                type: string;
+                description: string;
+            };
+            targetFollowerMax: {
+                type: string;
+                description: string;
+            };
             excludePostUrls: {
                 type: string;
                 items: {

package/package.json

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

package/skills/create-post/SKILL.md

@@ -321,6 +321,7 @@ The research worker must return a compact packet only:
 - full adapted hook blocks
 - market belief map: resonating ideas, implicit beliefs, audience wants, resentments, fears, and credible controversy angles
 - premise inputs: real scenes, observed tensions, reader value openings, and proof gaps
+- reach-normalized signal notes, including follower-band fit when available
 - exact phrase patterns and sentence shapes
 - body structures and exact body language moves
 - rendered mobile and desktop preview records
@@ -334,11 +335,11 @@ the exact extracted phrase shapes.
 Default flow:
 
 1. Convert the idea into 3-8 search keywords.
-2. Call `mcp__sellable__search_engagement_posts` with an explicit multi-month window. Default to `maxAgeDays: 120`, tightening to 30-60 days only when the topic is trend-sensitive.
-3. Shortlist high-engagement posts by topic fit, hook strength, creator repeat evidence, and weighted engagement quality.
-4. Because search results may only include previews, call `mcp__sellable__fetch_linkedin_posts` for shortlisted authors/profile URLs and match recent posts by URL/activity ID when full text is needed.
+2. Call `mcp__sellable__search_engagement_posts` with an explicit multi-month window. Default to `maxAgeDays: 120`, tightening to 30-60 days only when the topic is trend-sensitive. When the user gives a follower range, pass it as `targetFollowerMin` and `targetFollowerMax`; for example, "8k-20k followers" means `targetFollowerMin: 8000` and `targetFollowerMax: 20000`.
+3. Shortlist posts by topic fit, rendered hook strength, content pattern replicability, creator repeat evidence, weighted engagement quality, and reach-normalized signal quality. Do not sort by raw engagement alone, and do not let the numeric reach score choose the final hook by itself.
+4. Because search results may only include previews, call `mcp__sellable__fetch_linkedin_posts` for shortlisted authors/profile URLs and match recent posts by URL/activity ID when full text is needed. If a promising source is missing follower count and the user requested reach normalization, call `mcp__sellable__fetch_linkedin_profile` on a bounded shortlist before treating the source as a keeper.
 5. If full text cannot be matched, record `full_text_unavailable` and use only the preview. Do not invent missing body details.
-6. Weigh shares/reposts above comments, comments above reactions, and reactions as weak reach unless paired with stronger signals. If shares/reposts are unavailable, record `repost_data_unavailable`.
+6. Weigh shares/reposts above comments, comments above reactions, and reactions as weak reach unless paired with stronger signals. Normalize engagement against follower count when available: record `authorFollowerCount`, `targetFollowerBand`, `followerBandFit`, `engagementPer1kFollowers`, `weightedEngagementPer1kFollowers`, `reachPenaltyMultiplier`, `reachAdjustedScore`, and `baselineLift` when repeated creator posts make it possible. If follower count is unavailable, record `follower_count_unavailable`; if shares/reposts are unavailable, record `repost_data_unavailable`.
 7. Penalize lead-magnet or giveaway mechanics unless the user explicitly asks for a lead magnet post.
 8. Build a market belief map before hook generation: what the space is rewarding, what the audience implicitly believes, what they want permission to say, what they resent or fear, what they will argue with, and which controversial angle the user can credibly own. If the user's raw idea is internally coherent but not attached to a live market tension, do not draft from the internal idea alone; present stronger directions or rewrite the draft angle around the external tension.
 9. Extract premise inputs: real story/scene possibilities, observed tensions, useful reader takeaways, and proof gaps. A good hook cannot rescue a premise with no value.
@@ -356,7 +357,9 @@ Record provenance:
 - search window
 - source post URLs
 - authors/profile URLs
+- author follower counts and target follower-band fit when available
 - engagement totals and available likes/comments/shares breakdown
+- reach-normalized scoring fields and confidence notes
 - creator repeat evidence
 - lead-magnet or engagement-bait penalties
 - story mechanism when relevant
@@ -369,6 +372,11 @@ Record provenance:
 - exact phrase patterns and sentence shapes
 - body structures and body language patterns
 - why each pattern fits the user's idea and voice
+- `whyTheHookCarries`: why the selected hook works from the words, tension, and
+  content pattern independent of the source creator's reach
+- `whyTheReachEvidenceIsTrustworthy`: follower-band fit, reach-adjusted score,
+  baseline lift, share/comment quality, or why a large-account example is only
+  secondary pattern evidence
 
 ## Step 1.5: Research Learning Report
 
@@ -394,6 +402,9 @@ Research status:
 - keywords:
 - full-text coverage:
 - repost/share data:
+- target follower band:
+- reach-normalized winners:
+- big-account examples used only as secondary pattern evidence:
 
 Best source examples:
 1. author, URL, engagement, why kept, why not copied

package/skills/create-post/references/hook-research-playbook.md

@@ -28,6 +28,7 @@ Worker owns:
 - tracked-person post fetches
 - full-text matching by URL/activity ID
 - duplicate removal
+- follower-band and reach-normalized signal scoring
 - lead-magnet, giveaway, engagement-bait, and off-voice filtering
 - market belief mapping across kept and rejected examples
 - premise input extraction: real scenes, observed tensions, reader value, proof gaps
@@ -58,6 +59,7 @@ Research packet:
 - exact phrase patterns: max 20
 - body patterns: max 8
 - source URLs and author profile URLs
+- reach-normalized signal notes
 - rendered preview records
 - confidence gaps
 - save recommendations
@@ -74,6 +76,13 @@ Use `mcp__sellable__search_engagement_posts` with practical constraints:
 
 - explicit `maxAgeDays: 120` by default so research covers the past 30-120 days, not only this week's posts
 - tighten to 30-60 days for trend-sensitive topics; widen only when the topic has low volume
+- when the user gives a follower range, pass it as `targetFollowerMin` and
+  `targetFollowerMax` so the tool can expose reach-normalized signals and
+  prioritize comparable creators
+- if a source hook looks promising but follower count is missing, use
+  `mcp__sellable__fetch_linkedin_profile` on a bounded shortlist before calling
+  the source a keeper; if profile fetch is unavailable or too slow, mark
+  `follower_count_unavailable`
 - high enough engagement to matter
 - narrow enough to match the idea
 - enough result depth to see whether a creator has repeated winners, not just one viral outlier
@@ -82,14 +91,19 @@ Record every keyword, filter, search window, page, and result count.
 
 ## Weighted Signals
 
-Rank source posts with a weighted signal view. Do not sort by total engagement alone.
+Rank source posts with a weighted signal view. Do not sort by total engagement
+alone. Use the numeric score to decide which sources deserve study; do not let
+the number choose the final hook by itself.
 
 Use this scoring shape:
 
 ```text
 hook_score =
   topic_fit
+  + rendered_mobile_preview_strength
   + hook_clarity
+  + content_pattern_replicability
+  + reach_adjusted_evidence
   + creator_repeat_success
   + repost_share_strength
   + comment_quality
@@ -107,6 +121,135 @@ Guidance:
 - If share or repost data is unavailable, record `repost_data_unavailable` instead of inventing it.
 - Prefer creators with repeated high-performing posts in the same lane over one-off viral posts.
 
+## Reach-Normalized Hook Scoring
+
+Raw engagement is not the clearest signal when source creators have wildly
+different audience sizes. A post from a 100k+ follower creator can win on
+distribution even when the hook is ordinary. A post from a creator near the
+user's follower range that overperforms is a clearer signal that LinkedIn and
+readers rewarded the hook/premise.
+
+This calculation is a source-quality filter, not the final creative decision.
+After reach is controlled, the LLM still chooses the hooks to steal based on the
+visible hook, rendered first-screen promise, content pattern, premise fit, and
+whether the idea can carry without the source creator's distribution.
+
+When the user gives a target range, default to that range. For example, if the
+user says "8k to 20k followers," call `mcp__sellable__search_engagement_posts`
+with:
+
+```text
+targetFollowerMin: 8000
+targetFollowerMax: 20000
+```
+
+If the user gives no range, use the user's known follower count from memory or
+ask only when the decision depends on it. If no follower count is available, use
+raw engagement as a fallback and mark `target_follower_band_unknown`.
+
+For every shortlisted source post, record:
+
+- `authorFollowerCount`
+- `targetFollowerBand`
+- `followerBandFit`: `in_target_band`, `below_target_band`,
+  `above_target_band`, or `unknown`
+- `engagementPer1kFollowers`
+- `weightedEngagementPer1kFollowers`
+- `reachAdjustedScore`
+- `creatorBaselineMedianEngagement` when repeated posts from that creator are
+  available
+- `baselineLift`: this post's engagement divided by the creator's recent median
+  engagement in the same lane, or `creator_baseline_unavailable`
+- `confidence`: `high`, `medium`, or `low`
+- `normalizationNotes`
+
+Use this Harvest-compatible calculation when follower counts are available:
+
+```text
+weightedEngagement =
+  likes
+  + (comments * 4)
+  + (shares * 12)
+
+engagementPer1kFollowers =
+  totalEngagement / authorFollowerCount * 1000
+
+weightedEngagementPer1kFollowers =
+  weightedEngagement / authorFollowerCount * 1000
+
+reachPenaltyMultiplier =
+  1.00 when in target follower band
+  0.75 when below target band
+  0.65 when above target band but <= 2x target max
+  0.35 when above target band but <= 5x target max
+  0.15 when above target band and > 5x target max
+  0.40 when follower count is unknown
+
+reachAdjustedScore =
+  weightedEngagementPer1kFollowers * reachPenaltyMultiplier
+```
+
+When repeated posts from the same creator are available, calculate:
+
+```text
+creatorBaselineMedianEngagement =
+  median weightedEngagement across recent same-lane posts
+
+baselineLift =
+  post weightedEngagement / creatorBaselineMedianEngagement
+```
+
+Use this scoring shape when deciding which hooks to study:
+
+```text
+hook_score =
+  topic_fit
+  + rendered_mobile_preview_strength
+  + hook_clarity
+  + same_follower_band_bonus
+  + weighted_engagement_per_1k_followers
+  + creator_baseline_lift
+  + repost_share_strength
+  + substantive_comment_quality
+  + creator_repeat_success
+  - celebrity_reach_penalty
+  - tiny_sample_penalty
+  - lead_magnet_penalty
+  - engagement_bait_penalty
+  - off_voice_penalty
+```
+
+Rules:
+
+- Prefer in-band creators when the hook is strong and the engagement is real.
+- Use near-band creators as secondary evidence.
+- Penalize creators far above the target range, especially accounts above 5x
+  the target max or above 100k followers when the target range is 8k-20k.
+- Do not automatically reject large-account posts; they can still teach body
+  structure, topic heat, or category language. Do not treat them as primary hook
+  proof unless they also overperform their creator baseline.
+- Large-account hooks can be selected only when the hook carries without the
+  creator: the rendered mobile opening is strong, the premise is reusable by the
+  user, the body pattern does not depend on celebrity authority, and the source
+  either beats baseline or has unusually high reach-adjusted quality after the
+  penalty.
+- Do not overvalue tiny-account anomalies. Very high engagement per follower
+  with low absolute engagement is interesting but lower confidence.
+- When follower data is unavailable, do not invent it. Mark
+  `follower_count_unavailable`, lower confidence, and rely more on creator repeat
+  evidence, repost/share strength, comment quality, and rendered preview quality.
+- A source hook is strongest when it is in/near the target follower band, has
+  real absolute engagement, beats the creator's apparent baseline, has
+  share/comment quality, and passes rendered mobile preview.
+
+Final hook selection must explain both:
+
+- `whyTheHookCarries`: the visible words, specificity, tension, and first-screen
+  promise that work independent of reach
+- `whyTheReachEvidenceIsTrustworthy`: follower-band fit, reach-adjusted score,
+  baseline lift, share/comment quality, or why a large-account example is only
+  secondary pattern evidence
+
 Penalize lead-magnet and engagement-bait mechanics unless the user explicitly asks for that style:
 
 - `comment "template"` / `comment "guide"` / `comment "playbook"`
@@ -283,7 +426,10 @@ For each shortlisted source post, record:
 - URL
 - author
 - author profile URL when available
+- author follower count and follower-band fit when available
 - engagement totals and available likes/comments/shares breakdown
+- reach-normalized metrics: engagement per 1k followers, weighted engagement
+  per 1k followers, reach-adjusted score, baseline lift, and confidence
 - creator repeat evidence
 - visible hook text or preview
 - rendered preview fields from the section above
@@ -296,6 +442,7 @@ For each shortlisted source post, record:
 - proof/story dependency
 - lead magnet or engagement bait penalty
 - weighted signal notes
+- reach-normalized signal notes
 - replicability score
 - track person recommendation: `yes`, `no`, or `ask_user`
 - tracking reason when recommended

package/skills/create-post/references/post-file-contract.md

@@ -59,6 +59,11 @@ Hook research files must preserve:
 - source post URLs
 - author/profile URLs
 - engagement totals
+- author follower counts when available, target follower band, follower-band
+  fit, engagement per 1k followers, weighted engagement per 1k followers,
+  reach penalty multiplier, reach-adjusted score, baseline lift when available,
+  why the hook carries independent of creator reach, and normalization
+  confidence notes
 - full-text availability
 - source hook preview measurements, including text basis, char count including
   newlines, physical/content line counts, longest nonblank line, blank-line

package/skills/create-post/references/post-validation.md

@@ -11,6 +11,7 @@ Every saved draft needs a validation receipt. A draft without this receipt is no
 - `candidateHooksConsidered`
 - `selectedHook`
 - `selectedHookWhy`
+- `sourceHookReachAudit`
 - `proofClaimsUsed`
 - `proofClaimSources`
 - `storyFilesConsulted`
@@ -77,6 +78,10 @@ Each candidate should include:
 - premise tension opened
 - reader value implied
 - source pattern
+- source pattern reach signals: author follower count when available, target
+  follower band, follower-band fit, engagement per 1k followers, weighted
+  engagement per 1k followers, reach-adjusted score, baseline lift, and
+  confidence
 - score
 - `renderedPreview` using `references/linkedin-preview-rendering.md`
 - literal mobile and desktop rendered preview blocks
@@ -153,6 +158,35 @@ If `selectedControversy` is missing, if the audience belief is only a generic
 label like "founders want growth," or if `credibleWhyUs` depends on borrowed
 proof from another creator, save as `needs_revision`.
 
+## Source Hook Reach Audit
+
+Before a draft can be `ready`, validate that the selected source hook pattern
+was chosen for a reach-normalized reason, not raw audience size.
+
+Record:
+
+- `targetFollowerBand`
+- `authorFollowerCount` for each source pattern when available
+- `followerBandFit`: `in_target_band`, `below_target_band`,
+  `above_target_band`, or `unknown`
+- `engagementPer1kFollowers`
+- `weightedEngagementPer1kFollowers`
+- `reachAdjustedScore`
+- `reachPenaltyMultiplier`
+- `creatorBaselineMedianEngagement` or `creator_baseline_unavailable`
+- `baselineLift` or `creator_baseline_unavailable`
+- `bigAccountPenaltyApplied`
+- `whyTheHookCarries`
+- `followerCountUnavailableSources`
+- `whyThisHookIsAReachAdjustedSignal`
+
+If the user asked for a follower range and the selected source pattern is from a
+large account above the target range, the receipt must explain why it survived
+the celebrity reach penalty. Use large-account hooks as secondary pattern
+evidence unless they clearly overperform the creator's baseline or the hook
+itself carries after reach is controlled. A draft cannot be `ready` when the
+selected hook is justified only by raw total engagement or follower count.
+
 ## LinkedIn Preview Audit
 
 Audit the selected hook and top candidates against