@coppica/persuasion-mcp 1.0.1

package/dist/hookcheck/index.js

@@ -0,0 +1,294 @@
+/**
+ * HOOK CHECK: the replacement for scoreHook (see docs/hook-check.md).
+ *
+ * Asks three things of an opening line: does it do its job in this slot (which of the nine reader
+ * questions it answers), could a competitor send it unchanged (swap test against the brief), and
+ * what is it a bet on. Reports hard facts and replicated evidence instead of a 0-10 score.
+ *
+ * Pure module: no I/O, no AI calls. The calling model supplies the labels (which question the
+ * line answers, quoting the words); this code verifies them and does the rest.
+ *
+ * Every message here is read by a model and echoed to a writer, so each one is a full, plain
+ * sentence. The fix logic keys off flags, never off the wording, so the wording can change freely.
+ */
+import { ROLES } from '../roles.js';
+import { detectAISmell } from '../scorers/hook-framework.js';
+import { smellSentences, joinList, endSentence } from '../voice.js';
+import { safeSlice } from '../scorers/string-utils.js';
+// ── slots (reviewed 2026-10-04) ──────────────────────────────────────────────
+export const SLOTS = ['email_subject', 'ad_opening', 'landing_page_headline', 'first_line', 'video_hook', 'social_post_open', 'sales_letter_headline'];
+/** label takes an article ("an email subject line"); job completes "Its job is to ..."; visibleNote completes "Keep in mind that ...". */
+export const SLOT_INFO = {
+    email_subject: { label: 'email subject line', job: 'earn the open', requires: [['DISRUPT', 'COMPEL'], ['IDENTIFY']], visibleChars: 40, visibleNote: 'only about 40 characters show in a mobile inbox', headlineLike: true },
+    ad_opening: { label: 'ad opening', job: 'stop the scroll, flag the right reader and give them a reason to click', requires: [['DISRUPT'], ['IDENTIFY'], ['AGITATE', 'ELEVATE', 'COMPEL']], visibleChars: 125, visibleNote: 'only about 125 characters show before "See more"', headlineLike: true },
+    landing_page_headline: { label: 'landing page headline', job: 'promise the outcome to the right reader, carrying on from whatever brought them here', requires: [['ELEVATE', 'AGITATE', 'REFRAME'], ['IDENTIFY']], maxWords: 14, headlineLike: true },
+    first_line: { label: 'first line of the body', job: 'pay off the headline and earn the second line', requires: [['DISRUPT', 'IDENTIFY', 'AGITATE', 'REFRAME', 'PROVE', 'ELEVATE', 'BOND']], headlineLike: false },
+    video_hook: { label: 'video hook', job: 'stop the scroll in the first three seconds', requires: [['DISRUPT'], ['IDENTIFY']], maxWords: 9, spoken: true, headlineLike: false },
+    social_post_open: { label: 'social post opening', job: 'earn the tap on "see more"', requires: [['DISRUPT'], ['IDENTIFY']], visibleChars: 140, visibleNote: 'only about 140 characters show before "see more" on a phone', headlineLike: true },
+    sales_letter_headline: { label: 'sales letter headline', job: 'stop the right reader and promise the big idea', requires: [['DISRUPT', 'ELEVATE', 'AGITATE'], ['IDENTIFY']], headlineLike: true },
+};
+export const article = (s) => (/^[aeiou]/i.test(s) ? `an ${s}` : `a ${s}`);
+function requirements(slot, awareness) {
+    const req = SLOT_INFO[slot].requires.map((g) => [...g]);
+    if (awareness === 'most_aware')
+        for (const g of req)
+            if (g.includes('DISRUPT') && !g.includes('COMPEL'))
+                g.push('COMPEL'); // the offer is the hook
+    return req;
+}
+/** What a set of requirement groups asks for, in words: '"A?" and "B?", plus one of "C?", "D?" or "E?"' */
+export function questionsNeeded(groups) {
+    const q = (r) => `"${ROLES[r].question}"`;
+    const singles = groups.filter((g) => g.length === 1).map((g) => q(g[0]));
+    const choices = groups.filter((g) => g.length > 1).map((g) => `${g.length === 2 ? 'either' : 'one of'} ${joinList(g.map(q), 'or')}`);
+    if (!singles.length)
+        return joinList(choices);
+    return choices.length ? `${joinList(singles)}, plus ${joinList(choices)}` : joinList(singles);
+}
+// ── evidence: traits that replicated in all three Upworthy splits (data/trait-evidence.json) ──
+const EVIDENCE_SOURCE = 'The evidence comes from the Upworthy Research Archive, thousands of real headline tests run on news stories between 2013 and 2015, ' +
+    'each one measuring clicks with the image held the same. The effects are small, and they come from news headlines and not ads, so treat them as a nudge and never as a verdict.';
+const TRAIT_EVIDENCE = [
+    { name: 'question', test: (s) => s.includes('?'), text: 'Headlines phrased as a question won only 39% of 4,217 real head-to-head tests, so consider saying it as a statement.', good: false },
+    { name: 'exclamation', test: (s) => s.includes('!'), text: 'Headlines with an exclamation mark won only 40% of 761 tests.', good: false },
+    { name: 'emphasis_caps', test: (s) => /\b[A-Z]{3,}\b|\*\w+\*/.test(s), text: 'Headlines with a word in CAPS or *emphasis* won only 42% of 1,776 tests.', good: false },
+    { name: 'number', test: (s) => /\d/.test(s.replace(/#\s?1\b|\bno\.?\s?1\b/gi, '')), text: 'Headlines with a number in them won 54% of 3,316 tests.', good: true },
+    { name: 'this_these', test: (s) => /\b(this|these|here's|here is)\b/i.test(s), text: 'Headlines that point at something with "this", "these" or "here\'s" won 56% of 5,522 tests.', good: true },
+    { name: 'time_word', test: (s) => /\b(day|days|week|weeks|month|months|year|years|minute|minutes|hour|hours|today)\b/i.test(s), text: 'Headlines with a time word, like "days" or "today", won 54% of 2,158 tests.', good: true },
+];
+// ── text helpers ─────────────────────────────────────────────────────────────
+const STOP = new Set('a an the and or of to in on for with by is are be as at it its from their they them who will was were has have had his her he she we i me so if but not no do does did just about into than up out off over can all one my our your you yours this that these those what when why how there here'.split(' '));
+/** Marketing-generic words: never count as "only you could say this". */
+const GENERIC = new Set(('sale sales deal deals offer offers discount discounts save saving savings percent best great good amazing awesome incredible new now today tonight ' +
+    'free shop buy get order product products service services solution solutions platform tool tools app quality premium easy simple fast quick ' +
+    'year years day days week weeks month months time limited exclusive biggest ultimate everything more miss dont don black friday cyber monday holiday season special big huge top ' +
+    'number help helps make makes need want find start try learn discover join click link finally really actually only every everyone people customer customers ' +
+    'business businesses company team teams work life world way ways thing things result results better worse love perfect proven guaranteed').split(' '));
+const norm = (s) => s.toLowerCase().replace(/[‘’]/g, "'").replace(/[“”]/g, '"').replace(/\s+/g, ' ').trim();
+function contentTokens(s) {
+    return (norm(s).match(/[a-z][a-z']+/g) ?? [])
+        .map((w) => w.replace(/'s$/, '').replace(/'/g, ''))
+        .filter((w) => w.length > 2 && !STOP.has(w))
+        .map((w) => (w.length > 4 && w.endsWith('ies') ? w.slice(0, -3) + 'y' : w.length > 4 && w.endsWith('s') && !w.endsWith('ss') ? w.slice(0, -1) : w));
+}
+const specificTokens = (s) => new Set(contentTokens(s).filter((w) => !GENERIC.has(w)));
+/** normalized token -> the word as written, for readable output */
+function surfaceWords(s) {
+    const m = new Map();
+    for (const raw of s.match(/[A-Za-z][A-Za-z'’]+/g) ?? []) {
+        const [t] = contentTokens(raw);
+        if (t && !m.has(t))
+            m.set(t, raw);
+    }
+    return m;
+}
+const numbersIn = (s) => new Set((s.match(/\d[\d,.]*/g) ?? []).map((n) => n.replace(/[,.]$/, '').replace(/,/g, '')));
+const quoted = (ws) => joinList(ws.map((w) => `"${w}"`));
+// ── swap test ────────────────────────────────────────────────────────────────
+/** Brand and product names: the explicit brand, plus capitalized words inside the product
+ *  description that are not its first word (a first word may just be sentence case). */
+function brandTokens(product, brand) {
+    const out = new Set(brand ? contentTokens(brand) : []);
+    const words = product.match(/[A-Za-z][A-Za-z'’]+/g) ?? [];
+    words.forEach((w, i) => { if (/^[A-Z]/.test(w) && (i > 0 || /[a-z][A-Z]/.test(w) || product.trim().split(/\s+/).length <= 3))
+        for (const t of contentTokens(w))
+            out.add(t); });
+    return out;
+}
+/**
+ * The swap test (Thesis II): could a competitor send this line unchanged?
+ * only_you: names the brand, or a fact from your proof. on_target: names this reader's situation or the
+ * product's specifics (a direct competitor could match it). concrete_but_swappable: only a number or offer
+ * term. generic: nothing specific. unknown: no brief.
+ */
+export function swapTest(text, brief, context) {
+    const line = specificTokens(text);
+    const lineNums = numbersIn(text.replace(/#\s?1\b/g, ''));
+    const surface = surfaceWords(text);
+    const show = (ws) => ws.map((w) => surface.get(w) ?? w);
+    const hasBrief = !!brief && Object.values(brief).some((v) => v && v.trim());
+    if (hasBrief) {
+        const brand = brandTokens(brief.product ?? '', brief.brand);
+        const proof = specificTokens(brief.proof ?? '');
+        const proofNums = numbersIn(brief.proof ?? '');
+        const target = specificTokens(`${brief.brand ?? ''} ${brief.product ?? ''} ${brief.audience ?? ''}`);
+        const offer = specificTokens(brief.offer ?? '');
+        const mine = [...show([...line].filter((w) => brand.has(w) || proof.has(w))), ...[...lineNums].filter((n) => proofNums.has(n))];
+        if (mine.length)
+            return { level: 'only_you', specifics: mine, note: `No competitor could send it, because it names ${quoted(mine)}.` };
+        const onTarget = show([...line].filter((w) => target.has(w)));
+        if (onTarget.length)
+            return { level: 'on_target', specifics: onTarget, note: `It speaks to this reader and this offer with ${quoted(onTarget)}, but a direct competitor could still send it. Add the brand name or a fact from your proof and it becomes yours alone.` };
+        const offerHits = show([...line].filter((w) => offer.has(w)));
+        if (lineNums.size || offerHits.length) {
+            return { level: 'concrete_but_swappable', specifics: [...lineNums, ...offerHits], note: "It's concrete, but any competitor with the same offer could send it word for word. Nothing in it names this product, this reader or your proof." };
+        }
+        return { level: 'generic', specifics: [], note: 'Any competitor could send this word for word, because nothing in it belongs to this product, this reader, this offer or your proof.' };
+    }
+    if (context && context.trim()) {
+        const ctx = specificTokens(context);
+        const shared = show([...line].filter((w) => ctx.has(w)));
+        return { level: 'unknown', specifics: shared, note: shared.length
+                ? `It shares ${quoted(shared.slice(0, 4))} with the rest of the copy. Pass the brief, meaning the product, audience, offer and proof, and the swap test can tell you whether a competitor could send it.`
+                : 'It shares nothing specific with the rest of the copy. Pass the brief, meaning the product, audience, offer and proof, so the swap test can run.' };
+    }
+    return { level: 'unknown', specifics: [], note: "The swap test didn't run because there's no brief. Pass the product, audience, offer and proof." };
+}
+/** Completes 'Answer "<question>" by ...' */
+const ROLE_FIX = {
+    DISRUPT: "adding one surprising, specific detail, or a tension they didn't see coming",
+    IDENTIFY: 'naming the reader or something that is theirs, like "your boots" or "bakery owners"',
+    AGITATE: 'naming what the problem is costing them',
+    REFRAME: "showing them the problem from an angle they haven't considered",
+    PROVE: 'putting the proof right next to the claim',
+    ELEVATE: 'showing them, specifically, what life looks like after',
+    RESOLVE: "removing the main reason they'd hesitate",
+    COMPEL: 'giving them an honest reason to act now, like the offer or the deadline',
+    BOND: "sounding like a specific person they'd trust",
+};
+const SUPERLATIVE = /(#\s?1\b|\bnumber one\b|\bthe best\b|\bbest[- ]in[- ]class\b|\bleading\b|\bworld'?s (best|first|most|leading)\b|\btop[- ]rated\b|\bunmatched\b|\brevolutionary\b|\bbiggest\b|\bultimate\b|\bgreatest\b)/i;
+const BACKED = /\b(according to|rated by|ranked by|verified|audited|source:|survey|study)\b|\d[\d,.]*\s?(%|customers|users|reviews|stars|brands|teams)/i;
+const RESULT_CLAIM = /\b(\d+x|doubles?|triples?|increases?|boosts?|cuts?|saves?|earns?|grows?|loses?|gains?)\b/i;
+// ── the check ────────────────────────────────────────────────────────────────
+export function checkHook(input) {
+    const { text, slot } = input;
+    const info = SLOT_INFO[slot];
+    const needs = requirements(slot, input.awareness);
+    const nText = norm(text);
+    const hardFails = [];
+    const warnings = [];
+    const believability = [];
+    // 1. the job: verify each label's quote is really in the line (and visible)
+    const verified = [];
+    const unverified = [];
+    const cutoff = info.visibleChars;
+    const cpLen = Array.from(text).length;
+    let cutFail = false;
+    for (const a of input.answers) {
+        const w = norm(a.words);
+        const at = w ? nText.indexOf(w) : -1;
+        if (at < 0) {
+            unverified.push(a);
+            continue;
+        }
+        if (cutoff && cpLen > cutoff && at + w.length > cutoff) {
+            cutFail = true;
+            hardFails.push(`The words that answer "${ROLES[a.question].question}" ("${a.words}") fall past the cutoff, and since ${info.visibleNote}, most readers never see them.`);
+            continue;
+        }
+        verified.push(a);
+    }
+    const answered = [...new Set(verified.map((a) => a.question))];
+    const missing = needs.filter((g) => !g.some((r) => answered.includes(r)));
+    // 2. swap test
+    const swap = swapTest(text, input.brief, input.context);
+    // 3. hard facts
+    let visible = null;
+    if (cutoff)
+        visible = cpLen > cutoff ? Array.from(text).slice(0, cutoff).join('') + '…' : text;
+    if (cutoff && cpLen > cutoff && !cutFail) {
+        const w = `It runs past the cutoff, and since ${info.visibleNote}, readers see only "${visible}". Make sure the point lands before that.`;
+        warnings.push(w);
+        believability.push(w);
+    }
+    const words = text.trim().split(/\s+/).filter(Boolean).length;
+    if (info.spoken && words > (info.maxWords ?? 9))
+        warnings.push(`At ${words} words it takes about ${(words / 2.7).toFixed(1)} seconds to say. The hook has to land in the first three seconds, which is about ${info.maxWords} words.`);
+    else if (info.maxWords && words > info.maxWords)
+        warnings.push(`It runs ${words} words. Headlines in this spot usually land in ${info.maxWords} or fewer.`);
+    const smell = smellSentences(detectAISmell(text).violations);
+    hardFails.push(...smell);
+    const superlative = SUPERLATIVE.test(text) && !BACKED.test(text);
+    const bareResult = RESULT_CLAIM.test(text) && !/\d/.test(text) && !BACKED.test(text);
+    if (superlative) {
+        const w = 'It makes a superlative claim, like "best", "#1" or "biggest", with no proof in the same line, and readers discount those on sight.';
+        warnings.push(w);
+        believability.push(w);
+    }
+    if (bareResult) {
+        const w = 'It claims a result without a number, a source or a quote to back it up.';
+        warnings.push(w);
+        believability.push(w);
+    }
+    if (input.follows && input.follows.trim()) {
+        const prev = specificTokens(input.follows);
+        const shared = [...specificTokens(text)].filter((w) => prev.has(w));
+        if (!shared.length && (slot === 'first_line' || slot === 'landing_page_headline')) {
+            warnings.push(`It picks up nothing specific from what the reader just saw ("${safeSlice(input.follows, 80)}"). Readers feel that break, and that is when they leave.`);
+        }
+    }
+    // 4. evidence (headline-like slots only)
+    const traits = info.headlineLike ? TRAIT_EVIDENCE.filter((t) => t.test(text)) : [];
+    const evidence = traits.map((t) => t.text);
+    const evidenceAgainst = traits.filter((t) => !t.good).map((t) => t.text);
+    // verdict
+    const labeled = input.answers.length > 0;
+    const jobMet = labeled && missing.length === 0;
+    // Unproven claims cannot pass: they are what readers discount first.
+    const unbacked = superlative || bareResult;
+    let verdict;
+    if (hardFails.length)
+        verdict = jobMet ? 'partly' : 'doesnt';
+    // Passing needs the swap test to have actually run (a brief) and found something specific.
+    else if (jobMet && !unbacked && (swap.level === 'only_you' || swap.level === 'on_target'))
+        verdict = 'does_its_job';
+    else if (missing.length === needs.length || (swap.level === 'generic' && !jobMet))
+        verdict = 'doesnt'; // answers none of what this slot needs
+    else
+        verdict = 'partly';
+    // The swap test gets its own sentence, so the bet names only the questions.
+    const bet = answered.length
+        ? `It's betting on ${joinList(answered.map((r) => ROLES[r].gloss))}.`
+        : "It doesn't answer any of the questions this spot needs.";
+    // one best fix, highest-leverage first
+    let fix;
+    if (cutFail)
+        fix = `Move the words that answer the question into the first ${cutoff} characters.`;
+    else if (smell.length)
+        fix = 'Replace the stock phrasing with something only this product could say.';
+    else if (missing.length)
+        fix = `Answer "${ROLES[missing[0][0]].question}" by ${ROLE_FIX[missing[0][0]]}.`;
+    else if (unbacked)
+        fix = 'Back the claim up in the same line, with who ranked it, a number or a source, or swap it for a specific fact a reader could check.';
+    else if (swap.level === 'generic' || swap.level === 'concrete_but_swappable')
+        fix = "Add something specific, like the reader's situation, the product itself or a proof number.";
+    else if (swap.level === 'unknown')
+        fix = 'Pass the brief, meaning the brand, product, offer, audience and proof, so the swap test can run.';
+    else if (traits.some((t) => t.name === 'question'))
+        fix = 'Try it as a statement, since question headlines lose most head-to-head tests.';
+    else
+        fix = 'Nothing needs fixing before you test it.';
+    return { text, slot, verdict, needs, answered, missing, unverified, swap, visible, hardFails, warnings, believability, evidence, evidenceAgainst, bet, fix };
+}
+/** Completes a heading like '"Your bakery posted 3 times..." ___' */
+export const VERDICT_LABEL = { does_its_job: 'does its job', partly: 'partly does its job', doesnt: "doesn't do its job" };
+export { EVIDENCE_SOURCE };
+/** The body of a checked line as one paragraph: the bet, what is missing, the swap test, the problems. */
+export function describeCheck(c, opts = {}) {
+    const parts = [c.bet];
+    if (c.missing.length)
+        parts.push(endSentence(`It still has to answer ${questionsNeeded(c.missing)}`));
+    parts.push(c.swap.note, ...c.hardFails, ...c.warnings);
+    if (opts.evidence !== false)
+        parts.push(...c.evidence);
+    return parts.join(' ');
+}
+/** Compare checked lines: drop hard failures, describe each bet, recommend a test. */
+export function compareHooks(checks, names) {
+    const good = checks.map((c, i) => ({ c, n: names[i] })).filter((x) => x.c.verdict === 'does_its_job');
+    const betKey = (c) => c.answered.slice().sort().join('+');
+    const betOn = (c) => c.bet.replace(/^It's betting on /, 'is betting on ').replace(/\.$/, '');
+    if (good.length >= 2) {
+        const [a, ...rest] = good;
+        const b = rest.find((x) => betKey(x.c) !== betKey(a.c));
+        if (b)
+            return `Test ${a.n} against ${b.n}. They make different bets. ${a.n} ${betOn(a.c)}, and ${b.n} ${betOn(b.c)}. Whichever wins tells you which question matters more to this reader.`;
+        return `${joinList(good.map((x) => x.n))} make the same bet, so testing one against the other won't teach you much. Keep ${a.n}, and write a challenger that answers a different question.`;
+    }
+    if (good.length === 1)
+        return `Use ${good[0].n}. If you want to learn something, test it against a line that answers a different question.`;
+    const partly = checks.map((c, i) => ({ c, n: names[i] })).filter((x) => x.c.verdict === 'partly');
+    if (partly.length)
+        return `None of these does its job yet. ${joinList(partly.map((x) => x.n))} ${partly.length === 1 ? 'comes' : 'come'} closest, so apply the fix below and check again.`;
+    return 'None of these does its job yet. Start with the fixes below.';
+}

package/dist/http.d.ts

@@ -0,0 +1,12 @@
+/** What a JSON-RPC body asks for, without its arguments, so it is safe to log. */
+export declare function describeRequest(body: unknown): {
+    method: string;
+    tool?: string;
+}[];
+/**
+ * Answer one MCP request. Pass `parsedBody` if the caller already read the body (to log it, say),
+ * since a Request body can only be read once.
+ */
+export declare function handleMcpRequest(request: Request, opts?: {
+    parsedBody?: unknown;
+}): Promise<Response>;

package/dist/http.js

@@ -0,0 +1,62 @@
+/**
+ * The hosted endpoint: stateless Streamable HTTP, built on web-standard Request and Response so it
+ * runs anywhere that speaks fetch (a Next.js route, a Vercel or Cloudflare function, Node 18+).
+ *
+ * Every request gets its own server and transport. There is no session to keep, and data.ts loads
+ * the catalog once per process, so a fresh server costs only the tool registration. Responses are
+ * plain JSON, not an SSE stream, because every tool answers in one shot.
+ */
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { buildServer } from './server.js';
+const CORS = {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization, Mcp-Session-Id, Mcp-Protocol-Version, Last-Event-ID',
+    'Access-Control-Expose-Headers': 'Mcp-Session-Id, Mcp-Protocol-Version',
+};
+function withCors(res) {
+    const headers = new Headers(res.headers);
+    for (const [k, v] of Object.entries(CORS))
+        headers.set(k, v);
+    return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+}
+const ABOUT = `This is the Persuasion Taxonomy MCP server, from Coppica. It's free and needs no key.
+
+To use it, add this URL to any MCP client as a remote server (Streamable HTTP):
+https://taxonomy.coppica.com/mcp
+
+Setup for Claude, ChatGPT, Cursor and others: https://github.com/Otha-Labs/persuasion-mcp
+`;
+/** What a JSON-RPC body asks for, without its arguments, so it is safe to log. */
+export function describeRequest(body) {
+    const items = Array.isArray(body) ? body : [body];
+    return items.flatMap((m) => {
+        if (!m || typeof m !== 'object' || typeof m.method !== 'string')
+            return [];
+        const { method, params } = m;
+        return [{ method, ...(method === 'tools/call' && typeof params?.name === 'string' ? { tool: params.name } : {}) }];
+    });
+}
+/**
+ * Answer one MCP request. Pass `parsedBody` if the caller already read the body (to log it, say),
+ * since a Request body can only be read once.
+ */
+export async function handleMcpRequest(request, opts = {}) {
+    if (request.method === 'OPTIONS')
+        return new Response(null, { status: 204, headers: CORS });
+    if (request.method !== 'POST') {
+        // Stateless server: no stream to resume and no session to end. A browser that opens the URL
+        // gets a short note on how to connect instead of a protocol error.
+        return new Response(ABOUT, { status: 405, headers: { ...CORS, Allow: 'POST, OPTIONS', 'Content-Type': 'text/plain; charset=utf-8' } });
+    }
+    const server = buildServer();
+    const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+    await server.connect(transport);
+    try {
+        return withCors(await transport.handleRequest(request, opts));
+    }
+    finally {
+        await transport.close().catch(() => { });
+        await server.close().catch(() => { });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { buildServer } from './server.js';
+const server = buildServer();
+await server.connect(new StdioServerTransport());

package/dist/roles.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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 declare const ROLE_NAMES: readonly ["DISRUPT", "IDENTIFY", "AGITATE", "REFRAME", "PROVE", "ELEVATE", "RESOLVE", "COMPEL", "BOND"];
+export type Role = (typeof ROLE_NAMES)[number];
+export interface RoleInfo {
+    num: number;
+    name: Role;
+    question: string;
+    ifMissing: string;
+    /** Completes "Right now, ..." when the copy leaves this question unanswered. */
+    gap: string;
+    /** Completes "It's betting on ..." and "This question is about ...". */
+    gloss: string;
+}
+export declare const ROLES: Record<Role, RoleInfo>;
+/** The question in quotes, with its role name, for the places a model needs both. */
+export declare const roleLabel: (r: Role) => string;
+export declare const GOALS: readonly ["purchase", "signup", "click", "engagement"];
+export type Goal = (typeof GOALS)[number];
+/** 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 declare const GOAL_REQUIREMENTS: Record<Goal, Role[][]>;
+/** "For a signup, ..." */
+export declare const GOAL_NOUN: Record<Goal, string>;
+/** "a landing page that ..." */
+export declare const GOAL_CLAUSE: Record<Goal, string>;
+export declare function expectedRoles(goal: Goal): Set<Role>;
+export declare const FORMATS: readonly ["ad", "landing_page", "sales_letter", "email", "email_subject", "social_post", "video_script", "headline"];
+export type Format = (typeof FORMATS)[number];
+export declare const FORMAT_LABEL: Record<Format, string>;
+/** Corpus channel groups where evidence for a technique counts toward "fits this format". */
+export declare const FORMAT_CHANNELS: Record<Format, string[]>;
+export declare const AWARENESS: readonly ["unaware", "problem_aware", "solution_aware", "product_aware", "most_aware"];
+export type Awareness = (typeof AWARENESS)[number];
+export declare const AWARENESS_WEIGHT: Record<Awareness, {
+    heavy: Role[];
+    note: string;
+}>;
+/** 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 declare const COHERENCE_CHECKS: {
+    roles: [Role, Role];
+    check: string;
+}[];
+export declare const SYMPTOMS: readonly ["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"];
+export type Symptom = (typeof SYMPTOMS)[number];
+export interface SymptomInfo {
+    /** Completes "Why it isn't converting: ..." */
+    label: string;
+    /** why + check read as one paragraph: what is going wrong, then how to see it for yourself. */
+    suspects: {
+        role: Role | 'COHERENCE';
+        why: string;
+        check: string;
+    }[];
+    ruleOutFirst: string;
+}
+/** Symptom map (reviewed 2026-10-04), derived from each role's "if missing" consequence. */
+export declare const SYMPTOM_MAP: Record<Symptom, SymptomInfo>;
+export declare function normalizeRole(v: unknown): unknown;