diff --git a/app/actions/leads.ts b/app/actions/leads.ts
index a44e74d9..b2c378c0 100644
--- a/app/actions/leads.ts
+++ b/app/actions/leads.ts
@@ -402,6 +402,11 @@ export async function saveCampaignAction(input: {
   angle?: string;
   senderName?: string;
   replyTo?: string;
+  pitchMode?: "audit" | "custom";
+  pitchIntro?: string;
+  pitchAsk?: string;
+  pitchFacts?: string;
+  scanProspects?: boolean;
 }): Promise<Ok<{ note: string }> | Err> {
   const auth = await requireLeadAccess(input.projectId);
   if (!auth.ok) return auth;
@@ -412,6 +417,38 @@ export async function saveCampaignAction(input: {
   if (!queries.length && !seedUrls.length) {
     return { ok: false, error: "A campaign needs at least one search query or directory URL." };
   }
+  const pitchMode = input.pitchMode ?? "audit";
+  const pitchFacts = (input.pitchFacts ?? "")
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (pitchMode === "custom") {
+    // The same bar the audit pitch holds itself to: without a description
+    // and some declared facts there is nothing truthful for a draft to say,
+    // and the grounding guard would reject every draft anyway.
+    if (!input.pitchIntro?.trim()) {
+      return { ok: false, error: "A custom pitch needs a description of who is writing and why." };
+    }
+    if (!pitchFacts.length) {
+      return {
+        ok: false,
+        error:
+          "A custom pitch needs at least one fact. Drafts may only state what you list here, so an empty list means every draft gets rejected.",
+      };
+    }
+  }
+
+  // Scanning is the audit pitch's evidence step; default it off for a custom
+  // pitch rather than scanning people we're emailing about something else.
+  const scanProspects = input.scanProspects ?? pitchMode === "audit";
+  if (pitchMode === "audit" && !scanProspects) {
+    return {
+      ok: false,
+      error:
+        "The audit pitch is built from scan findings, so it can't run with scanning turned off. Switch to a custom pitch instead.",
+    };
+  }
+
   if (input.autoSend) {
     const postal = await loadAddressSettings({ projectId: input.projectId, ownerId: auth.userId });
     if (!postal.address) {
@@ -440,6 +477,11 @@ export async function saveCampaignAction(input: {
         angle: input.angle?.trim() || null,
         sender_name: input.senderName?.trim() || null,
         reply_to: input.replyTo?.trim() || null,
+        pitch_mode: pitchMode,
+        pitch_intro: input.pitchIntro?.trim() || null,
+        pitch_ask: input.pitchAsk?.trim() || null,
+        pitch_facts: pitchFacts,
+        scan_prospects: scanProspects,
       },
       { onConflict: "project_id,name" },
     );
diff --git a/components/leads/campaign-panel.tsx b/components/leads/campaign-panel.tsx
index 98f5b22a..efd74a63 100644
--- a/components/leads/campaign-panel.tsx
+++ b/components/leads/campaign-panel.tsx
@@ -47,6 +47,11 @@ export function CampaignPanel({
   const [maxScore, setMaxScore] = useState(70);
   const [dailyLimit, setDailyLimit] = useState(10);
   const [angle, setAngle] = useState("");
+  const [pitchMode, setPitchMode] = useState<"audit" | "custom">("audit");
+  const [pitchIntro, setPitchIntro] = useState("");
+  const [pitchAsk, setPitchAsk] = useState("");
+  const [pitchFacts, setPitchFacts] = useState("");
+  const [scanProspects, setScanProspects] = useState(true);
   const [senderName, setSenderName] = useState("");
   const [replyTo, setReplyTo] = useState("");
 
@@ -75,6 +80,11 @@ export function CampaignPanel({
         angle,
         senderName,
         replyTo,
+        pitchMode,
+        pitchIntro,
+        pitchAsk,
+        pitchFacts,
+        scanProspects,
       }),
     );
 
@@ -215,6 +225,80 @@ export function CampaignPanel({
               onChange={(e) => setDailyLimit(Number(e.target.value))}
             />
           </label>
+          <label className="text-sm sm:col-span-2">
+            What is this campaign pitching?
+            <select
+              className="input mt-1 w-full"
+              value={pitchMode}
+              onChange={(e) => {
+                const next = e.target.value as "audit" | "custom";
+                setPitchMode(next);
+                // Scanning is the audit pitch's evidence step. A custom pitch
+                // has no reason to scan the people it writes to.
+                setScanProspects(next === "audit");
+              }}
+            >
+              <option value="audit">A CrawlProof scan of their site</option>
+              <option value="custom">Something else — I&apos;ll describe it</option>
+            </select>
+          </label>
+
+          {pitchMode === "custom" && (
+            <>
+              <label className="text-sm sm:col-span-2">
+                Who is writing, and why
+                <textarea
+                  className="input mt-1 w-full"
+                  rows={2}
+                  value={pitchIntro}
+                  onChange={(e) => setPitchIntro(e.target.value)}
+                  placeholder="Anthony, a freelance 3D modeller looking for contract work with game studios"
+                />
+              </label>
+              <label className="text-sm sm:col-span-2">
+                Facts drafts may state — one per line
+                <textarea
+                  className="input mt-1 w-full font-mono text-xs"
+                  rows={4}
+                  value={pitchFacts}
+                  onChange={(e) => setPitchFacts(e.target.value)}
+                  placeholder={"9 years of experience in hard-surface modelling\nPortfolio at https://example.com/work\nAvailable from March"}
+                />
+                <span className="mt-1 block text-xs text-[var(--color-muted)]">
+                  Drafts are checked against this list and rejected if they state anything else.
+                  Numbers and links that don&apos;t appear here are treated as invented.
+                </span>
+              </label>
+              <label className="text-sm sm:col-span-2">
+                The one ask
+                <input
+                  className="input mt-1 w-full"
+                  value={pitchAsk}
+                  onChange={(e) => setPitchAsk(e.target.value)}
+                  placeholder="take a look at my portfolio"
+                />
+              </label>
+            </>
+          )}
+
+          <label className="flex items-start gap-2 text-sm sm:col-span-2">
+            <input
+              type="checkbox"
+              className="mt-1"
+              checked={scanProspects}
+              onChange={(e) => setScanProspects(e.target.checked)}
+              disabled={pitchMode === "audit"}
+            />
+            <span>
+              Scan each discovered lead
+              <span className="mt-0.5 block text-xs text-[var(--color-muted)]">
+                {pitchMode === "audit"
+                  ? "Required for the audit pitch — the email is built from what the scan finds."
+                  : "Off by default: this campaign isn't pitching an audit, so there's nothing to scan for."}
+              </span>
+            </span>
+          </label>
+
           <label className="text-sm sm:col-span-2">
             Angle (optional)
             <input
diff --git a/lib/outreach/cold.ts b/lib/outreach/cold.ts
index 14b975d6..866c3ea1 100644
--- a/lib/outreach/cold.ts
+++ b/lib/outreach/cold.ts
@@ -338,6 +338,61 @@ export function unsupportedClaims(body: string, facts: ProspectFacts): string[]
   return problems;
 }
 
+/**
+ * Grounding guard for a custom pitch.
+ *
+ * The audit pitch earns its claims from a scan. A custom pitch has no scan,
+ * so the campaign declares what it is allowed to say and this checks the
+ * draft against that list. Dropping the guard entirely for custom campaigns
+ * would turn the same machinery into something that states invented facts
+ * about strangers, at volume, over email.
+ *
+ * The check is deliberately narrow. Proving a sentence is entailed by a fact
+ * list is not something a regex can do, and pretending otherwise would give
+ * false confidence. What it catches is the specific, checkable species of
+ * fabrication: numbers and durations that appear nowhere in the declared
+ * facts, links to places the campaign never mentioned, and claimed prior
+ * contact. Tone and phrasing are the prompt's job.
+ */
+export function unsupportedCustomClaims(body: string, facts: string[]): string[] {
+  const problems: string[] = [];
+  const lower = body.toLowerCase();
+  const declared = facts.join(" \n ").toLowerCase();
+
+  // A number in the body that appears in no declared fact is invented —
+  // years of experience, team sizes, prices. Small integers are excluded
+  // because they are usually prose ("one thing", "a couple of weeks").
+  for (const m of body.matchAll(/\b(\d[\d,]*(?:\.\d+)?)\s*(%|\+)?/g)) {
+    const raw = m[1].replace(/,/g, "");
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value <= 3) continue;
+    const appears = declared.includes(raw) || declared.includes(m[1].toLowerCase());
+    if (!appears) problems.push(`states "${m[0].trim()}", which is not in the campaign's declared facts`);
+  }
+
+  // Links have to come from the declared facts too: a made-up portfolio URL
+  // is both a false claim and a broken promise.
+  for (const m of body.matchAll(/https?:\/\/[^\s)>\]]+/gi)) {
+    const url = m[0].replace(/[.,]$/, "");
+    if (!declared.includes(url.toLowerCase())) {
+      problems.push(`links to ${url}, which is not in the campaign's declared facts`);
+    }
+  }
+
+  for (const phrase of [
+    "as we discussed",
+    "following up on our call",
+    "great speaking with you",
+    "as promised",
+    "per our conversation",
+    "thanks for your time yesterday",
+  ]) {
+    if (lower.includes(phrase)) problems.push(`implies a prior relationship: "${phrase}"`);
+  }
+
+  return [...new Set(problems)];
+}
+
 // ------------------------------------------------- obfuscation & link crawl
 
 /**
diff --git a/lib/outreach/pipeline.ts b/lib/outreach/pipeline.ts
index 80a5507d..93ddf251 100644
--- a/lib/outreach/pipeline.ts
+++ b/lib/outreach/pipeline.ts
@@ -37,6 +37,7 @@ import {
   stepGuidance,
   suppressionReason,
   unsupportedClaims,
+  unsupportedCustomClaims,
   type ContactCandidate,
   type OutreachStep,
   type ProspectFacts,
@@ -272,6 +273,8 @@ export async function researchProspect(input: {
   notes?: string | null;
   discoveredVia?: string | null;
   discoveryLabel?: string | null;
+  /** Don't queue a scan for prospects we have no audit for. */
+  skipScan?: boolean;
 }): Promise<ResearchResult> {
   const check = isAllowedTargetUrl(input.url);
   if (!check.ok) return { status: "error", message: check.reason };
@@ -288,6 +291,14 @@ export async function researchProspect(input: {
   }
 
   const audit = await latestAuditForHost(input.userId, host);
+  // A campaign that isn't pitching an audit has no use for a scan, and
+  // scanning someone in order to email them about something else is both
+  // wasted worker time and a poor look. Skipping it moves the prospect
+  // straight to contact discovery instead of parking it on a scan that
+  // nothing will ever read.
+  if (!audit && input.skipScan) {
+    return researchWithoutScan({ ...input, host, target });
+  }
   if (!audit) {
     const started = await startFreeScan({ userId: input.userId, url: target });
     if (!started.ok) return { status: "error", message: started.error };
@@ -372,6 +383,71 @@ export async function researchProspect(input: {
   };
 }
 
+/**
+ * Research a prospect without scanning it.
+ *
+ * All a non-audit campaign needs is a way to reach someone, so this does
+ * contact discovery and stops. The prospect lands as "researched" with no
+ * score and no findings, which is honest: nothing was measured, and the
+ * draft path for these campaigns doesn't claim otherwise.
+ */
+async function researchWithoutScan(input: {
+  userId: string;
+  projectId: string;
+  campaignId?: string | null;
+  contactEmail?: string | null;
+  notes?: string | null;
+  discoveredVia?: string | null;
+  discoveryLabel?: string | null;
+  host: string;
+  target: string;
+}): Promise<ResearchResult> {
+  const { host, target } = input;
+  const candidates = input.contactEmail
+    ? [
+        {
+          email: normalizeEmail(input.contactEmail),
+          source: "manual" as const,
+          sameDomain: normalizeEmail(input.contactEmail).endsWith(`@${host}`),
+        },
+      ]
+    : await findContact(host);
+  const contact = bestContact(candidates);
+
+  const { data, error } = await serviceClient()
+    .from("outreach_prospects")
+    .upsert(
+      {
+        project_id: input.projectId,
+        owner_id: input.userId,
+        channel: "email",
+        target_key: host,
+        site_url: target,
+        campaign_id: input.campaignId ?? null,
+        discovered_via: input.discoveredVia ?? null,
+        discovery_label: input.discoveryLabel ?? null,
+        contact_email: contact?.email ?? null,
+        contact_source: contact?.source ?? null,
+        status: contact ? "researched" : "new",
+        ...(input.notes ? { notes: input.notes } : {}),
+      },
+      { onConflict: "project_id,channel,target_key" },
+    )
+    .select(PROSPECT_COLUMNS)
+    .maybeSingle();
+  if (error || !data) {
+    return { status: "error", message: error?.message ?? "Could not save the prospect." };
+  }
+
+  return {
+    status: "researched",
+    prospect: data as ProspectRow,
+    contact,
+    candidates,
+    quoteLabel: "not scanned — this campaign doesn't pitch an audit",
+  };
+}
+
 // ------------------------------------------------------------------- drafting
 
 const DraftSchema = z.object({
@@ -392,6 +468,37 @@ Hard rules, in order of importance:
 7. One ask, and make it the low-commitment one: look at the report. Never ask for a call in a first message.
 8. Write like a person who ran a scan and thought the result was worth mentioning — because that is exactly what happened.`;
 
+/**
+ * A campaign's own pitch, for campaigns that aren't selling a CrawlProof scan.
+ *
+ * `facts` is what the draft is permitted to assert. It replaces scan findings
+ * as the grounding set, so the honesty guarantee survives the change of
+ * subject rather than being dropped along with it.
+ */
+export type CampaignPitch = {
+  intro: string;
+  ask?: string | null;
+  facts: string[];
+};
+
+/** System prompt for a campaign pitching something other than a scan. */
+export function customDraftSystem(pitch: CampaignPitch): string {
+  return `You write cold outreach email on behalf of the sender described below. You are not selling a website audit; write only the pitch described.
+
+WHO IS WRITING AND WHY:
+${pitch.intro}
+
+Hard rules, in order of importance:
+1. Every factual claim must come from the FACTS supplied to you. If something is not in the facts, you do not know it, and you may not state it. Invent no numbers, dates, durations, links, company names or credentials.
+2. Say nothing about the recipient's business as fact. You have not researched them. You may say why you are writing to someone like them, not what they are doing wrong.
+3. Never imply a prior relationship. They have never heard from the sender. No "following up", no "as discussed", no "thanks for your time".
+4. No invented urgency, no fake deadlines, no flattery about work you have not seen.
+5. Short. Under 120 words for a first contact.
+6. Plain language. No "In today's digital landscape", "unlock", "leverage", "elevate", "game-changer", "delve", "reach out", "circle back", "I hope this email finds you well".
+7. One ask${pitch.ask ? `, and it is this: ${pitch.ask}` : ", and make it low-commitment"}. Never ask for a call in a first message.
+8. Write like one person emailing another, because that is what this is.`;
+}
+
 export type DraftResult =
   | { ok: true; subject: string; body: string; evidenceUsed: string[] }
   | { ok: false; problems: string[] };
@@ -401,7 +508,11 @@ export async function draftEmail(input: {
   step: OutreachStep;
   angle?: string | null;
   sender?: string | null;
+  /** Set for a custom campaign; omitted means the CrawlProof audit pitch. */
+  pitch?: CampaignPitch | null;
 }): Promise<DraftResult> {
+  if (input.pitch) return draftCustomEmail({ ...input, pitch: input.pitch });
+
   const facts = factsOf(input.prospect);
   if (!facts.topIssues.length && facts.score === null) {
     return { ok: false, problems: ["no findings and no score on file — nothing truthful to say"] };
@@ -473,6 +584,88 @@ export async function draftEmail(input: {
   };
 }
 
+/**
+ * Draft for a campaign pitching something other than a scan.
+ *
+ * Structurally the same as the audit path — build a prompt, generate, then
+ * refuse to trust the result — but grounded in the campaign's declared facts.
+ * Nothing about the recipient's site is supplied, because nothing about it is
+ * known: a custom campaign doesn't scan anyone.
+ */
+async function draftCustomEmail(input: {
+  prospect: ProspectRow;
+  step: OutreachStep;
+  angle?: string | null;
+  sender?: string | null;
+  pitch: CampaignPitch;
+}): Promise<DraftResult> {
+  const facts = input.pitch.facts.map((f) => f.trim()).filter(Boolean);
+  if (!input.pitch.intro.trim()) {
+    return { ok: false, problems: ["the campaign has no pitch description — nothing to say"] };
+  }
+  if (!facts.length) {
+    return {
+      ok: false,
+      problems: [
+        "the campaign declares no facts, so there is nothing the draft would be allowed to state",
+      ],
+    };
+  }
+
+  const { anthropic, openai } = aiClients();
+  if (!anthropic && !openai) {
+    return { ok: false, problems: ["no AI provider configured (ANTHROPIC_API_KEY / OPENAI_API_KEY)"] };
+  }
+
+  const host = normalizeHost(input.prospect.site_url ?? input.prospect.target_key);
+  const userPrompt = [
+    `Recipient: someone at ${host}. You know nothing else about them — do not characterise their work, their site, or their needs as fact.`,
+    "",
+    "FACTS (the only things you may state):",
+    ...facts.map((f) => `- ${f}`),
+    "",
+    `SEQUENCE POSITION: ${stepGuidance(input.step)}`,
+    input.pitch.ask ? `The ask: ${input.pitch.ask}` : "",
+    input.angle ? `Emphasis requested: ${input.angle}` : "",
+    input.sender ? `Sign off as: ${input.sender}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  let output: { subject: string; body: string; evidence_used: string[] };
+  try {
+    const res = await generateStructuredOutput({
+      name: "custom_outreach_draft",
+      schema: DraftSchema,
+      system: customDraftSystem({ ...input.pitch, facts }),
+      user: userPrompt,
+      anthropic,
+      openai,
+      preference: env.backendAiProvider,
+      anthropicModel: "claude-haiku-4-5-20251001",
+      openaiModel: env.backendAiOpenaiModel,
+      maxTokens: 900,
+      anthropicEffort: false,
+    });
+    output = res.output;
+  } catch (err) {
+    return { ok: false, problems: [`generation failed: ${err instanceof Error ? err.message : "unknown"}`] };
+  }
+
+  const problems = unsupportedCustomClaims(output.body, facts);
+  if (problems.length) return { ok: false, problems };
+
+  const subject = output.subject?.trim();
+  if (!subject) return { ok: false, problems: ["the draft came back with no subject"] };
+
+  return {
+    ok: true,
+    subject,
+    body: output.body.trim(),
+    evidenceUsed: output.evidence_used ?? [],
+  };
+}
+
 // -------------------------------------------------------------------- sending
 
 export type SendOutcome =
diff --git a/lib/outreach/runner.ts b/lib/outreach/runner.ts
index 87809990..9317b1e8 100644
--- a/lib/outreach/runner.ts
+++ b/lib/outreach/runner.ts
@@ -20,6 +20,7 @@ import {
   latestAuditForHost,
   researchProspect,
   sendProspectEmail,
+  type CampaignPitch,
   type ProspectRow,
 } from "./pipeline";
 import { nextStepReadyAt, type OutreachStep } from "./cold";
@@ -42,13 +43,18 @@ export type CampaignRow = {
   auto_send: boolean;
   follow_ups: boolean;
   angle: string | null;
+  pitch_mode: "audit" | "custom";
+  pitch_intro: string | null;
+  pitch_ask: string | null;
+  pitch_facts: string[] | null;
+  scan_prospects: boolean;
   sender_name: string | null;
   reply_to: string | null;
   last_run_at: string | null;
 };
 
 export const CAMPAIGN_COLUMNS =
-  "id, project_id, owner_id, name, channel, active, queries, seed_urls, keywords, subreddits, negative_keywords, max_score, daily_send_limit, target_pipeline, auto_send, follow_ups, angle, sender_name, reply_to, last_run_at";
+  "id, project_id, owner_id, name, channel, active, queries, seed_urls, keywords, subreddits, negative_keywords, max_score, daily_send_limit, target_pipeline, auto_send, follow_ups, angle, sender_name, reply_to, last_run_at, pitch_mode, pitch_intro, pitch_ask, pitch_facts, scan_prospects";
 
 export type TickResult = {
   campaign: string;
@@ -58,6 +64,8 @@ export type TickResult = {
   drafted: number;
   sent: number;
   dryRuns: number;
+  /** The campaign's actual auto_send setting, so the summary can't misreport it. */
+  autoSend: boolean;
   skipped: string[];
   errors: string[];
 };
@@ -75,6 +83,7 @@ export async function runEmailCampaignTick(campaign: CampaignRow): Promise<TickR
     campaign: campaign.name,
     discovered: 0,
     scansStarted: 0,
+    autoSend: campaign.auto_send,
     researched: 0,
     drafted: 0,
     sent: 0,
@@ -122,12 +131,18 @@ export async function runEmailCampaignTick(campaign: CampaignRow): Promise<TickR
   // ---- 2. First contact for researched prospects that are weak enough.
   const ready = prospects
     .filter((p) => p.status === "researched" && p.contact_email && p.last_step === 0)
-    .filter((p) =>
-      isWeakEnough({
-        score: p.score,
-        engine: p.score_kind === "slop" ? "slop" : "rule",
-        maxScore: campaign.max_score,
-      }),
+    // The score gate exists so we never pitch a fix to a site that doesn't
+    // need one. A campaign that isn't pitching a fix has nothing to gate on,
+    // and applying it anyway would filter out every prospect, since an
+    // unscanned one has no score.
+    .filter(
+      (p) =>
+        !campaign.scan_prospects ||
+        isWeakEnough({
+          score: p.score,
+          engine: p.score_kind === "slop" ? "slop" : "rule",
+          maxScore: campaign.max_score,
+        }),
     )
     .slice(0, MAX_SEND_PER_TICK);
 
@@ -161,12 +176,15 @@ export async function runEmailCampaignTick(campaign: CampaignRow): Promise<TickR
   const pending = prospects.filter((p) => p.status === "new").slice(0, MAX_RESEARCH_PER_TICK);
   for (const p of pending) {
     const audit = await latestAuditForHost(campaign.owner_id, p.target_key);
-    if (!audit) continue; // still queued in the worker; next tick.
+    // With scanning off there will never be an audit, so waiting for one
+    // would strand every prospect at "new" forever.
+    if (!audit && campaign.scan_prospects) continue; // still queued in the worker; next tick.
     const res = await researchProspect({
       userId: campaign.owner_id,
       projectId: campaign.project_id,
       url: p.site_url ?? `https://${p.target_key}`,
       campaignId: campaign.id,
+      skipScan: !campaign.scan_prospects,
     });
     if (res.status === "researched") {
       result.researched += 1;
@@ -250,6 +268,24 @@ type Outcome =
   | { kind: "skipped"; host: string; reason: string }
   | { kind: "error"; host: string; reason: string };
 
+
+/**
+ * The campaign's own pitch, or null when it is selling a CrawlProof scan.
+ *
+ * Null is what keeps every existing campaign on exactly the old path: the
+ * audit pitch is the default and this feature is additive.
+ */
+function campaignPitch(campaign: CampaignRow): CampaignPitch | null {
+  if (campaign.pitch_mode !== "custom") return null;
+  const intro = (campaign.pitch_intro ?? "").trim();
+  if (!intro) return null;
+  return {
+    intro,
+    ask: campaign.pitch_ask,
+    facts: Array.isArray(campaign.pitch_facts) ? campaign.pitch_facts : [],
+  };
+}
+
 async function draftAndSend(
   campaign: CampaignRow,
   prospect: ProspectRow,
@@ -260,6 +296,7 @@ async function draftAndSend(
     step,
     angle: campaign.angle,
     sender: campaign.sender_name,
+    pitch: campaignPitch(campaign),
   });
   if (!draft.ok) {
     return { kind: "error", host: prospect.target_key, reason: draft.problems.join("; ") };
@@ -315,7 +352,14 @@ export function summarize(r: TickResult): string {
     `${r.discovered} discovered`,
     `${r.scansStarted} scans`,
     `${r.researched} researched`,
-    r.sent ? `${r.sent} SENT` : `${r.dryRuns} drafted (auto_send off)`,
+    r.sent
+      ? `${r.sent} SENT`
+      : r.autoSend
+        // Sending is on and nothing went out, so the funnel stalled earlier.
+        // Saying "auto_send off" here was simply false and sent people to
+        // check a switch that was already flipped.
+        ? `${r.dryRuns} drafted, 0 sent`
+        : `${r.dryRuns} drafted (auto_send off)`,
   ];
   if (r.skipped.length) parts.push(`${r.skipped.length} skipped`);
   if (r.errors.length) parts.push(`${r.errors.length} errors`);
diff --git a/supabase/migrations/20260728020000_outreach_campaign_pitch.sql b/supabase/migrations/20260728020000_outreach_campaign_pitch.sql
new file mode 100644
index 00000000..13e08573
--- /dev/null
+++ b/supabase/migrations/20260728020000_outreach_campaign_pitch.sql
@@ -0,0 +1,49 @@
+-- Let a campaign say what it is pitching.
+--
+-- Campaigns were project-scoped in who they contacted but not in what they
+-- said: the draft prompt hardcoded CrawlProof's site-audit offer, so a
+-- campaign built to reach game studios about a 3D modelling role still sent
+-- those studios an AEO audit pitch. The `angle` column only nudged emphasis
+-- inside that fixed pitch; it could not replace the premise.
+--
+-- pitch_mode 'audit' keeps exactly the old behaviour and stays the default,
+-- so existing campaigns are untouched.
+--
+-- pitch_facts is the honesty mechanism, not decoration. The audit pitch is
+-- grounded in scan findings — every claim traces to something we measured.
+-- A custom pitch has no scan to trace to, so the campaign declares the facts
+-- the draft is allowed to state, and the same grounding guard runs against
+-- those instead. Without it, a custom campaign would be a confident-
+-- false-statement generator pointed at strangers.
+
+alter table public.outreach_campaigns
+  add column if not exists pitch_mode text not null default 'audit'
+    check (pitch_mode in ('audit', 'custom')),
+  -- Who is writing and why, in their own words.
+  add column if not exists pitch_intro text,
+  -- The single ask. Cold email gets one.
+  add column if not exists pitch_ask text,
+  -- Claims the draft may make, one per entry. The grounding guard treats
+  -- anything outside this list as unsupported.
+  add column if not exists pitch_facts jsonb not null default '[]'::jsonb,
+  -- Scanning is the audit pitch's evidence-gathering step. A campaign that
+  -- isn't selling an audit has no reason to scan the people it contacts, and
+  -- scanning them anyway spends worker time and looks like surveillance.
+  add column if not exists scan_prospects boolean not null default true;
+
+comment on column public.outreach_campaigns.pitch_mode is
+  'audit = pitch a CrawlProof scan, grounded in findings. custom = pitch whatever pitch_intro describes, grounded in pitch_facts.';
+
+comment on column public.outreach_campaigns.pitch_facts is
+  'Claims a custom draft is permitted to state. The grounding guard rejects drafts that assert anything else.';
+
+comment on column public.outreach_campaigns.scan_prospects is
+  'Whether discovered prospects get a free scan queued. Required for the audit pitch; off by default for custom campaigns.';
+
+-- A custom pitch with nothing declared has nothing truthful to say, which is
+-- the same bar the audit pitch already holds itself to.
+alter table public.outreach_campaigns
+  drop constraint if exists outreach_campaigns_custom_pitch_needs_intro;
+alter table public.outreach_campaigns
+  add constraint outreach_campaigns_custom_pitch_needs_intro
+  check (pitch_mode <> 'custom' or (pitch_intro is not null and length(btrim(pitch_intro)) > 0));
diff --git a/tests/custom-pitch.test.ts b/tests/custom-pitch.test.ts
new file mode 100644
index 00000000..119d90c4
--- /dev/null
+++ b/tests/custom-pitch.test.ts
@@ -0,0 +1,98 @@
+import { describe, it, expect } from "vitest";
+import { unsupportedCustomClaims } from "@/lib/outreach/cold";
+import { customDraftSystem } from "@/lib/outreach/pipeline";
+
+// A job-application campaign: the case that exposed the bug, where the
+// engine sent a CrawlProof audit pitch to game studios instead.
+const FACTS = [
+  "I am a freelance 3D modeller with 9 years of experience",
+  "My portfolio is at https://nightcell7.com/work",
+  "I specialise in hard-surface military assets for games",
+];
+
+describe("unsupportedCustomClaims", () => {
+  it("accepts a draft that only states declared facts", () => {
+    const body =
+      "I'm a freelance 3D modeller specialising in hard-surface military assets, with 9 years of experience. Portfolio: https://nightcell7.com/work. Worth a look if you're hiring.";
+    expect(unsupportedCustomClaims(body, FACTS)).toEqual([]);
+  });
+
+  it("catches an invented number", () => {
+    const body = "I've shipped 47 titles and have 9 years of experience.";
+    const problems = unsupportedCustomClaims(body, FACTS);
+    expect(problems.join(" ")).toMatch(/47/);
+  });
+
+  it("does not flag a number that is in the facts", () => {
+    const problems = unsupportedCustomClaims("Nine years — 9 to be exact.", FACTS);
+    expect(problems.join(" ")).not.toMatch(/states "9"/);
+  });
+
+  it("catches a fabricated link", () => {
+    const problems = unsupportedCustomClaims(
+      "See my reel at https://vimeo.com/made-up-id for details.",
+      FACTS,
+    );
+    expect(problems.join(" ")).toMatch(/vimeo\.com/);
+  });
+
+  it("allows the declared portfolio link", () => {
+    const problems = unsupportedCustomClaims("Portfolio: https://nightcell7.com/work", FACTS);
+    expect(problems).toEqual([]);
+  });
+
+  it("catches invented familiarity", () => {
+    const problems = unsupportedCustomClaims("Great speaking with you last week!", FACTS);
+    expect(problems.join(" ")).toMatch(/prior relationship/);
+  });
+
+  it("ignores small numbers that are ordinary prose", () => {
+    expect(unsupportedCustomClaims("Just one question, and I'll keep it to 2 lines.", FACTS)).toEqual(
+      [],
+    );
+  });
+
+  it("does not report the same problem twice", () => {
+    const problems = unsupportedCustomClaims("47 titles. 47 titles. 47 titles.", FACTS);
+    expect(problems).toHaveLength(1);
+  });
+
+  it("flags everything numeric when no facts are declared", () => {
+    expect(unsupportedCustomClaims("I have 12 years of experience.", []).length).toBeGreaterThan(0);
+  });
+});
+
+describe("customDraftSystem", () => {
+  const system = customDraftSystem({
+    intro: "Anthony, a freelance 3D modeller looking for contract work",
+    ask: "consider me for 3D modelling contract work",
+    facts: FACTS,
+  });
+
+  it("drops the CrawlProof audit premise entirely", () => {
+    expect(system).not.toMatch(/CrawlProof/);
+    expect(system).not.toMatch(/answer engines/i);
+    expect(system.toLowerCase()).not.toMatch(/free report/);
+  });
+
+  it("carries the campaign's own description", () => {
+    expect(system).toMatch(/freelance 3D modeller looking for contract work/);
+  });
+
+  it("states the campaign's ask", () => {
+    expect(system).toMatch(/consider me for 3D modelling contract work/);
+  });
+
+  it("keeps the grounding and no-prior-relationship rules", () => {
+    expect(system).toMatch(/may not state it/);
+    expect(system).toMatch(/prior relationship/);
+  });
+
+  it("forbids asserting things about the recipient's business", () => {
+    expect(system).toMatch(/nothing about the recipient's business as fact/i);
+  });
+
+  it("still refuses a call as the first ask", () => {
+    expect(system).toMatch(/Never ask for a call in a first message/);
+  });
+});