@coppica/persuasion-mcp 1.0.1

package/dist/roles.js

@@ -0,0 +1,188 @@
+/**
+ * The nine reader questions (Thesis VIII of The 18 Theses) and the framework
+ * tables built on them. Role names, questions and "if missing" lines are copied
+ * from persuasion-taxonomy (app/the-nine-roles/roles-data.ts). The glosses, gaps,
+ * the click goal, the coherence pairs and the symptom map are written here; the
+ * last three were reviewed and approved by Elijah on 2026-10-04.
+ *
+ * Every string in this file reaches a model, and through it a writer. Keep it in
+ * the voice of a working copywriter: plain words, full sentences, no em dashes.
+ */
+export const ROLE_NAMES = [
+    'DISRUPT', 'IDENTIFY', 'AGITATE', 'REFRAME', 'PROVE', 'ELEVATE', 'RESOLVE', 'COMPEL', 'BOND',
+];
+export const ROLES = {
+    DISRUPT: { num: 1, name: 'DISRUPT', question: 'Why am I even reading this?', ifMissing: 'Nothing below matters.', gap: "nothing in the opening breaks the reader's autopilot, so they never really arrive", gloss: 'earning the first read' },
+    IDENTIFY: { num: 2, name: 'IDENTIFY', question: 'Is this written for me?', ifMissing: "I assume it's for someone else.", gap: 'the copy never shows readers themselves, so it reads as if it were written for anybody', gloss: 'making the reader feel seen' },
+    AGITATE: { num: 3, name: 'AGITATE', question: 'How bad is my problem, really?', ifMissing: 'I disengage; the problem feels unrelated.', gap: 'the pain stays abstract, so nothing builds the pressure to fix it', gloss: 'making the problem feel real' },
+    REFRAME: { num: 4, name: 'REFRAME', question: 'Am I thinking about this correctly?', ifMissing: 'The default frame keeps the default decision.', gap: 'the copy asserts where it should reframe, so the reader keeps the old way of seeing the problem', gloss: 'changing how they see the problem' },
+    PROVE: { num: 5, name: 'PROVE', question: 'Can I trust the claim?', ifMissing: 'All gains are discounted.', gap: 'the claims float with nothing under them, so nothing earns belief', gloss: 'making the claim believable' },
+    ELEVATE: { num: 6, name: 'ELEVATE', question: 'What does my life look like after?', ifMissing: "I see information; I don't see myself in it.", gap: "the copy lists features and never shows the reader's life after the change", gloss: 'making the payoff vivid' },
+    RESOLVE: { num: 7, name: 'RESOLVE', question: "What's stopping me from saying yes?", ifMissing: 'Doubt accumulates faster than belief.', gap: 'the objections and the risk are still standing between the reader and yes', gloss: 'removing what stops the yes' },
+    COMPEL: { num: 8, name: 'COMPEL', question: 'Why should I act right now?', ifMissing: 'I bookmark and never return.', gap: 'nothing makes today the day, so the decision can wait forever', gloss: 'getting them to act now' },
+    BOND: { num: 9, name: 'BOND', question: "Do I like and trust who's speaking?", ifMissing: 'Arguments become harder to accept.', gap: 'no relationship forms, so the copy sells at the reader instead of talking with them', gloss: 'making them like and trust the one speaking' },
+};
+/** The question in quotes, with its role name, for the places a model needs both. */
+export const roleLabel = (r) => `"${ROLES[r].question}" (${r})`;
+// ── Goals ────────────────────────────────────────────────────────────────
+export const GOALS = ['purchase', 'signup', 'click', 'engagement'];
+/** Each requirement is satisfied by ANY of its roles. purchase/signup/engagement
+ *  mirror the analyzer's sales/lead_gen/nurture EXPECTED_ROLES; click was added here (reviewed 2026-10-04). */
+export const GOAL_REQUIREMENTS = {
+    purchase: ROLE_NAMES.map((r) => [r]),
+    signup: [['DISRUPT'], ['IDENTIFY'], ['AGITATE'], ['REFRAME'], ['PROVE'], ['COMPEL']],
+    engagement: [['DISRUPT'], ['IDENTIFY'], ['REFRAME'], ['PROVE'], ['BOND'], ['COMPEL']],
+    click: [['DISRUPT'], ['IDENTIFY'], ['AGITATE', 'ELEVATE'], ['COMPEL']],
+};
+/** "For a signup, ..." */
+export const GOAL_NOUN = {
+    purchase: 'a sale',
+    signup: 'a signup',
+    click: 'a click',
+    engagement: 'engagement',
+};
+/** "a landing page that ..." */
+export const GOAL_CLAUSE = {
+    purchase: 'has to make the sale',
+    signup: 'has to get the signup',
+    click: 'has to earn the click',
+    engagement: 'has to get read and answered',
+};
+export function expectedRoles(goal) {
+    return new Set(GOAL_REQUIREMENTS[goal].flat());
+}
+// ── Formats ──────────────────────────────────────────────────────────────
+export const FORMATS = ['ad', 'landing_page', 'sales_letter', 'email', 'email_subject', 'social_post', 'video_script', 'headline'];
+export const FORMAT_LABEL = {
+    ad: 'an ad',
+    landing_page: 'a landing page',
+    sales_letter: 'a sales letter',
+    email: 'an email',
+    email_subject: 'an email subject line',
+    social_post: 'a social post',
+    video_script: 'a video script',
+    headline: 'a headline',
+};
+/** Corpus channel groups where evidence for a technique counts toward "fits this format". */
+export const FORMAT_CHANNELS = {
+    ad: ['ads', 'video'],
+    landing_page: ['web', 'direct_mail'],
+    sales_letter: ['direct_mail', 'web'],
+    email: ['email', 'direct_mail'],
+    email_subject: ['email'],
+    social_post: ['ads', 'web'],
+    video_script: ['video', 'ads'],
+    headline: ['ads', 'web'],
+};
+// ── Awareness (Schwartz) ─────────────────────────────────────────────────
+export const AWARENESS = ['unaware', 'problem_aware', 'solution_aware', 'product_aware', 'most_aware'];
+export const AWARENESS_WEIGHT = {
+    unaware: { heavy: ['DISRUPT', 'IDENTIFY', 'AGITATE'], note: "They don't know they have the problem yet, so don't open with the product or the price. Open with their world, or with a surprising truth, and earn the problem before you offer the solution." },
+    problem_aware: { heavy: ['AGITATE', 'REFRAME', 'IDENTIFY'], note: "They feel the problem but can't see the way out. Show them you understand it better than they do, and then change the way they see it." },
+    solution_aware: { heavy: ['REFRAME', 'PROVE', 'ELEVATE'], note: "They know solutions exist. Show them what's different about yours and prove that it works, or you're just one more option." },
+    product_aware: { heavy: ['PROVE', 'RESOLVE', 'COMPEL'], note: "They know you, but they haven't said yes. Take away the doubt and the risk, and give them a reason to act now." },
+    most_aware: { heavy: ['COMPEL', 'RESOLVE'], note: "They're ready to buy. Lead with the offer and the reason to act today, because a long argument only slows them down." },
+};
+// ── Coherence (Thesis X) ─────────────────────────────────────────────────
+/** Coherence pairs (reviewed 2026-10-04). Readers check the nine answers against each other; a mismatch is what
+ *  they feel as "something's off". These are questions for the calling model to ask. */
+export const COHERENCE_CHECKS = [
+    { roles: ['DISRUPT', 'ELEVATE'], check: 'Does the rest of the copy pay off what the opening hints at? A bigger promise up top than the body can deliver reads as bait.' },
+    { roles: ['ELEVATE', 'PROVE'], check: 'Is the life after you paint any bigger than your proof can support? It should never be.' },
+    { roles: ['IDENTIFY', 'BOND'], check: 'Does the voice sound like someone this reader would trust, using their words, at their level?' },
+    { roles: ['AGITATE', 'COMPEL'], check: 'Is the urgency in proportion to the pain you set up? A deadline on a mild problem feels manufactured.' },
+    { roles: ['REFRAME', 'PROVE'], check: 'Does your proof support the new way of seeing the problem, or the old one you argued against?' },
+    { roles: ['RESOLVE', 'COMPEL'], check: 'Is the risk reversal big enough for the size of the ask?' },
+    { roles: ['PROVE', 'BOND'], check: 'Does the proof come from people and sources this reader already trusts?' },
+];
+// ── Symptoms → unanswered questions ──────────────────────────────────────
+export const SYMPTOMS = [
+    'low_click_through', 'high_bounce', 'reads_but_no_action', 'starts_but_abandons',
+    'leads_dont_buy', 'buys_once_no_return', 'low_open_rate', 'opens_no_clicks',
+];
+/** Symptom map (reviewed 2026-10-04), derived from each role's "if missing" consequence. */
+export const SYMPTOM_MAP = {
+    low_click_through: {
+        label: "people see it but don't click",
+        suspects: [
+            { role: 'DISRUPT', why: 'The scroll wins. Nothing in the first line or the first frame interrupts their autopilot, so they never read the rest.', check: 'To check, read only the first line, or only the words on the thumbnail. If it could run for any brand in your category, it fails this question.' },
+            { role: 'IDENTIFY', why: 'Nothing tells them this is for them, so they keep moving.', check: 'To check, look at the opening and ask whether the right person would recognize their own situation in it at a glance.' },
+            { role: 'COMPEL', why: 'Even interested readers need a reason to click now and not later.', check: 'To check, find the reason to click today. If all you have is "Learn more", there isn\'t one.' },
+        ],
+        ruleOutFirst: 'Check the targeting, the placement and the image first. If the wrong people are seeing it, or the visual is wrong, no copy will fix it.',
+    },
+    high_bounce: {
+        label: 'people click, then leave fast',
+        suspects: [
+            { role: 'COHERENCE', why: "The page doesn't pay off what the ad or the link promised. Readers feel the mismatch before they can name it, and they leave.", check: "To check, put the ad next to the page's first screen. They should make the same promise, in the same words, to the same reader." },
+            { role: 'IDENTIFY', why: 'The page talks to a different reader than the ad did.', check: 'To check, ask who the first screen is talking to, and whether that is the same person the ad was talking to.' },
+            { role: 'DISRUPT', why: 'The page starts over cold when it should carry on the thought that made them click.', check: 'To check, read the headline right after the ad. It should pick up where the ad left off, not start again with a brand slogan.' },
+        ],
+        ruleOutFirst: 'Check the page speed, the mobile layout and the links first. A slow or broken page looks like a bounce no matter what the copy says.',
+    },
+    reads_but_no_action: {
+        label: "people read it but don't act",
+        suspects: [
+            { role: 'PROVE', why: 'They hear the promise, but they don\'t believe it.', check: 'To check, go through every big claim and look for the evidence sitting right next to it: a number, a name, a demonstration.' },
+            { role: 'RESOLVE', why: 'An objection nobody answered, like the price, the time or "will it work for me?", is standing in the way of yes.', check: 'To check, write down the three reasons a reader would say no, and see whether the copy answers each one before it asks.' },
+            { role: 'COMPEL', why: 'Nothing makes today the day.', check: 'To check, look for a real, honest reason to act now. If you can\'t point to one, the reader can\'t either.' },
+            { role: 'ELEVATE', why: 'The copy describes the product and never shows the reader after the change.', check: 'To check, look for a specific, concrete picture of their life afterward. A list of features doesn\'t count.' },
+        ],
+        ruleOutFirst: 'Check the offer itself first, meaning the price, the terms and the fit, and make sure the call to action is easy to find and easy to use.',
+    },
+    starts_but_abandons: {
+        label: 'people start the checkout or the form, then abandon it',
+        suspects: [
+            { role: 'RESOLVE', why: 'A last-minute objection about cost, commitment or risk comes up at the moment of yes, and nothing answers it.', check: 'To check, look at the form or the checkout itself. The guarantee, the "cancel anytime" and what happens next should all be visible right there.' },
+            { role: 'COMPEL', why: 'The urgency that started them fades before the finish line.', check: 'To check, see whether the checkout reminds them why now.' },
+            { role: 'PROVE', why: 'Trust drops the moment you ask for money or an email address.', check: 'To check, look for trust signals right where you ask for the card or the email.' },
+        ],
+        ruleOutFirst: 'Rule out surprise costs like shipping and fees, forced account creation, too many fields and payment errors first.',
+    },
+    leads_dont_buy: {
+        label: "signups and leads don't turn into sales",
+        suspects: [
+            { role: 'REFRAME', why: 'The lead still sees the problem the old way, so the default decision wins, whether that is doing nothing or sticking with what they know.', check: 'To check, read the follow-up and ask whether it changes how they see the problem or just repeats the pitch.' },
+            { role: 'PROVE', why: 'They wanted the free thing. Nothing has convinced them the paid one works.', check: 'To check, list the evidence a lead actually sees between signing up and being asked to buy.' },
+            { role: 'RESOLVE', why: "Objections that didn't matter for a free signup matter a great deal for a purchase.", check: 'To check, see whether the nurture sequence answers the objections about price, time and fit.' },
+            { role: 'BOND', why: "They don't trust the sender enough yet for a paid ask.", check: 'To check, see whether the sequence builds a relationship, through voice, story and generosity, before it asks.' },
+        ],
+        ruleOutFirst: 'Check the lead quality first, meaning whether these are the right people at all, and how fast sales follows up.',
+    },
+    buys_once_no_return: {
+        label: 'people buy once, then ask for a refund, cancel or never come back',
+        suspects: [
+            { role: 'COHERENCE', why: "The promise and the delivery don't match. The sale was made on a life after that the product didn't produce.", check: 'To check, compare the after-picture and the proof in your sales copy with what customers actually experience.' },
+            { role: 'BOND', why: 'No relationship formed, so nothing brings them back.', check: 'To check, read what they get after they buy. It should carry the relationship on, not go silent until the next pitch.' },
+        ],
+        ruleOutFirst: "Rule out problems with the product, the onboarding and the delivery first. Copy can make the promise honest, but it can't make the product deliver.",
+    },
+    low_open_rate: {
+        label: "emails don't get opened",
+        suspects: [
+            { role: 'DISRUPT', why: 'The subject line reads like every other email in the inbox.', check: 'To check, cover the sender name and ask whether the subject line could have come from anyone.' },
+            { role: 'IDENTIFY', why: 'Nothing in the subject or the preview says this one is for them.', check: 'To check, see whether the subject or the preview text names their situation.' },
+            { role: 'BOND', why: "They don't know or care who is sending it.", check: 'To check, look at the sender name. It should be a person or a brand they recognize and like.' },
+        ],
+        ruleOutFirst: "Check deliverability first, meaning the spam folder and your authentication, and the health of the list. Nobody opens an email they never see.",
+    },
+    opens_no_clicks: {
+        label: 'emails get opened but nobody clicks',
+        suspects: [
+            { role: 'COHERENCE', why: "The body doesn't pay off the subject line, so the open feels like bait.", check: 'To check, read the first line right after the subject. It should deliver what the subject promised.' },
+            { role: 'IDENTIFY', why: 'The body drifts away from the reader and toward the brand.', check: 'To check, count the "you"s against the "we"s. The email should be about them.' },
+            { role: 'COMPEL', why: 'There is no single, clear reason to click now.', check: 'To check, look for one obvious click with a reason attached. Several competing links split the reader\'s attention.' },
+        ],
+        ruleOutFirst: 'Rule out broken links, image-only emails and too many competing calls to action first.',
+    },
+};
+export function normalizeRole(v) {
+    if (typeof v !== 'string')
+        return v;
+    const up = v.trim().toUpperCase();
+    if (ROLE_NAMES.includes(up))
+        return up;
+    // accept the question text itself
+    const byQ = ROLE_NAMES.find((r) => ROLES[r].question.toLowerCase().replace(/[^a-z ]/g, '') === v.toLowerCase().replace(/[^a-z ]/g, '').trim());
+    return byQ ?? up;
+}

package/dist/schemas.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const goalSchema: z.ZodEnum<["purchase", "signup", "click", "engagement"]>;
+export declare const formatSchema: z.ZodEnum<["ad", "landing_page", "sales_letter", "email", "email_subject", "social_post", "video_script", "headline"]>;
+export declare const awarenessSchema: z.ZodEnum<["unaware", "problem_aware", "solution_aware", "product_aware", "most_aware"]>;
+export declare const roleSchema: z.ZodEffects<z.ZodEnum<["DISRUPT", "IDENTIFY", "AGITATE", "REFRAME", "PROVE", "ELEVATE", "RESOLVE", "COMPEL", "BOND"]>, "DISRUPT" | "IDENTIFY" | "AGITATE" | "REFRAME" | "PROVE" | "ELEVATE" | "RESOLVE" | "COMPEL" | "BOND", unknown>;
+export declare const categorySchema: z.ZodString;
+export declare const modeSchema: z.ZodDefault<z.ZodEnum<["aggressive", "balanced", "equity"]>>;

package/dist/schemas.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { GOALS, FORMATS, AWARENESS, ROLE_NAMES, ROLES, normalizeRole } from './roles.js';
+import { CATEGORY_NAMES } from './data.js';
+export const goalSchema = z.enum(GOALS).describe('What the copy has to get the reader to do. Use purchase when they should buy now, signup for an opt-in, a trial, a demo or a lead form, ' +
+    'click when the whole job is the click (most ads and links), and engagement for nurture emails, newsletters and social posts that should be read, answered or followed.');
+export const formatSchema = z.enum(FORMATS).describe('The kind of copy it is: ad, landing_page, sales_letter for long-form sales copy, email, email_subject, social_post, video_script or headline.');
+export const awarenessSchema = z.enum(AWARENESS).describe("How much the reader already knows, on Eugene Schwartz's scale. Use unaware if they don't know they have the problem, problem_aware if they feel it, " +
+    "solution_aware if they know solutions exist, product_aware if they know you, and most_aware if they're ready and only need the offer.");
+export const roleSchema = z.preprocess(normalizeRole, z.enum(ROLE_NAMES)).describe('The reader question the text answers, by its role name: ' + ROLE_NAMES.map((r) => `${r} for "${ROLES[r].question}"`).join(', ') + '.');
+export const categorySchema = z.string().max(60).describe(`The industry, if you want to compare against what brands in that category usually do. There is enough data for ${CATEGORY_NAMES.join(', ')}. ` +
+    'Any other category still works, just without the comparison.');
+export const modeSchema = z.enum(['aggressive', 'balanced', 'equity']).default('balanced').describe('How hard the copy is allowed to push. Balanced is the default, persuasive and sustainable over time. Equity protects long-term trust, so it rules out fear, hype and hard-sell moves. ' +
+    'Aggressive is for short-term direct response and allows fear, threat and hard scarcity. In every mode, the claims stay true.');

package/dist/scorers/claim-framework.d.ts

@@ -0,0 +1,52 @@
+import { type HookFormat, type AwarenessLevel } from './hook-framework.js';
+/**
+ * CLAIM FRAMEWORK — Phase 2 of the writing-tools strategy.
+ *
+ * The hook framework scores openers (single sentences). The flow framework
+ * scores blocks (paragraphs). This sits between them: it scores SENTENCES
+ * with role-specific gates. v1 ships three claim types:
+ *
+ *   - headline      → delegates to scoreHook (single source of truth for
+ *                     opener scoring; reconciles with the universal headline
+ *                     rule from Layer 1)
+ *   - cta           → button / CTA-specific gates (generic-text fail,
+ *                     first-person or outcome, single-verb strength,
+ *                     low-friction word cap, anti-smell)
+ *   - body_claim    → in-body assertion gates (specificity, mechanism named,
+ *                     proof welded, anti-smell)
+ *
+ * Phase 2.5 will add: subhead, bullet, proof_statement, objection_rebuttal,
+ * guarantee. Per the v3 plan: ship 3 first, expand based on observed gaps.
+ *
+ * Pure module — no I/O, no DB. The evaluate_claims tool wraps this and
+ * persists results to claim_evaluations. Reuses detectAISmell from
+ * hook-framework so the banned-word list has one source of truth.
+ *
+ * Batched scoring is the default: scoreClaims(claims[]) keeps token cost low
+ * by scoring an array of mixed-type claims in one call.
+ */
+export type ClaimType = 'headline' | 'cta' | 'body_claim';
+interface ClaimGateResult {
+    name: string;
+    status: 'pass' | 'warn' | 'fail';
+    detail?: string;
+}
+export interface ClaimScore {
+    /** Echoed back so the bot can correlate batched results to its inputs. */
+    text: string;
+    type: ClaimType;
+    score: number;
+    scoreLabel: 'fail' | 'weak' | 'passable' | 'strong' | 'excellent';
+    gates: ClaimGateResult[];
+    violations: string[];
+    suggestions: string[];
+}
+export interface BatchClaimInput {
+    text: string;
+    type: ClaimType;
+    context?: string;
+    headline_format?: HookFormat;
+    awareness_level?: AwarenessLevel;
+}
+export declare function scoreClaims(claims: BatchClaimInput[]): ClaimScore[];
+export {};

package/dist/scorers/claim-framework.js

@@ -0,0 +1,363 @@
+// Copied from persuasion-ecosystem lib/claim-framework.ts on 2026-10-03. Pure module: no I/O, no AI calls.
+// Keep in sync with the source until both import a shared package.
+import { detectAISmell, scoreHook } from './hook-framework.js';
+import { safeSlice } from './string-utils.js';
+// ──────────────────────────────────────────────────────────────────────────
+// Tunables
+// ──────────────────────────────────────────────────────────────────────────
+const MAX_CLAIM_LENGTH = 1000;
+/** CTA hard-fails on these literal words (case insensitive). */
+// Note: trailing punctuation is stripped by `replace(/[!.?]+$/, '')` in scoreCta
+// before this Set is consulted, so dotted variants ('click here.', 'learn more.')
+// would never match — kept the canonical un-dotted forms only.
+const CTA_GENERIC_BUTTONS = new Set([
+    'submit',
+    'click here',
+    'click',
+    'learn more',
+    'read more',
+    'continue',
+    'next',
+    'go',
+    'enter',
+    'send',
+    'okay',
+    'ok',
+    // Stock buttons that name no outcome. "Buy now" / "Shop now" stay off the list:
+    // for a ready buyer they are the clear, honest button.
+    'get started',
+    'sign up',
+    'sign up now',
+    'start now',
+    'start here',
+    'try it',
+    'try it now',
+    'find out more',
+    'discover more',
+    'see more',
+]);
+/** Strong action verbs that indicate the CTA names a real action. */
+const CTA_STRONG_VERBS = [
+    'get', 'grab', 'claim', 'reserve', 'save', 'book', 'unlock', 'start',
+    'try', 'join', 'download', 'install', 'send', 'request', 'apply',
+    'see', 'show', 'reveal', 'discover', 'open', 'activate', 'enroll',
+    'enter', 'subscribe', 'access', 'create', 'build', 'launch', 'fix',
+    'cancel', 'stop', 'remove', 'delete', 'add',
+];
+/** Outcome words that indicate the CTA promises something specific. */
+const CTA_OUTCOME_NOUNS = [
+    'spot', 'seat', 'session', 'demo', 'access', 'guide', 'report',
+    'audit', 'review', 'plan', 'kit', 'template', 'discount', 'sample',
+    'consult', 'consultation', 'invitation', 'invite', 'preview', 'trial',
+    'subscription', 'license', 'key', 'pass', 'ticket', 'copy', 'edition',
+    'meeting', 'call',
+];
+// Pre-compiled regex for CTA outcome detection. Compiling once at module load
+// is N× faster than building a new RegExp inside scoreCta on every call,
+// which matters in batched mode (up to 50 claims per evaluate_claims call).
+const CTA_OUTCOME_REGEX = new RegExp(`\\b(${CTA_OUTCOME_NOUNS.join('|')})\\b`, 'i');
+/** CTAs longer than this many words feel like sentences, not buttons. */
+const CTA_LOW_FRICTION_WORDS = 6;
+/** Mechanism markers — words that indicate the claim names HOW. */
+const MECHANISM_MARKERS = [
+    'because', 'by ', 'through ', 'via ', 'using ', 'thanks to ',
+    'powered by ', 'based on ', 'driven by ', 'built on ',
+];
+// ──────────────────────────────────────────────────────────────────────────
+// Headline — delegates to scoreHook
+// ──────────────────────────────────────────────────────────────────────────
+function normalizeHookResult(text, options) {
+    // Hook framework owns the 7-gate logic for openers. Translate its return
+    // shape into the unified ClaimScore shape so the consumer (the bot) sees
+    // a consistent structure across claim types.
+    const result = scoreHook(text, {
+        format: options.headlineFormat,
+        awarenessLevel: options.awarenessLevel,
+    });
+    const gates = result.gates.map((g) => ({
+        name: g.name,
+        status: g.result,
+        detail: g.detail,
+    }));
+    return {
+        text,
+        type: 'headline',
+        score: result.score,
+        scoreLabel: result.scoreLabel,
+        gates,
+        violations: result.violations,
+        suggestions: result.suggestions.slice(0, 3),
+    };
+}
+// ──────────────────────────────────────────────────────────────────────────
+// CTA gates
+// ──────────────────────────────────────────────────────────────────────────
+function scoreCta(text) {
+    const trimmed = text.trim();
+    const lower = trimmed.toLowerCase().replace(/[!.?]+$/, '');
+    const words = trimmed.split(/\s+/).filter(Boolean);
+    const wordCount = words.length;
+    const gates = [];
+    const violations = [];
+    const suggestions = [];
+    // CTA 1: hard-fail on generic button text
+    if (CTA_GENERIC_BUTTONS.has(lower)) {
+        gates.push({
+            name: 'generic_button_text',
+            status: 'fail',
+            detail: `"${trimmed}" is a generic button label. Replace with a specific outcome ("Save my seat", "Book my audit", "Send me the guide").`,
+        });
+        violations.push('generic_button_text');
+        suggestions.push('Replace with a benefit-oriented action ("Save my seat" not "Submit").');
+    }
+    else {
+        gates.push({ name: 'generic_button_text', status: 'pass' });
+    }
+    // CTA 2: first-person possessive OR specific outcome noun
+    const hasFirstPerson = /\b(my|me|i)\b/i.test(trimmed);
+    const lowerForOutcome = lower.replace(/[^a-z\s]/g, ' ');
+    const hasOutcome = CTA_OUTCOME_REGEX.test(lowerForOutcome);
+    if (hasFirstPerson || hasOutcome) {
+        gates.push({
+            name: 'first_person_or_outcome',
+            status: 'pass',
+            detail: hasFirstPerson ? 'first-person possessive' : 'specific outcome noun',
+        });
+    }
+    else {
+        gates.push({
+            name: 'first_person_or_outcome',
+            status: 'fail',
+            detail: 'CTA needs first-person ("Get my X") or a specific outcome noun ("seat", "session", "audit").',
+        });
+        violations.push('first_person_or_outcome');
+        suggestions.push('Use first-person ("Get my plan") — Unbounce documents +90% lift over second-person.');
+    }
+    // CTA 3: starts with a strong action verb
+    const firstWord = words[0]?.toLowerCase().replace(/[^a-z]/g, '') || '';
+    if (CTA_STRONG_VERBS.includes(firstWord)) {
+        gates.push({
+            name: 'strong_action_verb',
+            status: 'pass',
+            detail: firstWord,
+        });
+    }
+    else {
+        gates.push({
+            name: 'strong_action_verb',
+            status: 'warn',
+            detail: `First word "${firstWord || '(none)'}" is not a strong action verb. CTAs should open with the verb of the action.`,
+        });
+    }
+    // CTA 4: low-friction word cap
+    if (wordCount === 0) {
+        gates.push({ name: 'low_friction', status: 'fail', detail: 'empty CTA' });
+    }
+    else if (wordCount > CTA_LOW_FRICTION_WORDS) {
+        gates.push({
+            name: 'low_friction',
+            status: 'warn',
+            detail: `${wordCount} words. Buttons over ${CTA_LOW_FRICTION_WORDS} words read as sentences, not actions.`,
+        });
+    }
+    else {
+        gates.push({
+            name: 'low_friction',
+            status: 'pass',
+            detail: `${wordCount} words`,
+        });
+    }
+    // CTA 5: anti-smell
+    const smell = detectAISmell(trimmed);
+    if (smell.hasSmells) {
+        gates.push({
+            name: 'anti_smell',
+            status: 'fail',
+            detail: smell.violations.slice(0, 3).join('; '),
+        });
+        violations.push(...smell.violations.map((v) => `anti_smell: ${v}`));
+    }
+    else {
+        gates.push({ name: 'anti_smell', status: 'pass' });
+    }
+    return finalizeScore(trimmed, 'cta', gates, violations, suggestions);
+}
+// ──────────────────────────────────────────────────────────────────────────
+// Body-claim gates
+// ──────────────────────────────────────────────────────────────────────────
+function scoreBodyClaim(text, options) {
+    const trimmed = text.trim();
+    const lower = trimmed.toLowerCase();
+    const gates = [];
+    const violations = [];
+    const suggestions = [];
+    // Body 1: specificity — number, $, %, year, named entity, or timeframe
+    const hasNumber = /\b\d+([,.]\d+)?[%kKmM]?\b/.test(trimmed) || /\$[\d,]+/.test(trimmed);
+    // Named-entity check: skip the first capitalized word of the sentence so
+    // sentence-initial "The" / "This" / "They" / "We" / "Our" don't false-
+    // positive every sentence into a "specificity pass". Strip leading
+    // punctuation, then strip the first capitalized word, then look for
+    // proper-noun patterns in what remains.
+    const stripped = trimmed.replace(/^[^a-zA-Z]*/, '').replace(/^[A-Z][a-z]*(?:'s)?\s*/, '');
+    const hasNamedEntity = /\b[A-Z][a-z]{2,}(?:\s+[A-Z][a-z]+)*\b/.test(stripped);
+    const hasTimeframe = /\b(day|days|week|weeks|month|months|year|years|hour|hours|minute|minutes|2024|2025|2026)\b/i.test(trimmed);
+    if (hasNumber || hasNamedEntity || hasTimeframe) {
+        const sources = [];
+        if (hasNumber)
+            sources.push('number');
+        if (hasNamedEntity)
+            sources.push('named entity');
+        if (hasTimeframe)
+            sources.push('timeframe');
+        gates.push({
+            name: 'specificity',
+            status: 'pass',
+            detail: sources.join(', '),
+        });
+    }
+    else {
+        gates.push({
+            name: 'specificity',
+            status: 'fail',
+            detail: 'No number, named entity, or timeframe. Generic claims are forgettable.',
+        });
+        violations.push('specificity');
+        suggestions.push('Anchor the claim with a number, dollar amount, percentage, year, or named entity.');
+    }
+    // Body 2: mechanism named — claim or its surrounding context names HOW.
+    // This mirrors the Schwartz "stage 4-5 sophistication" requirement: at
+    // higher market sophistication, the audience needs to know HOW the result
+    // is produced, not just WHAT the result is.
+    const haystack = `${lower} ${(options.context || '').toLowerCase()}`;
+    const hasMechanism = MECHANISM_MARKERS.some((m) => haystack.includes(m));
+    if (hasMechanism) {
+        gates.push({ name: 'mechanism_named', status: 'pass' });
+    }
+    else {
+        gates.push({
+            name: 'mechanism_named',
+            status: 'warn',
+            detail: 'Claim does not name HOW the result happens (no "because", "by", "through", "via"). At sophistication stage 4+, mechanism > pure benefit.',
+        });
+    }
+    // Body 3: proof welded — claim has at least one verifiable hook (number,
+    // source attribution, or named source). Reuses the specificity check but
+    // weights it differently: a number alone is enough here.
+    const hasSourceAttribution = /\b(according to|study|research|survey|reported|documented|measured|tested)\b/i.test(trimmed);
+    if (hasNumber || hasSourceAttribution) {
+        gates.push({
+            name: 'proof_welded',
+            status: 'pass',
+            detail: hasSourceAttribution ? 'source attribution' : 'verifiable number',
+        });
+    }
+    else {
+        gates.push({
+            name: 'proof_welded',
+            status: 'warn',
+            detail: 'No verifiable number or source attribution. Body claims need a proof anchor a skeptic can check.',
+        });
+    }
+    // Body 4: anti-smell
+    const smell = detectAISmell(trimmed);
+    if (smell.hasSmells) {
+        gates.push({
+            name: 'anti_smell',
+            status: 'fail',
+            detail: smell.violations.slice(0, 3).join('; '),
+        });
+        violations.push(...smell.violations.map((v) => `anti_smell: ${v}`));
+        suggestions.push('Strip the AI-smell vocabulary and rewrite in plain Anglo-Saxon verbs.');
+    }
+    else {
+        gates.push({ name: 'anti_smell', status: 'pass' });
+    }
+    return finalizeScore(trimmed, 'body_claim', gates, violations, suggestions);
+}
+// ──────────────────────────────────────────────────────────────────────────
+// Composition
+// ──────────────────────────────────────────────────────────────────────────
+function finalizeScore(text, type, gates, violations, suggestions) {
+    // Each fail costs 2.5, each warn 0.7, baseline 10.
+    let score = 10.0;
+    for (const g of gates) {
+        if (g.status === 'fail')
+            score -= 2.5;
+        else if (g.status === 'warn')
+            score -= 0.7;
+    }
+    if (score < 0)
+        score = 0;
+    // Auto-suggestions from any failed gate that didn't already contribute one.
+    for (const g of gates) {
+        if (g.status === 'fail' && g.detail && suggestions.length < 3) {
+            // Skip if a more specific suggestion already exists.
+            const alreadyCovered = suggestions.some((s) => s.toLowerCase().includes(g.name.replace(/_/g, ' ')));
+            if (!alreadyCovered)
+                suggestions.push(g.detail);
+        }
+    }
+    let scoreLabel;
+    if (score < 4)
+        scoreLabel = 'fail';
+    else if (score < 6)
+        scoreLabel = 'weak';
+    else if (score < 7.5)
+        scoreLabel = 'passable';
+    else if (score < 9)
+        scoreLabel = 'strong';
+    else
+        scoreLabel = 'excellent';
+    return {
+        text,
+        type,
+        score: Math.round(score * 10) / 10,
+        scoreLabel,
+        gates,
+        violations,
+        suggestions: suggestions.slice(0, 3),
+    };
+}
+// ──────────────────────────────────────────────────────────────────────────
+// Public entrypoints
+// ──────────────────────────────────────────────────────────────────────────
+function scoreClaim(text, type, options = {}) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return {
+            text: '',
+            type,
+            score: 0,
+            scoreLabel: 'fail',
+            gates: [{ name: 'empty', status: 'fail', detail: 'Empty claim.' }],
+            violations: ['empty'],
+            suggestions: ['Pass non-empty text.'],
+        };
+    }
+    if (trimmed.length > MAX_CLAIM_LENGTH) {
+        return {
+            text: safeSlice(trimmed, 80) + '…',
+            type,
+            score: 0,
+            scoreLabel: 'fail',
+            gates: [{ name: 'too_long', status: 'fail', detail: `Claims must be ≤${MAX_CLAIM_LENGTH} chars (received ${trimmed.length}). Use evaluate_flow for longer blocks.` }],
+            violations: ['too_long'],
+            suggestions: [`Pass a single sentence, not a paragraph (max ${MAX_CLAIM_LENGTH} chars).`],
+        };
+    }
+    switch (type) {
+        case 'headline':
+            return normalizeHookResult(trimmed, options);
+        case 'cta':
+            return scoreCta(trimmed);
+        case 'body_claim':
+            return scoreBodyClaim(trimmed, options);
+    }
+}
+export function scoreClaims(claims) {
+    return claims.map((c) => scoreClaim(c.text, c.type, {
+        context: c.context,
+        headlineFormat: c.headline_format,
+        awarenessLevel: c.awareness_level,
+    }));
+}