@sellable/mcp 0.1.256 → 0.1.258

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.258",
   "type": "module",
   "description": "Sellable MCP server for Claude Code and Codex campaign workflows",
   "main": "dist/index.js",

package/skills/create-post/SKILL.md

@@ -60,8 +60,9 @@ Do:
 
 - capture rough ideas, voice memos, freestyle notes, and ad hoc prompts
 - research currently working LinkedIn hooks
+- reverse engineer why source hooks work, what shape to keep, and what not to copy
 - develop premise cards with real story/observed tension and reader value
-- generate hook candidates
+- explore many hook angle territories before choosing the winning hook
 - draft a post body that stays true to the source idea
 - run validation before calling a draft ready
 - save ideas, hook research, drafts, and published records under `~/.sellable/content/linkedin/**`
@@ -318,9 +319,13 @@ and drafting gate.
 The research worker must return a compact packet only:
 
 - source examples kept and rejected
+- hook reverse-engineering autopsies: why each source hook works, which shape to
+  keep, what not to copy, and what payoff the body must deliver
 - full adapted hook blocks
+- angle territories tested before drafting
 - 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,20 +339,24 @@ 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.
 10. For story posts, extract the story mechanism that made the post work, not just the first line.
 11. Extract hook structures plus specific reusable words, phrases, sentence
    shapes, transitions, and body language patterns.
-12. Render each kept source hook and adapted hook block through the LinkedIn
+12. For each keeper, create a `hookAutopsy`: the source mechanism, open-loop
+   type, click question, promised payoff, specificity anchor, tension opened,
+   source shape to keep, source words not to copy, and adaptation rule for the
+   user's idea.
+13. Render each kept source hook and adapted hook block through the LinkedIn
    preview rendering contract. Character counts alone are not enough.
-13. Save the research with `mcp__sellable__save_hook_research`.
+14. Save the research with `mcp__sellable__save_hook_research`.
 
 Record provenance:
 
@@ -356,7 +365,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
@@ -364,11 +375,19 @@ Record provenance:
 - source hook rendered preview records and whether they came from full text,
   authenticated LinkedIn screenshots, or a search preview
 - selected hook patterns
+- hook reverse-engineering autopsies, including `clickQuestion`,
+  `promisedPayoff`, `sourceShapeToKeep`, `sourceWordsNotToCopy`, and
+  `adaptationRule`
 - market belief map and selected controversy
 - premise cards and selected premise
 - 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 +413,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
@@ -414,6 +436,11 @@ Premise cards:
 Hook patterns learned:
 1. full adapted hook block
    - source mechanism:
+   - open-loop type:
+   - click question:
+   - promised payoff:
+   - source shape to keep:
+   - source words not to copy:
    - rendered preview:
      - mobile visible block:
      - desktop visible block:
@@ -445,9 +472,9 @@ Save recommendations:
 - gold-standard candidates:
 
 Recommended draft directions:
-1. premise card + hook block + body structure
-2. premise card + hook block + body structure
-3. premise card + hook block + body structure
+1. premise card + hook territory + hook block + click question + body structure
+2. premise card + hook territory + hook block + click question + body structure
+3. premise card + hook territory + hook block + click question + body structure
 ```
 
 Keep this report concise enough to read, but concrete enough that another agent
@@ -481,16 +508,32 @@ unless the premise still has concrete reader value.
 
 ## Step 2: Hook Candidates
 
-Generate at least 12 hook candidates from the selected premise unless the user
-requested a smaller set. Do not generate hooks directly from the raw idea before
-the premise is selected.
+Generate a hook angle matrix from the selected premise before writing the post
+body. Do not generate hooks directly from the raw idea before the premise is
+selected.
+
+Minimum exploration:
+
+- normal drafting: at least 8 distinct angle territories and 24 hook candidates
+- hook-critical requests, "nail the hook," "a ton of angles," or space research:
+  at least 12 distinct angle territories and 40 hook candidates
+- smaller set only when the user explicitly asks for fewer options
+
+Angle territories must be genuinely different. Use options such as enemy/tool
+contrast, hidden asset, first-person build proof, workflow reveal, contrarian
+category claim, mistake/confession, market timing, operator pain,
+asset/free-reveal without comment bait, specific person/company signal,
+before/after transformation, and question hook.
 
 Each hook must include:
 
 - selected premise
+- angle territory
 - premise tension opened
 - reader value implied
 - source hook pattern
+- source shape kept
+- source words not copied
 - why it fits this idea
 - `renderedPreview` using `references/linkedin-preview-rendering.md`
 - `mobileRenderedPreviewBlock`
@@ -498,6 +541,12 @@ Each hook must include:
 - `mobileRenderedLines`
 - `desktopRenderedLines`
 - `firstScreenPromise`
+- `intentionalOpenLoop`
+- `specificClickQuestionVisible`
+- `seeMoreClickReason`
+- `clickQuestion`
+- `payoffAfterFold`
+- `bodyProofObligation`
 - `corePainProofOrCuriosityVisibleMobile`
 - `corePointVisibleMobile`
 - `pointAfterMobileClamp`
@@ -517,6 +566,8 @@ Each hook must include:
 - `rewriteIfTruncated`
 - proof/story dependency
 - AI-tell risk
+- why it should win
+- why it should lose
 - score
 
 Do not copy source wording. Copy only the structure.
@@ -537,23 +588,28 @@ available:
 Use the rendered gates from `references/linkedin-preview-rendering.md`:
 
 - `pass`: the mobile rendered preview shows the pain, proof, or curiosity by
-  the end of the first 3 rendered lines, and the core point is understandable
-  without opening "see more".
+  the end of the first 3 rendered lines, and either the core point is
+  understandable without opening "see more" or an intentional open loop creates
+  a specific click question with an immediate planned payoff.
 - `warn`: the mobile rendered preview creates useful curiosity but the core
-  point is slightly softened by wrapping, blank-line rhythm, or one missing
-  context word. A compact fallback is required.
+  point or click question is slightly softened by wrapping, blank-line rhythm,
+  or one missing context word. A compact fallback is required.
 - `fail`: the hook's real point appears after the first 3 mobile rendered
-  lines, the first rendered line is generic setup, blank lines consume the
-  preview before the reader sees the point, or desktop fit is the only reason it
-  looks good.
+  lines without an intentional open-loop plan, the visible open loop is vague,
+  the first rendered line is generic setup, blank lines consume the preview
+  before the reader sees the point, or desktop fit is the only reason it looks
+  good.
 
 Desktop preview usually has more room. Still record `desktopPreviewFit`, but
 never let desktop fit compensate for a mobile `fail`.
 
 If a hook's point depends on text after the rendered mobile preview clamp,
-rewrite it before selecting it. A selected hook may carry a `warn` only when
-the warning is explicit and the validation receipt includes a compact fallback.
-A hook with no rendered mobile and desktop preview record cannot be selected.
+rewrite it before selecting it unless the hook is intentionally using a
+see-more open loop. Intentional open loops must show a specific click question
+inside the mobile clamp and must define the first payoff line after the fold. A
+selected hook may carry a `warn` only when the warning is explicit and the
+validation receipt includes a compact fallback. A hook with no rendered mobile
+and desktop preview record cannot be selected.
 
 ## Step 3: Draft
 
@@ -583,6 +639,9 @@ Every saved draft needs a validation receipt with:
 - selected premise card
 - candidate hooks considered
 - selected hook and why
+- hook reverse-engineering audit
+- hook angle matrix summary
+- see-more click audit
 - proof claims used and source
 - story/proof files consulted
 - gold standards consulted

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
@@ -54,10 +55,13 @@ Research packet:
 - market belief map: max 8 bullets
 - controversy candidates: max 8
 - premise inputs: max 8
+- hook reverse-engineering autopsies: max 12
 - full adapted hook blocks: max 12
+- angle territories tested: max 12
 - 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 +78,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 +93,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 +123,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"`
@@ -118,6 +263,104 @@ Penalize lead-magnet and engagement-bait mechanics unless the user explicitly as
 - "like and comment"
 - broad giveaway framing that makes engagement inflate without proving the hook/body worked
 
+## Hook Reverse Engineering Autopsy
+
+For any space or LinkedIn topic, do not stop at "this is a good hook." Reverse
+engineer why the opening earned attention, which shape can be reused, and which
+parts belong to the source and must not be copied.
+
+For each keeper source hook, record a `hookAutopsy`:
+
+```text
+hookAutopsy:
+  sourceHook: <exact visible opening used for analysis>
+  renderedFirstScreen: <mobile and desktop visible blocks>
+  sourceMechanism: <what the hook does structurally>
+  openLoopType: none | hidden_payoff | contradiction | proof_gap | workflow_reveal | asset_reveal | story_gap
+  clickQuestion: <the question a reader has before clicking see more>
+  promisedPayoff: <what the body/video must deliver after the click>
+  curiosityGap: <what is withheld and why that is fair>
+  specificityAnchor: <tool, person, number, object, scene, or enemy named>
+  tensionOpened: <belief, resentment, fear, status, cost, or contradiction>
+  proofImplied: <what proof the source suggests in the first screen>
+  whyItWorks: <specific words and structure, not a vibe label>
+  whyItMightBeInflated: <reach, giveaway, celebrity, outrage, or topic heat>
+  sourceShapeToKeep: <portable structure, written as a template>
+  sourceWordsNotToCopy: <phrases, jokes, proof, or context owned by source>
+  adaptationRule: <how to make it true for the user's idea and voice>
+```
+
+Good `sourceShapeToKeep` examples:
+
+- "The best [desired asset] I have right now is not in [default tool]."
+- "I gave [system/person] one prompt: [specific request]."
+- "[Common vanity metric] is useless until it becomes [business outcome]."
+- "I built [familiar workflow] inside [new interface]."
+- "Most teams [surface behavior]. Then they miss [hidden opportunity]."
+
+Bad autopsies:
+
+- "contrarian hook"
+- "strong curiosity"
+- "good storytelling"
+- "viral format"
+
+Those labels are allowed only after the concrete shape, click question, and
+payoff obligation are recorded.
+
+## Angle Exploration Before Drafting
+
+After selecting a premise, create a hook angle matrix before drafting the post.
+This is mandatory when the user asks to nail the hook, study hooks, explore a
+space, or write from a specific idea.
+
+Default matrix:
+
+- at least 8 angle territories for normal drafting
+- at least 12 angle territories when the user asks for "a ton of angles" or
+  says the hook is the main constraint
+- at least 24 generated hooks across those territories for normal drafting
+- at least 40 generated hooks when the user explicitly asks to optimize hooks
+
+Angle territories should be materially different, not synonyms. Use territories
+such as:
+
+- enemy/tool contrast
+- hidden asset
+- first-person build proof
+- workflow reveal
+- contrarian category claim
+- mistake/confession
+- market timing
+- customer/operator pain
+- asset/free reveal without comment bait
+- specific person/company signal
+- before/after transformation
+- question hook
+
+For each territory, record:
+
+```text
+angleTerritory:
+  name:
+  sourceShapesUsed:
+  premiseTensionOpened:
+  readerValueImplied:
+  bestHook:
+  mobileRenderedPreview:
+  desktopRenderedPreview:
+  clickQuestion:
+  payoffAfterFold:
+  whyThisAngleShouldWin:
+  whyThisAngleShouldLose:
+  proofNeeded:
+```
+
+Do not write the post body until the winning hook territory is chosen. The post
+body must then pay off the selected hook quickly. If the best hook says the list
+is not in Apollo, the next lines must reveal where it is. If the hook says "I
+gave Sellable one prompt," the next lines must show the prompt or the demo.
+
 ## Market Belief Map
 
 Before selecting a hook or writing a draft, synthesize a market belief map from
@@ -239,6 +482,12 @@ For each source, record:
 - `corePainProofOrCuriosityVisibleDesktop`
 - `corePointVisibleMobile`
 - `corePointVisibleDesktop`
+- `intentionalOpenLoop`
+- `specificClickQuestionVisible`
+- `payoffPlannedImmediatelyAfterClamp`
+- `seeMoreClickReason`
+- `clickQuestion`
+- `payoffAfterFold`
 - `pointAfterMobileClamp`
 - `charCountIncludingNewlines`
 - `physicalLineCount`
@@ -252,6 +501,7 @@ For each source, record:
 - `desktopPreviewBudget`: `pass`, `warn`, or `fail`
 - `blankLineVisualRisk`
 - `corePointBeforeLikelyTruncation`
+- `openLoopType`
 - `renderedPreviewVerdict`: `pass`, `warn`, or `fail`
 
 If only a search preview is available, do not pretend the opening is complete.
@@ -261,15 +511,17 @@ appears cut off or body context is unavailable.
 Pass/warn/fail is based on rendered output:
 
 - `pass`: the mobile rendered preview shows the pain, proof, or curiosity by
-  the end of the first 3 rendered lines, and the core point is understandable
-  without opening "see more".
+  the end of the first 3 rendered lines, and either the core point is
+  understandable without opening "see more" or an intentional open loop creates
+  a specific click question with an immediate planned payoff.
 - `warn`: the mobile rendered preview creates useful curiosity but the core
-  point is slightly softened by wrapping, blank-line rhythm, or one missing
-  context word. A compact fallback is required.
+  point or click question is slightly softened by wrapping, blank-line rhythm,
+  or one missing context word. A compact fallback is required.
 - `fail`: the hook's real point appears after the first 3 mobile rendered
-  lines, the first rendered line is generic setup, blank lines consume the
-  preview before the reader sees the point, or desktop fit is the only reason it
-  looks good.
+  lines without an intentional open-loop plan, the visible open loop is vague,
+  the first rendered line is generic setup, blank lines consume the preview
+  before the reader sees the point, or desktop fit is the only reason it looks
+  good.
 
 ## Hook Extraction
 
@@ -283,7 +535,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 +551,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/linkedin-preview-rendering.md

@@ -63,6 +63,10 @@ renderedPreview:
     blankLinesBeforeClamp: <number>
     corePainProofOrCuriosityVisible: true | false
     corePointVisible: true | false
+    intentionalOpenLoop: true | false
+    specificClickQuestionVisible: true | false
+    payoffPlannedImmediatelyAfterClamp: true | false
+    seeMoreClickReason: <why a reader would click see more>
     seeMoreRisk: pass | warn | fail
     screenshotPath: <optional local path>
   desktop:
@@ -88,6 +92,7 @@ renderedPreview:
     longestNonblankLineChars: <number>
     blankLineVisualRisk: none | low | medium | high
     pointAfterMobileClamp: true | false
+    openLoopType: none | hidden_payoff | contradiction | proof_gap | workflow_reveal | asset_reveal | story_gap
     rewriteIfTruncated: <short fallback>
 ```
 
@@ -112,31 +117,39 @@ For generated hooks:
 
 - Generate the hook from the selected premise first.
 - Render the hook for mobile and desktop before scoring it.
-- Score the rendered first-screen promise before scoring cleverness.
-- Rewrite any candidate whose real point appears after the mobile clamp.
+- Score the rendered first-screen click reason before scoring cleverness.
+- If the goal is see-more clicks, the hook may intentionally hide the payoff
+  after the mobile clamp, but the visible block must create a specific question
+  the target reader wants answered.
+- Rewrite any candidate whose real point appears after the mobile clamp unless
+  that point is the planned payoff for an intentional open loop.
 
 ## Pass, Warn, Fail
 
 Use these rendered gates:
 
 - `pass`: the mobile rendered preview shows the pain, proof, or curiosity by the
-  end of the first 3 rendered lines, and the core point is understandable
-  without opening "see more".
+  end of the first 3 rendered lines, and either the core point is
+  understandable without opening "see more" or an intentional open loop creates
+  a specific click question with an immediate planned payoff.
 - `warn`: the mobile rendered preview creates useful curiosity but the core
-  point is slightly softened by wrapping, blank-line rhythm, or one missing
-  context word. A compact fallback is required.
+  point or click question is slightly softened by wrapping, blank-line rhythm,
+  or one missing context word. A compact fallback is required.
 - `fail`: the hook's real point appears after the first 3 mobile rendered lines,
-  the first rendered line is generic setup, blank lines consume the preview
-  before the reader sees the point, or desktop fit is the only reason it looks
-  good.
+  the visible open loop is vague, the first rendered line is generic setup,
+  blank lines consume the preview before the reader sees the point, or desktop
+  fit is the only reason it looks good.
 
 A draft cannot be `ready` when the selected hook has:
 
 - no `renderedPreview`
 - `mobile.seeMoreRisk: fail`
 - `mobile.corePainProofOrCuriosityVisible: false`
-- `mobile.corePointVisible: false`
-- `pointAfterMobileClamp: true`
+- `mobile.corePointVisible: false` unless `mobile.intentionalOpenLoop: true`,
+  `mobile.specificClickQuestionVisible: true`, and
+  `mobile.payoffPlannedImmediatelyAfterClamp: true`
+- `pointAfterMobileClamp: true` unless the point after the clamp is the
+  intentional payoff for a specific open loop
 
 ## Report Format
 

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
@@ -67,6 +72,12 @@ Hook research files must preserve:
   including literal mobile/desktop preview blocks, rendered line wraps, render
   basis, CSS contract version, text widths, first-screen promise visibility,
   core point visibility, and whether the point lands after the mobile clamp
+- hook reverse-engineering autopsies for kept source hooks, including source
+  mechanism, open-loop type, click question, promised payoff, specificity
+  anchor, source shape to keep, source words not to copy, and adaptation rule
+- hook angle matrix summary, including angle territories tested, top generated
+  hooks, winning territory, runner-up territories, and why the winning angle
+  beat the alternatives
 - extracted hook patterns
 - selected hook basis
 
@@ -87,6 +98,9 @@ Draft files must preserve:
 - draft body
 - validation receipt, including LinkedIn preview pass/warn/fail status and
   compact fallback when the selected hook carries a warning
+- selected hook reverse-engineering audit, hook angle matrix summary, and
+  see-more click audit when the selected hook intentionally hides the payoff
+  after the mobile fold
 - rendered mobile and desktop preview blocks for the selected hook; drafts
   cannot be ready when this rendered-preview audit is missing or fails mobile
   visibility

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

@@ -11,6 +11,10 @@ Every saved draft needs a validation receipt. A draft without this receipt is no
 - `candidateHooksConsidered`
 - `selectedHook`
 - `selectedHookWhy`
+- `sourceHookReachAudit`
+- `hookReverseEngineeringAudit`
+- `hookAngleMatrix`
+- `seeMoreClickAudit`
 - `proofClaimsUsed`
 - `proofClaimSources`
 - `storyFilesConsulted`
@@ -68,20 +72,44 @@ set the verdict to `revise` or `reject`.
 
 ## Candidate Set
 
-Generate multiple hook candidates before drafting. Do not lock onto the first draft.
+Generate many hook candidates before drafting. Do not lock onto the first draft.
+
+Minimum candidate set:
+
+- normal drafting: at least 8 angle territories and 24 hook candidates
+- hook-critical requests: at least 12 angle territories and 40 hook candidates
+- smaller set only when the user explicitly asks for fewer options
+
+An angle territory is a distinct reason the reader might care, such as hidden
+asset, tool/enemy contrast, first-person build proof, workflow reveal,
+contrarian category claim, mistake/confession, market timing, operator pain,
+specific person/company signal, before/after transformation, or question hook.
 
 Each candidate should include:
 
 - hook text
 - selected premise
+- angle territory
 - premise tension opened
 - reader value implied
 - source pattern
+- source shape kept
+- source words not copied
+- 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
 - mobile and desktop rendered line wraps
 - first-screen promise: pain, proof, or curiosity visible by the mobile clamp
+- `intentionalOpenLoop`
+- `specificClickQuestionVisible`
+- `seeMoreClickReason`
+- `clickQuestion`
+- `payoffAfterFold`
+- `bodyProofObligation`
 - whether the core point is visible in the mobile rendered preview
 - whether the point lands after the mobile clamp
 - char count including newlines and first-line / first-two-line preview measurements
@@ -92,6 +120,55 @@ Each candidate should include:
 - AI-tell risk
 - why it should win or lose
 
+## Hook Reverse Engineering Audit
+
+Before a draft can be `ready`, validate that the selected hook came from a real
+source-shape analysis, not from generic brainstorming.
+
+Record:
+
+- `sourceHooksStudied`
+- `sourceHookAutopsies`
+- `selectedSourceShape`
+- `sourceShapeKept`
+- `sourceWordsNotCopied`
+- `whyItWorks`
+- `openLoopType`: `none`, `hidden_payoff`, `contradiction`, `proof_gap`,
+  `workflow_reveal`, `asset_reveal`, or `story_gap`
+- `clickQuestion`
+- `promisedPayoff`
+- `specificityAnchor`
+- `tensionOpened`
+- `proofImplied`
+- `adaptationRule`
+- `bodyPayoffObligation`
+
+The selected draft cannot be `ready` if the hook was copied verbatim from
+another creator, if the receipt only says "contrarian" or "curiosity" without
+the concrete shape, or if the body does not pay off the hook quickly.
+
+## Hook Angle Matrix Audit
+
+Before a draft can be `ready`, validate that the hook was chosen after exploring
+materially different angles.
+
+Record:
+
+- `angleTerritoriesTested`
+- `hookCandidatesGenerated`
+- `winningTerritory`
+- `runnerUpTerritories`
+- `whyWinningAngleBeatsAlternatives`
+- `whyRejectedHooksLost`
+- `mobileRenderedPreviewBlocksForTopCandidates`
+- `desktopRenderedPreviewBlocksForTopCandidates`
+- `proofNeededByWinningAngle`
+
+If the user asked to "nail the hook," "focus on hooks," or explore "a ton of
+angles," the draft cannot be `ready` unless at least 12 territories and 40 hook
+candidates were considered or the receipt explains why the user explicitly
+requested fewer.
+
 ## Finalizer Pass
 
 After the first draft:
@@ -153,6 +230,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
@@ -182,15 +288,17 @@ review clamp: first 3 rendered text lines
 Use rendered gates:
 
 - `pass`: the mobile rendered preview shows the pain, proof, or curiosity by
-  the end of the first 3 rendered lines, and the core point is understandable
-  without opening "see more".
+  the end of the first 3 rendered lines, and either the core point is
+  understandable without opening "see more" or an intentional open loop creates
+  a specific click question with an immediate planned payoff.
 - `warn`: the mobile rendered preview creates useful curiosity but the core
-  point is slightly softened by wrapping, blank-line rhythm, or one missing
-  context word. A compact fallback is required.
+  point or click question is slightly softened by wrapping, blank-line rhythm,
+  or one missing context word. A compact fallback is required.
 - `fail`: the hook's real point appears after the first 3 mobile rendered
-  lines, the first rendered line is generic setup, blank lines consume the
-  preview before the reader sees the point, or desktop fit is the only reason it
-  looks good.
+  lines without an intentional open-loop plan, the visible open loop is vague,
+  the first rendered line is generic setup, blank lines consume the preview
+  before the reader sees the point, or desktop fit is the only reason it looks
+  good.
 
 Desktop preview usually has more room. Still record desktop fit, but never let
 desktop fit compensate for a mobile `fail`.
@@ -213,6 +321,12 @@ Record:
 - `corePainProofOrCuriosityVisibleDesktop`
 - `corePointVisibleMobile`
 - `corePointVisibleDesktop`
+- `intentionalOpenLoop`
+- `specificClickQuestionVisible`
+- `payoffPlannedImmediatelyAfterClamp`
+- `seeMoreClickReason`
+- `clickQuestion`
+- `payoffAfterFold`
 - `pointAfterMobileClamp`
 - `charCount`
 - `charCountIncludingNewlines`
@@ -236,10 +350,33 @@ If the hook only works after the rendered mobile clamp, rewrite it. A draft
 cannot be `ready` with `previewBudgetStatus: fail`,
 `mobilePreviewFit: fail`, missing `renderedPreview`,
 `corePainProofOrCuriosityVisibleMobile: false`,
-`corePointVisibleMobile: false`, or `pointAfterMobileClamp: true`. A draft may
-be `ready` with `previewBudgetStatus: warn` only when the warning is explicit,
-usually because the user prefers blank-line rhythm, and the receipt includes a
-compact fallback.
+`corePointVisibleMobile: false` unless the receipt has
+`intentionalOpenLoop: true`, `specificClickQuestionVisible: true`, and
+`payoffPlannedImmediatelyAfterClamp: true`, or `pointAfterMobileClamp: true`
+unless the post is intentionally hiding the payoff for a specific see-more
+click. A draft may be `ready` with `previewBudgetStatus: warn` only when the
+warning is explicit, usually because the user prefers blank-line rhythm, and
+the receipt includes a compact fallback.
+
+## See-More Click Audit
+
+When the selected hook intentionally hides the payoff after the mobile fold,
+record:
+
+- `intentionalOpenLoop: true`
+- `openLoopType`
+- `visibleBeforeFold`
+- `clickQuestion`
+- `payoffAfterFold`
+- `firstPayoffLine`
+- `payoffArrivesWithinFirstBodySection`
+- `readerValueAfterClick`
+- `baitRisk`
+- `baitRiskMitigation`
+
+Open loops are allowed only when the body actually delivers the promised payoff.
+If the hook withholds the answer but the body switches topics, save as
+`needs_revision`.
 
 ## Simplifier / Concrete-Language Audit