@sendinel/mcp-server 1.0.0

package/build/tools/campaigns.js

@@ -0,0 +1,1335 @@
+import { z } from 'zod';
+import Anthropic from '@anthropic-ai/sdk';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { checkPlanLimit } from '../plan-limits.js';
+import { buildVoicePrompt, buildEmailSystemPrompt, validateTemplate } from '../lib/voice.js';
+import { fireWebhookEvent } from '../lib/webhook-events.js';
+import { getApprovalTier, requestApproval, checkApproval } from '../lib/action-approvals.js';
+import { getAnthropicModelId } from '../anthropic-model.js';
+import { getScheduleWindowBounds, groupScheduleByCampaign } from '../lib/schedule.js';
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+export function registerCampaignTools(server) {
+    server.registerTool('get_campaign_calendar', {
+        description: 'Get campaigns grouped by day for a calendar month.',
+        inputSchema: { year: z.number().int().min(2000).max(2100), month: z.number().int().min(1).max(12), site_id: z.string().uuid().optional() },
+    }, async ({ year, month, site_id }) => {
+        const start = new Date(Date.UTC(year, month - 1, 1));
+        const end = new Date(Date.UTC(year, month, 1));
+        let query = db().from('campaigns').select('id, name, type, status, site_id, send_at, trigger_event_name, trigger_tag, total_enrolled').eq('project_id', getProjectId()).in('status', ['active', 'draft']);
+        if (site_id)
+            query = query.eq('site_id', site_id);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        const days = {};
+        for (const campaign of data ?? []) {
+            if (campaign.type === 'triggered') {
+                const key = 'triggered';
+                days[key] = [...(days[key] ?? []), campaign];
+                continue;
+            }
+            if (!campaign.send_at)
+                continue;
+            const sendAt = new Date(campaign.send_at);
+            if (sendAt < start || sendAt >= end)
+                continue;
+            const key = sendAt.toISOString().slice(0, 10);
+            days[key] = [...(days[key] ?? []), campaign];
+        }
+        return j({ days });
+    });
+    server.registerTool('preview_campaign_audience', {
+        description: 'Preview active campaign audience and suppression warnings.',
+        inputSchema: { campaign_id: z.string().uuid() },
+    }, async ({ campaign_id }) => {
+        const projectId = getProjectId();
+        const { data: campaign } = await db().from('campaigns').select('id, name').eq('project_id', projectId).eq('id', campaign_id).maybeSingle();
+        if (!campaign)
+            return j({ error: 'Campaign not found', code: 'NOT_FOUND' });
+        const { data: enrollments } = await db().from('campaign_enrollments').select('contact_id').eq('campaign_id', campaign_id).eq('status', 'active');
+        const ids = (enrollments ?? []).map((row) => row.contact_id);
+        const { data: subscribers } = ids.length ? await db().from('subscribers').select('id, email').eq('project_id', projectId).in('id', ids) : { data: [] };
+        const emails = (subscribers ?? []).map((row) => row.email);
+        const { data: suppressions } = emails.length ? await db().from('suppressions').select('email').eq('project_id', projectId).in('email', emails) : { data: [] };
+        const suppressed = new Set((suppressions ?? []).map((row) => row.email));
+        const suppressedCount = (subscribers ?? []).filter((row) => suppressed.has(row.email)).length;
+        const total = ids.length;
+        return j({ total, suppressed_count: suppressedCount, will_receive: Math.max(total - suppressedCount, 0), warnings: suppressedCount ? [`${suppressedCount} contacts are suppressed and will be skipped`] : [], sample: (subscribers ?? []).filter((row) => !suppressed.has(row.email)).slice(0, 20) });
+    });
+    server.registerTool('list_campaigns', {
+        description: 'List campaigns, optionally filtered by site and/or status',
+        inputSchema: {
+            site_id: z.string().uuid().optional(),
+            status: z.enum(['draft', 'active', 'paused', 'completed', 'archived']).optional(),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ site_id, status, limit }) => {
+        let q = db()
+            .from('campaigns')
+            .select('id, site_id, name, type, status, total_enrolled, total_sent, total_opened, total_clicked, created_at')
+            .eq('project_id', getProjectId())
+            .order('created_at', { ascending: false })
+            .limit(limit ?? 25);
+        if (site_id)
+            q = q.eq('site_id', site_id);
+        if (status)
+            q = q.eq('status', status);
+        const { data, error } = await q;
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('get_schedule', {
+        description: 'Get scheduled campaign sends for a site within a time window, grouped by campaign.',
+        inputSchema: {
+            site_id: z.string().uuid(),
+            window: z.enum(['today', 'tomorrow', '7d', '30d']).optional().default('today'),
+        },
+    }, async ({ site_id, window }) => {
+        const { start, end } = getScheduleWindowBounds(window ?? 'today');
+        const { data, error } = await db()
+            .from('campaign_enrollments')
+            .select('id, next_send_at, status, campaigns!inner(id, name, type, site_id, project_id)')
+            .gte('next_send_at', start.toISOString())
+            .lt('next_send_at', end.toISOString())
+            .not('status', 'in', '(completed,unsubscribed,failed)')
+            .eq('campaigns.project_id', getProjectId())
+            .eq('campaigns.site_id', site_id)
+            .order('next_send_at', { ascending: true });
+        if (error)
+            return txt(`Error: ${error.message}`);
+        const campaigns = groupScheduleByCampaign((data ?? []));
+        const total_sends_scheduled = campaigns.reduce((sum, campaign) => sum + campaign.total_sends_scheduled, 0);
+        return j({
+            site_id,
+            window: window ?? 'today',
+            start: start.toISOString(),
+            end: end.toISOString(),
+            total_sends_scheduled,
+            campaigns,
+            empty_message: total_sends_scheduled === 0 ? 'No campaign sends scheduled in this window.' : null,
+        });
+    });
+    server.registerTool('create_campaign', {
+        description: 'Create a new email campaign',
+        inputSchema: {
+            site_id: z.string().uuid(),
+            name: z.string().min(1).max(200),
+            type: z.enum(['sequence', 'broadcast', 'triggered']),
+            description: z.string().optional(),
+            requires_approval: z.boolean().optional().default(true),
+        },
+    }, async ({ site_id, name, type, description, requires_approval }) => {
+        const limit = await checkPlanLimit('active_campaigns');
+        if (!limit.allowed) {
+            return { content: [{ type: 'text', text: `Active campaign limit reached (${limit.current}/${limit.limit}). Upgrade to Pro for unlimited campaigns.` }] };
+        }
+        const { data, error } = await db()
+            .from('campaigns')
+            .insert({ project_id: getProjectId(), site_id, name, type, description, requires_approval })
+            .select()
+            .single();
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('add_campaign_step', {
+        description: 'Add an email step to a campaign. For A/B testing, add multiple steps with the same step_order but different variant_label values.',
+        inputSchema: {
+            campaign_id: z.string().uuid(),
+            step_order: z.number().int().min(0).describe('Position in sequence (0 = first)'),
+            subject: z.string().min(1),
+            body_html: z.string().optional(),
+            body_text: z.string().optional(),
+            delay_days: z.number().int().min(0).optional().default(0),
+            delay_hours: z.number().int().min(0).max(23).optional().default(0),
+            variant_label: z.string().optional().default('A').describe('Variant label for A/B testing (default: A). Use B, C, etc. for additional variants.'),
+        },
+    }, async ({ campaign_id, step_order, subject, body_html, body_text, delay_days, delay_hours, variant_label }) => {
+        const { data, error } = await db()
+            .from('campaign_steps')
+            .insert({ campaign_id, step_order, subject, body_html, body_text, delay_days, delay_hours, variant_label: variant_label ?? 'A' })
+            .select()
+            .single();
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('update_campaign_status', {
+        description: 'Activate, pause, or archive a campaign. Activating requires human approval via the dashboard — call without approval_id to request one, then call again with the approved token.',
+        inputSchema: {
+            campaign_id: z.string().uuid(),
+            status: z.enum(['draft', 'active', 'paused', 'completed', 'archived']),
+            approval_id: z.string().uuid().optional().describe('Required when activating. Get this by calling once without it, then have a human approve.'),
+        },
+    }, async ({ campaign_id, status, approval_id }) => {
+        // Human approval required for activation
+        if (status === 'active') {
+            if (!approval_id) {
+                const approval = await requestApproval('update_campaign_status', { campaign_id, status });
+                return j(approval);
+            }
+            const check = await checkApproval(approval_id, { consume: true });
+            if (!check.approved) {
+                return txt(`Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`);
+            }
+        }
+        const { data, error } = await db()
+            .from('campaigns')
+            .update({ status, updated_at: new Date().toISOString() })
+            .eq('id', campaign_id)
+            .select()
+            .single();
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        // Fire webhook for status changes
+        const eventMap = { active: 'campaign.activated', completed: 'campaign.completed', paused: 'campaign.paused' };
+        if (eventMap[status]) {
+            fireWebhookEvent(eventMap[status], {
+                campaign_id: data.id,
+                campaign_name: data.name,
+                status,
+            }).catch(() => { });
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('enroll_contact', {
+        description: 'Enroll a single contact in a campaign',
+        inputSchema: {
+            campaign_id: z.string().uuid(),
+            contact_id: z.string().uuid(),
+            next_send_at: z.string().optional().describe('ISO datetime for first send. Defaults to now.'),
+        },
+    }, async ({ campaign_id, contact_id, next_send_at }) => {
+        const { data, error } = await db()
+            .from('campaign_enrollments')
+            .insert({ campaign_id, contact_id, next_send_at: next_send_at ?? new Date().toISOString() })
+            .select()
+            .single();
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        // Update campaign enrolled counter
+        const { data: campaign } = await db().from('campaigns').select('total_enrolled').eq('id', campaign_id).maybeSingle();
+        if (campaign) {
+            await db().from('campaigns').update({ total_enrolled: (campaign.total_enrolled ?? 0) + 1 }).eq('id', campaign_id);
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('get_enrollment_status', {
+        description: "Get one contact's enrollment status and sequence position for a campaign",
+        inputSchema: {
+            campaign_id: z.string().uuid(),
+            contact_id: z.string().uuid(),
+        },
+    }, async ({ campaign_id, contact_id }) => {
+        const projectId = getProjectId();
+        const [campaignRes, contactRes] = await Promise.all([
+            db()
+                .from('campaigns')
+                .select('id, name, type, status')
+                .eq('id', campaign_id)
+                .eq('project_id', projectId)
+                .maybeSingle(),
+            db()
+                .from('subscribers')
+                .select('id, email, first_name, last_name')
+                .eq('id', contact_id)
+                .eq('project_id', projectId)
+                .maybeSingle(),
+        ]);
+        if (campaignRes.error)
+            return txt(`Error: ${campaignRes.error.message}`);
+        if (contactRes.error)
+            return txt(`Error: ${contactRes.error.message}`);
+        if (!campaignRes.data || !contactRes.data)
+            return j({ error: 'Campaign or contact not found', code: 'NOT_FOUND' });
+        const { data: enrollment, error } = await db()
+            .from('campaign_enrollments')
+            .select('id, status, current_step, current_step_id, enrolled_at, completed_at, next_send_at, exit_reason')
+            .eq('campaign_id', campaign_id)
+            .eq('contact_id', contact_id)
+            .maybeSingle();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        if (!enrollment) {
+            return j({ enrolled: false, enrollment: null, campaign: campaignRes.data, contact: contactRes.data });
+        }
+        const { count: stepsSent } = await db()
+            .from('email_log')
+            .select('id', { count: 'exact', head: true })
+            .eq('project_id', projectId)
+            .eq('campaign_id', campaign_id)
+            .eq('contact_id', contact_id)
+            .not('status', 'eq', 'failed');
+        return j({
+            enrolled: true,
+            campaign: campaignRes.data,
+            contact: contactRes.data,
+            enrollment: {
+                ...enrollment,
+                current_step_order: enrollment.current_step ?? 0,
+                steps_sent: stepsSent ?? 0,
+            },
+        });
+    });
+    server.registerTool('enroll_segment', {
+        description: 'Enroll all active subscribers from a site into a campaign. Skips globally unsubscribed and suppressed contacts.',
+        inputSchema: {
+            campaign_id: z.string().uuid(),
+            site_id: z.string().uuid(),
+            next_send_at: z.string().optional().describe('ISO datetime for first send. Defaults to now.'),
+        },
+    }, async ({ campaign_id, site_id, next_send_at }) => {
+        const sendAt = next_send_at ?? new Date().toISOString();
+        const { data: subs, error: subErr } = await db()
+            .from('site_subscriptions')
+            .select('contact_id')
+            .eq('site_id', site_id)
+            .eq('subscribed', true);
+        if (subErr)
+            return { content: [{ type: 'text', text: `Error: ${subErr.message}` }] };
+        if (!subs?.length)
+            return { content: [{ type: 'text', text: 'No active subscribers for this site.' }] };
+        const ids = subs.map((s) => s.contact_id);
+        const { data: contacts } = await db()
+            .from('subscribers')
+            .select('id, email')
+            .in('id', ids)
+            .eq('global_unsubscribed', false);
+        const { data: suppressed } = await db().from('suppressions').select('email').eq('project_id', getProjectId());
+        const suppressedSet = new Set((suppressed ?? []).map((s) => s.email));
+        const eligible = (contacts ?? []).filter((c) => !suppressedSet.has(c.email));
+        if (!eligible.length)
+            return { content: [{ type: 'text', text: 'All contacts are suppressed or unsubscribed.' }] };
+        const rows = eligible.map((c) => ({ campaign_id, contact_id: c.id, next_send_at: sendAt }));
+        const { error: enrollErr } = await db()
+            .from('campaign_enrollments')
+            .upsert(rows, { onConflict: 'campaign_id,contact_id', ignoreDuplicates: true });
+        if (enrollErr)
+            return { content: [{ type: 'text', text: `Error: ${enrollErr.message}` }] };
+        // Update campaign enrolled counter
+        const { data: campaign } = await db().from('campaigns').select('total_enrolled').eq('id', campaign_id).maybeSingle();
+        if (campaign) {
+            await db().from('campaigns').update({ total_enrolled: (campaign.total_enrolled ?? 0) + eligible.length }).eq('id', campaign_id);
+        }
+        return { content: [{ type: 'text', text: JSON.stringify({ enrolled: eligible.length, campaign_id, site_id }, null, 2) }] };
+    });
+    server.registerTool('clone_campaign', {
+        description: 'Clone an existing campaign (with all steps) into a new draft campaign',
+        inputSchema: {
+            campaign_id: z.string().uuid().describe('Source campaign to clone'),
+            new_name: z.string().min(1).describe('Name for the cloned campaign'),
+            site_id: z.string().uuid().optional().describe('Override site_id, defaults to original'),
+        },
+    }, async ({ campaign_id, new_name, site_id }) => {
+        const projectId = getProjectId();
+        const { data: original, error: fetchErr } = await db()
+            .from('campaigns')
+            .select('*, campaign_steps(*)')
+            .eq('id', campaign_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (fetchErr || !original)
+            return txt(`Error: Campaign not found — ${fetchErr?.message ?? 'not found'}`);
+        const limit = await checkPlanLimit('active_campaigns');
+        if (!limit.allowed)
+            return txt(`Active campaign limit reached (${limit.current}/${limit.limit}).`);
+        const { data: newCampaign, error: createErr } = await db()
+            .from('campaigns')
+            .insert({
+            project_id: projectId,
+            site_id: site_id ?? original.site_id,
+            name: new_name,
+            type: original.type,
+            description: original.description,
+            requires_approval: original.requires_approval,
+            status: 'draft',
+        })
+            .select()
+            .single();
+        if (createErr)
+            return txt(`Error creating campaign: ${createErr.message}`);
+        const steps = (original.campaign_steps ?? []).sort((a, b) => a.step_order - b.step_order);
+        if (steps.length > 0) {
+            const stepRows = steps.map((s) => ({
+                campaign_id: newCampaign.id,
+                step_order: s.step_order,
+                subject: s.subject,
+                body_html: s.body_html,
+                body_text: s.body_text,
+                delay_days: s.delay_days,
+                delay_hours: s.delay_hours,
+            }));
+            const { error: stepErr } = await db().from('campaign_steps').insert(stepRows);
+            if (stepErr)
+                return txt(`Campaign created but steps failed: ${stepErr.message}`);
+        }
+        return j({ ...newCampaign, steps_copied: steps.length, cloned_from: campaign_id });
+    });
+    server.registerTool('generate_email', {
+        description: 'Generate email content (subject, HTML, plain text) from a brief using AI. Optionally provide contact_id to adapt tone based on recipient engagement data.',
+        inputSchema: {
+            site_id: z.string().uuid(),
+            brief: z.string().min(1).describe('Description of the email to generate'),
+            format: z.enum(['both', 'html', 'text']).optional().describe('Output format, default both'),
+            contact_id: z.string().uuid().optional().describe('Optional contact UUID — when provided, AI adapts tone based on their engagement level and history'),
+        },
+    }, async ({ site_id, brief, format = 'both', contact_id }) => {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey)
+            return txt('Error: ANTHROPIC_API_KEY not configured');
+        const projectId = getProjectId();
+        // Fetch site and optionally contact data in parallel
+        const contactPromise = contact_id
+            ? db()
+                .from('subscribers')
+                .select('engagement_score, lifecycle_stage, tags, total_opens, total_clicks, last_opened_at')
+                .eq('id', contact_id)
+                .eq('project_id', projectId)
+                .maybeSingle()
+            : Promise.resolve({ data: null, error: null });
+        const [{ data: site }, { data: contact }, { data: project }] = await Promise.all([
+            db()
+                .from('sites')
+                .select('name, sending_domain, from_email, from_name, brand_voice')
+                .eq('id', site_id)
+                .eq('project_id', projectId)
+                .maybeSingle(),
+            contactPromise,
+            db()
+                .from('projects')
+                .select('brand_settings')
+                .eq('id', projectId)
+                .maybeSingle(),
+        ]);
+        const brandContext = site
+            ? `Brand: ${site.name}, Domain: ${site.sending_domain}, From: ${site.from_name} <${site.from_email}>`
+            : 'No brand info available';
+        const voicePrompt = buildVoicePrompt(site?.brand_voice, project?.brand_settings ?? null);
+        let systemPrompt = buildEmailSystemPrompt(brandContext, voicePrompt);
+        // Inject per-contact context when available
+        if (contact) {
+            const lastActivity = contact.last_opened_at
+                ? new Date(contact.last_opened_at).toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' })
+                : 'never';
+            systemPrompt += `\n\nRecipient context:
+- Lifecycle stage: ${contact.lifecycle_stage ?? 'unknown'}
+- Engagement score: ${contact.engagement_score ?? 0}/100
+- Tags: ${(contact.tags ?? []).join(', ') || 'none'}
+- Total opens: ${contact.total_opens ?? 0}, Total clicks: ${contact.total_clicks ?? 0}
+- Last activity: ${lastActivity}
+
+Adapt your tone accordingly:
+- For "new" contacts: welcoming, introductory, low-commitment CTA
+- For "active" contacts: value-adding, feature highlights, deeper engagement
+- For "cooling" contacts: re-engage with curiosity, remind of value, easy win CTA
+- For "cold" contacts: acknowledge absence, offer compelling reason to return, urgency
+- For "churned" contacts: last-chance, emotional appeal, exclusive offer`;
+        }
+        const anthropic = new Anthropic({ apiKey });
+        const genResponse = await anthropic.messages.create({
+            model: getAnthropicModelId(),
+            max_tokens: 2048,
+            system: systemPrompt,
+            messages: [{ role: 'user', content: brief }],
+        });
+        const textBlock = genResponse.content.find((b) => b.type === 'text');
+        const raw = textBlock && 'text' in textBlock ? textBlock.text : '{}';
+        try {
+            const result = JSON.parse(raw.replace(/```json?\n?|```/g, '').trim());
+            if (format === 'html')
+                delete result.body_text;
+            if (format === 'text')
+                delete result.body_html;
+            return j(result);
+        }
+        catch {
+            return txt(`Error: Failed to parse generated email. AI returned: ${raw.slice(0, 200)}`);
+        }
+    });
+    server.registerTool('launch_campaign', {
+        description: 'Full campaign lifecycle in one call: create segment (from NL or existing), create campaign, generate emails from briefs, enroll contacts, activate. Requires confirmation.',
+        inputSchema: {
+            name: z.string().min(1).describe('Campaign name'),
+            site_id: z.string().uuid(),
+            type: z.enum(['sequence', 'broadcast', 'triggered']).optional().default('sequence'),
+            segment_description: z.string().optional().describe('Natural language audience description'),
+            segment_id: z.string().uuid().optional().describe('Existing segment ID (alternative to segment_description)'),
+            emails: z.array(z.object({
+                brief: z.string().describe('What this email should say'),
+                delay_days: z.number().int().min(0).optional().default(0),
+                delay_hours: z.number().int().min(0).optional().default(0),
+            })).min(1),
+            confirmed: z.boolean().optional().describe('Set true after previewing to execute'),
+        },
+    }, async ({ name, site_id, type, segment_description, segment_id, emails, confirmed }) => {
+        if (!segment_description && !segment_id)
+            return txt('Provide segment_description or segment_id.');
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey)
+            return txt('Error: ANTHROPIC_API_KEY not configured');
+        const anthropic = new Anthropic({ apiKey });
+        const projectId = getProjectId();
+        function applyPaymentRules(query, payment) {
+            if (!payment)
+                return query;
+            let q = query;
+            if (payment.plan)
+                q = q.contains('custom_properties', { payment: { plan: payment.plan } });
+            if (payment.mrr_cents !== undefined)
+                q = q.contains('custom_properties', { payment: { mrr_cents: payment.mrr_cents } });
+            if (payment.ltv_cents !== undefined)
+                q = q.contains('custom_properties', { payment: { ltv_cents: payment.ltv_cents } });
+            if (payment.subscription_status)
+                q = q.contains('custom_properties', { payment: { subscription_status: payment.subscription_status } });
+            q = applyPaymentDateRule(q, 'trial_ends_at', payment.trial_ends_at);
+            q = applyPaymentDateRule(q, 'churned_at', payment.churned_at);
+            q = applyPaymentDateRule(q, 'paid_at', payment.paid_at);
+            return q;
+        }
+        function applyPaymentDateRule(query, field, rule) {
+            if (!rule)
+                return query;
+            if (typeof rule === 'string') {
+                return query.contains('custom_properties', { payment: { [field]: rule } });
+            }
+            let q = query;
+            const column = `custom_properties->payment->>${field}`;
+            if (typeof rule.within_days === 'number') {
+                const start = new Date();
+                const end = new Date(start.getTime() + rule.within_days * 24 * 60 * 60 * 1000);
+                q = q.gte(column, start.toISOString()).lte(column, end.toISOString());
+            }
+            if (rule.after)
+                q = q.gte(column, rule.after);
+            if (rule.before)
+                q = q.lte(column, rule.before);
+            return q;
+        }
+        // Helper to get segment contact IDs (simplified inline)
+        const getContactIds = async (rules) => {
+            let q = db().from('subscribers').select('id, email').eq('project_id', projectId).eq('global_unsubscribed', false);
+            if (rules.lifecycle_stage)
+                q = q.eq('lifecycle_stage', rules.lifecycle_stage);
+            q = applyPaymentRules(q, rules.payment);
+            if (rules.min_score !== undefined)
+                q = q.gte('engagement_score', rules.min_score);
+            if (rules.max_score !== undefined)
+                q = q.lte('engagement_score', rules.max_score);
+            if (rules.source)
+                q = q.eq('source', rules.source);
+            if (rules.subscribed_after)
+                q = q.gte('created_at', `${rules.subscribed_after}T00:00:00Z`);
+            if (rules.subscribed_before)
+                q = q.lte('created_at', `${rules.subscribed_before}T23:59:59Z`);
+            if (rules.has_opened === true)
+                q = q.not('last_opened_at', 'is', null);
+            if (rules.has_opened === false)
+                q = q.is('last_opened_at', null);
+            if (rules.has_clicked === true)
+                q = q.not('last_clicked_at', 'is', null);
+            if (rules.has_clicked === false)
+                q = q.is('last_clicked_at', null);
+            if (rules.tag)
+                q = q.contains('tags', [rules.tag]);
+            if (rules.site_id) {
+                const { data: subs } = await db().from('site_subscriptions').select('contact_id').eq('site_id', rules.site_id).eq('subscribed', true);
+                const siteIds = (subs ?? []).map((s) => s.contact_id);
+                if (!siteIds.length)
+                    return [];
+                q = q.in('id', siteIds);
+            }
+            const { data, error } = await q;
+            if (error || !data)
+                return [];
+            let ids = data.map((c) => c.id);
+            const { data: suppressed } = await db().from('suppressions').select('email').eq('project_id', projectId);
+            if (suppressed?.length) {
+                const suppressedEmails = new Set(suppressed.map((s) => s.email));
+                ids = data.filter((c) => !suppressedEmails.has(c.email)).map((c) => c.id);
+            }
+            return ids;
+        };
+        let segId = segment_id;
+        let segmentName;
+        let contactCount = 0;
+        let parsedRules;
+        if (segment_description) {
+            const parseResp = await anthropic.messages.create({
+                model: getAnthropicModelId(),
+                max_tokens: 512,
+                system: 'You translate natural language audience descriptions into a JSON filter rules object. Return ONLY valid JSON. Available keys: lifecycle_stage (lead|trial|customer|churned|win-back), payment (object with plan, mrr_cents, ltv_cents, subscription_status, trial_ends_at, churned_at, paid_at), min_score, max_score, source, subscribed_after, subscribed_before, has_opened, has_clicked, tag, custom_property, exclude_suppressed. Example: {"payment":{"plan":"pro","trial_ends_at":{"within_days":7}},"lifecycle_stage":"trial"}. Today is ' + new Date().toISOString().slice(0, 10) + '.',
+                messages: [{ role: 'user', content: segment_description }],
+            });
+            const tb = parseResp.content.find((b) => b.type === 'text');
+            const rawRules = tb && 'text' in tb ? tb.text : '{}';
+            try {
+                parsedRules = JSON.parse(rawRules.replace(/```json?\n?|```/g, '').trim());
+            }
+            catch {
+                return txt(`Error: Failed to parse segment from "${segment_description}"`);
+            }
+            const ids = await getContactIds(parsedRules);
+            contactCount = ids.length;
+            segmentName = `${name} — segment`;
+        }
+        else {
+            const { data: seg, error: segErr } = await db()
+                .from('segments')
+                .select('id, name, rules')
+                .eq('id', segment_id)
+                .eq('project_id', projectId)
+                .maybeSingle();
+            if (segErr || !seg)
+                return txt('Error: segment not found');
+            segmentName = seg.name;
+            parsedRules = seg.rules;
+            const ids = await getContactIds(parsedRules);
+            contactCount = ids.length;
+        }
+        if (!confirmed) {
+            const subjectPreviews = [];
+            for (const email of emails) {
+                const subResp = await anthropic.messages.create({
+                    model: getAnthropicModelId(),
+                    max_tokens: 100,
+                    system: 'Generate a single email subject line for: ' + email.brief + '. Return ONLY the subject line text.',
+                    messages: [{ role: 'user', content: email.brief }],
+                });
+                const stb = subResp.content.find((b) => b.type === 'text');
+                subjectPreviews.push(stb && 'text' in stb ? stb.text.trim() : email.brief);
+            }
+            return j({
+                confirmation_required: true,
+                campaign_name: name,
+                segment: segment_description
+                    ? { description: segment_description, parsed_rules: parsedRules, matching_contacts: contactCount }
+                    : { id: segId, name: segmentName, matching_contacts: contactCount },
+                emails: emails.map((e, i) => ({
+                    step: i, brief: e.brief, subject_preview: subjectPreviews[i], delay_days: e.delay_days ?? 0, delay_hours: e.delay_hours ?? 0,
+                })),
+                message: `Campaign "${name}" will target ${contactCount} contacts with ${emails.length} email(s). Call again with confirmed: true to create everything.`,
+            });
+        }
+        if (contactCount === 0)
+            return txt('No contacts match the segment. Adjust targeting criteria.');
+        // Create segment if from NL description
+        if (segment_description) {
+            const { data: seg, error: segErr } = await db()
+                .from('segments')
+                .insert({ project_id: projectId, name: segmentName, description: segment_description, rules: parsedRules })
+                .select('id')
+                .single();
+            if (segErr)
+                return txt(`Error creating segment: ${segErr.message}`);
+            segId = seg.id;
+        }
+        const campLimit = await checkPlanLimit('active_campaigns');
+        if (!campLimit.allowed)
+            return txt(`Active campaign limit reached (${campLimit.current}/${campLimit.limit}).`);
+        const { data: campaign, error: campErr } = await db()
+            .from('campaigns')
+            .insert({ project_id: projectId, site_id, name, type: type ?? 'sequence', segment_id: segId, requires_approval: false })
+            .select('id')
+            .single();
+        if (campErr)
+            return txt(`Error creating campaign: ${campErr.message}`);
+        const { data: site } = await db()
+            .from('sites')
+            .select('name, sending_domain, from_name, from_email, brand_voice')
+            .eq('id', site_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        const brandCtx = site ? `Brand: ${site.name}, Domain: ${site.sending_domain}, From: ${site.from_name}` : '';
+        const voicePrompt = buildVoicePrompt(site?.brand_voice);
+        const systemPrompt = buildEmailSystemPrompt(brandCtx, voicePrompt);
+        const steps = [];
+        for (let i = 0; i < emails.length; i++) {
+            const email = emails[i];
+            const genResp = await anthropic.messages.create({
+                model: getAnthropicModelId(),
+                max_tokens: 2048,
+                system: systemPrompt,
+                messages: [{ role: 'user', content: email.brief }],
+            });
+            const gtb = genResp.content.find((b) => b.type === 'text');
+            const rawEmail = gtb && 'text' in gtb ? gtb.text : '{}';
+            let emailContent;
+            try {
+                emailContent = JSON.parse(rawEmail.replace(/```json?\n?|```/g, '').trim());
+            }
+            catch {
+                emailContent = { subject: `Step ${i + 1}`, body_html: '<p>' + email.brief + '</p>', body_text: email.brief };
+            }
+            const { data: step, error: stepErr } = await db()
+                .from('campaign_steps')
+                .insert({
+                campaign_id: campaign.id, step_order: i,
+                subject: emailContent.subject, body_html: emailContent.body_html, body_text: emailContent.body_text,
+                delay_days: email.delay_days ?? 0, delay_hours: email.delay_hours ?? 0,
+            })
+                .select('id, step_order, subject')
+                .single();
+            if (stepErr)
+                return txt(`Error adding step ${i}: ${stepErr.message}`);
+            steps.push(step);
+        }
+        // Enroll contacts
+        const enrollIds = await getContactIds(parsedRules);
+        const enrollRows = enrollIds.map((id) => ({ campaign_id: campaign.id, contact_id: id, next_send_at: new Date().toISOString() }));
+        if (enrollRows.length) {
+            await db().from('campaign_enrollments').upsert(enrollRows, { onConflict: 'campaign_id,contact_id', ignoreDuplicates: true });
+        }
+        // Activate + update enrolled count
+        await db().from('campaigns').update({ status: 'active', total_enrolled: enrollIds.length, updated_at: new Date().toISOString() }).eq('id', campaign.id);
+        return j({
+            campaign_id: campaign.id, campaign_name: name, status: 'active',
+            segment: { id: segId, name: segmentName, contacts: contactCount },
+            enrolled: enrollIds.length,
+            steps: steps.map(s => ({ step: s.step_order, subject: s.subject })),
+            message: `Campaign "${name}" is live! ${enrollIds.length} contacts enrolled across ${steps.length} email(s).`,
+        });
+    });
+    server.registerTool('preview_email', {
+        description: 'Preview email content with merge variables resolved using sample contact data. Provide content via step_id, draft_id, or raw body_html/subject.',
+        inputSchema: {
+            step_id: z.string().uuid().optional().describe('Campaign step UUID'),
+            draft_id: z.string().uuid().optional().describe('AI draft UUID'),
+            subject: z.string().optional().describe('Raw subject'),
+            body_html: z.string().optional().describe('Raw HTML'),
+        },
+    }, async ({ step_id, draft_id, subject, body_html }) => {
+        const projectId = getProjectId();
+        let subj = subject ?? '';
+        let html = body_html ?? '';
+        let text = '';
+        if (!subj && !html) {
+            if (step_id) {
+                const { data: step, error } = await db()
+                    .from('campaign_steps')
+                    .select('subject, body_html, body_text')
+                    .eq('id', step_id)
+                    .maybeSingle();
+                if (error || !step)
+                    return txt('Error: Step not found');
+                subj = step.subject;
+                html = step.body_html ?? '';
+                text = step.body_text ?? '';
+            }
+            else if (draft_id) {
+                const { data: draft, error } = await db()
+                    .from('ai_drafts')
+                    .select('subject, body_html, body_text')
+                    .eq('id', draft_id)
+                    .eq('project_id', projectId)
+                    .maybeSingle();
+                if (error || !draft)
+                    return txt('Error: Draft not found');
+                subj = draft.subject;
+                html = draft.body_html ?? '';
+                text = draft.body_text ?? '';
+            }
+            else {
+                return txt('Provide step_id, draft_id, or raw subject/body_html.');
+            }
+        }
+        const { data: sample } = await db()
+            .from('subscribers')
+            .select('id, email, first_name, last_name')
+            .eq('project_id', projectId)
+            .eq('global_unsubscribed', false)
+            .order('created_at', { ascending: true })
+            .limit(1)
+            .maybeSingle();
+        const contact = sample ?? { email: 'preview@example.com', first_name: 'Jane' };
+        const resolve = (t) => t
+            .replace(/\{\{first_name\}\}/g, contact.first_name || 'there')
+            .replace(/\{\{email\}\}/g, contact.email)
+            .replace(/\{\{unsubscribe_url\}\}/g, '#unsubscribe-preview');
+        return j({ subject: resolve(subj), body_html: resolve(html), body_text: resolve(text), sample_contact: contact });
+    });
+    server.registerTool('send_test_email', {
+        description: 'Send a test email to a specified address via Resend. Content from step_id, draft_id, or raw subject/body_html. Logged as test, not counted in campaign metrics.',
+        inputSchema: {
+            to_email: z.string().email().describe('Email address to send the test to'),
+            site_id: z.string().uuid().describe('Site UUID (determines from address)'),
+            step_id: z.string().uuid().optional(),
+            draft_id: z.string().uuid().optional(),
+            subject: z.string().optional(),
+            body_html: z.string().optional(),
+            body_text: z.string().optional(),
+        },
+    }, async ({ to_email, site_id, step_id, draft_id, subject, body_html, body_text }) => {
+        const projectId = getProjectId();
+        let subj = subject ?? '';
+        let html = body_html ?? '';
+        let text = body_text ?? '';
+        if (!subj && !html) {
+            if (step_id) {
+                const { data: step } = await db().from('campaign_steps').select('subject, body_html, body_text').eq('id', step_id).maybeSingle();
+                if (!step)
+                    return txt('Error: Step not found');
+                subj = step.subject;
+                html = step.body_html ?? '';
+                text = step.body_text ?? '';
+            }
+            else if (draft_id) {
+                const { data: draft } = await db().from('ai_drafts').select('subject, body_html, body_text').eq('id', draft_id).eq('project_id', projectId).maybeSingle();
+                if (!draft)
+                    return txt('Error: Draft not found');
+                subj = draft.subject;
+                html = draft.body_html ?? '';
+                text = draft.body_text ?? '';
+            }
+            else {
+                return txt('Provide content via subject/body_html, step_id, or draft_id.');
+            }
+        }
+        const resolve = (t) => t
+            .replace(/\{\{first_name\}\}/g, 'Test')
+            .replace(/\{\{email\}\}/g, to_email)
+            .replace(/\{\{unsubscribe_url\}\}/g, '#test-unsubscribe');
+        // Suppression check — don't send test emails to bounced/complained addresses
+        const { data: suppressed } = await db()
+            .from('suppressions')
+            .select('reason')
+            .eq('project_id', projectId)
+            .eq('email', to_email.toLowerCase())
+            .maybeSingle();
+        if (suppressed)
+            return txt(`Error: Recipient suppressed (${suppressed.reason}). Test emails to suppressed addresses risk domain reputation.`);
+        const { data: site } = await db()
+            .from('sites')
+            .select('from_email, from_name')
+            .eq('id', site_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (!site)
+            return txt('Error: Site not found');
+        // Use Resend via env var (MCP server context)
+        const { Resend } = await import('resend');
+        const resendKey = process.env.RESEND_API_KEY;
+        if (!resendKey)
+            return txt('Error: RESEND_API_KEY not configured');
+        const resend = new Resend(resendKey);
+        const payload = {
+            from: `${site.from_name} <${site.from_email}>`,
+            to: to_email,
+            subject: `[TEST] ${resolve(subj)}`,
+        };
+        const resolvedHtml = resolve(html);
+        const resolvedText = resolve(text);
+        if (resolvedHtml)
+            payload.html = resolvedHtml;
+        if (resolvedText)
+            payload.text = resolvedText;
+        const { data: resendData, error: sendError } = await resend.emails.send(payload);
+        if (sendError)
+            return txt(`Error: Send failed — ${sendError.message}`);
+        await db().from('email_log').insert({
+            project_id: projectId,
+            site_id,
+            contact_id: null,
+            to_email,
+            from_email: site.from_email,
+            subject: resolve(subj),
+            status: 'sent',
+            category: 'test',
+            sent_at: new Date().toISOString(),
+            provider_message_id: resendData?.id ?? null,
+            body_html: resolvedHtml ?? null,
+        });
+        return j({ sent: true, to: to_email, resend_id: resendData?.id });
+    });
+    server.registerTool('send_transactional', {
+        description: 'Send a transactional email (password reset, receipt, notification). Checks suppressions and plan limits. Logged with category transactional.',
+        inputSchema: {
+            to: z.string().email().describe('Recipient email address'),
+            site_id: z.string().uuid().describe('Site UUID (determines from address and Resend key)'),
+            subject: z.string().describe('Email subject line'),
+            html: z.string().optional().describe('HTML body'),
+            text: z.string().optional().describe('Plain text body'),
+            reply_to: z.string().email().optional().describe('Reply-to address'),
+            idempotency_key: z.string().optional().describe('Unique key to prevent duplicate sends'),
+        },
+    }, async ({ to, site_id, subject, html, text, reply_to, idempotency_key }) => {
+        const projectId = getProjectId();
+        if (!html && !text)
+            return txt('At least one of html or text is required');
+        // Suppression check
+        const { data: suppression } = await db()
+            .from('suppressions')
+            .select('id, reason')
+            .eq('project_id', projectId)
+            .eq('email', to.toLowerCase())
+            .limit(1)
+            .maybeSingle();
+        if (suppression)
+            return txt(`Error: Recipient suppressed — ${suppression.reason}`);
+        // Idempotency check
+        if (idempotency_key) {
+            const { data: existing } = await db()
+                .from('email_log')
+                .select('id, provider_message_id, status')
+                .eq('project_id', projectId)
+                .eq('idempotency_key', idempotency_key)
+                .maybeSingle();
+            if (existing)
+                return j({ error: 'Duplicate send', id: existing.id, resend_id: existing.provider_message_id });
+        }
+        // Site verification
+        const { data: site } = await db()
+            .from('sites')
+            .select('from_email, from_name')
+            .eq('id', site_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (!site)
+            return txt('Error: Site not found');
+        // Send via Resend
+        const { Resend } = await import('resend');
+        const resendKey = process.env.RESEND_API_KEY;
+        if (!resendKey)
+            return txt('Error: RESEND_API_KEY not configured');
+        const resend = new Resend(resendKey);
+        const payload = {
+            from: `${site.from_name} <${site.from_email}>`,
+            to,
+            subject,
+        };
+        if (html)
+            payload.html = html;
+        if (text)
+            payload.text = text;
+        if (reply_to)
+            payload.reply_to = reply_to;
+        const { data: resendData, error: sendError } = await resend.emails.send(payload);
+        if (sendError)
+            return txt(`Error: Send failed — ${sendError.message}`);
+        // Log to email_log
+        const { data: logRow } = await db().from('email_log').insert({
+            project_id: projectId,
+            site_id,
+            contact_id: null,
+            to_email: to,
+            from_email: site.from_email,
+            subject,
+            status: 'sent',
+            category: 'transactional',
+            sent_at: new Date().toISOString(),
+            provider_message_id: resendData?.id ?? null,
+            idempotency_key: idempotency_key ?? null,
+            body_html: html ?? null,
+        }).select('id').single();
+        return j({ sent: true, id: logRow?.id, to, resend_id: resendData?.id });
+    });
+    server.registerTool('validate_template', {
+        description: 'Validate an email template for variable errors and brand voice compliance. Checks for unknown {{variables}}, stock phrases, excessive CTAs, missing sign-off, and more.',
+        inputSchema: {
+            html: z.string().describe('HTML email content to validate'),
+            site_id: z.string().uuid().optional().describe('Site UUID — uses the site brand voice config for sign-off check'),
+        },
+    }, async ({ html, site_id }) => {
+        let voiceConfig = null;
+        if (site_id) {
+            const { data: site } = await db()
+                .from('sites')
+                .select('brand_voice')
+                .eq('id', site_id)
+                .eq('project_id', getProjectId())
+                .maybeSingle();
+            voiceConfig = site?.brand_voice ?? null;
+        }
+        const result = validateTemplate(html, voiceConfig);
+        return j(result);
+    });
+    // ── Orchestrator fast path ──────────────────────────────────────────────
+    // Creates a campaign with pre-built content in a single call.
+    // Designed for external orchestrators (any MCP client, HTTP API, or automation)
+    // that draft their own content and just need Sendinel to deliver it.
+    server.registerTool('create_campaign_with_content', {
+        description: 'Create a campaign with pre-built email content in one call. Creates the campaign, adds email step(s), optionally enrolls a segment, and activates. Ideal for orchestrators that draft their own content — skips AI generation. Uses two-call confirmation: first call returns a preview, second call with confirmed=true executes.',
+        inputSchema: {
+            site_id: z.string().uuid().describe('Site to send from'),
+            name: z.string().min(1).max(200).describe('Campaign name'),
+            type: z.enum(['sequence', 'broadcast']).describe('Campaign type'),
+            steps: z.array(z.object({
+                subject: z.string().min(1).describe('Email subject line'),
+                body_html: z.string().min(1).describe('Full HTML email body'),
+                body_text: z.string().optional().describe('Plain text fallback'),
+                delay_days: z.number().int().min(0).optional().default(0),
+                delay_hours: z.number().int().min(0).max(23).optional().default(0),
+            })).min(1).describe('Email steps with pre-built content'),
+            segment_id: z.string().uuid().optional().describe('Segment to auto-enroll. If omitted, campaign is created in draft without enrollments.'),
+            activate: z.boolean().optional().default(false).describe('Set to true to activate immediately after creation. Requires segment_id.'),
+            confirmed: z.boolean().optional().default(false).describe('Two-call confirmation. First call previews, second call with confirmed=true executes.'),
+            approval_id: z.string().uuid().optional().describe('Approval token from a previous call. Required when activate=true — get this by calling once without it, then have a human approve via the dashboard.'),
+        },
+    }, async ({ site_id, name, type, steps, segment_id, activate, confirmed, approval_id }) => {
+        // Human-in-the-loop gate for activation
+        if (activate && confirmed) {
+            const tier = getApprovalTier('create_campaign_with_content', { activate });
+            if (tier !== 'autonomous') {
+                if (!approval_id) {
+                    // No approval token — request one
+                    const approval = await requestApproval('create_campaign_with_content', { site_id, name, type, steps_count: steps.length, segment_id, activate });
+                    return j(approval);
+                }
+                // Have a token — verify it's approved
+                const status = await checkApproval(approval_id, { consume: true });
+                if (!status.approved) {
+                    return txt(`Approval ${approval_id} is ${status.status}. ${status.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`);
+                }
+            }
+        }
+        // Plan limit check
+        const limit = await checkPlanLimit('active_campaigns');
+        if (!limit.allowed) {
+            return txt(`Campaign limit reached (${limit.current}/${limit.limit}). Upgrade your plan for more campaigns.`);
+        }
+        // Verify site exists
+        const { data: site, error: siteErr } = await db()
+            .from('sites')
+            .select('id, name, sending_domain, from_email')
+            .eq('id', site_id)
+            .eq('project_id', getProjectId())
+            .maybeSingle();
+        if (siteErr || !site)
+            return txt(`Site not found: ${site_id}`);
+        // If segment provided, get contact count
+        let contactCount = 0;
+        if (segment_id) {
+            const { data: subs } = await db()
+                .from('site_subscriptions')
+                .select('contact_id', { count: 'exact', head: true })
+                .eq('site_id', site_id)
+                .eq('subscribed', true);
+            contactCount = subs ?? 0;
+        }
+        // Preview mode (first call)
+        if (!confirmed) {
+            return j({
+                confirmation_required: true,
+                campaign: { name, type, site: site.name },
+                steps: steps.map((s, i) => ({
+                    step: i + 1,
+                    subject: s.subject,
+                    delay: s.delay_days ? `${s.delay_days}d ${s.delay_hours ?? 0}h` : `${s.delay_hours ?? 0}h`,
+                    has_html: !!s.body_html,
+                    has_text: !!s.body_text,
+                })),
+                segment_id: segment_id ?? null,
+                estimated_contacts: contactCount,
+                will_activate: activate && !!segment_id,
+                message: `Campaign "${name}" with ${steps.length} step(s) on ${site.name}. ${segment_id ? `Will enroll ~${contactCount} contacts.` : 'No segment — created as draft.'} ${activate && segment_id ? 'Will activate immediately.' : ''} Call again with confirmed=true to proceed.`,
+            });
+        }
+        // Execute mode (second call)
+        // 1. Create campaign
+        const { data: campaign, error: campErr } = await db()
+            .from('campaigns')
+            .insert({
+            project_id: getProjectId(),
+            site_id,
+            name,
+            type,
+            status: 'draft',
+            segment_id: segment_id ?? null,
+        })
+            .select()
+            .single();
+        if (campErr)
+            return txt(`Failed to create campaign: ${campErr.message}`);
+        // 2. Add steps
+        const stepInserts = steps.map((s, i) => ({
+            campaign_id: campaign.id,
+            step_order: i,
+            subject: s.subject,
+            body_html: s.body_html,
+            body_text: s.body_text ?? null,
+            delay_days: s.delay_days ?? 0,
+            delay_hours: s.delay_hours ?? 0,
+        }));
+        const { error: stepErr } = await db()
+            .from('campaign_steps')
+            .insert(stepInserts);
+        if (stepErr)
+            return txt(`Campaign created (${campaign.id}) but failed to add steps: ${stepErr.message}`);
+        // 3. Enroll segment if provided
+        let enrolled = 0;
+        if (segment_id) {
+            const { data: subs } = await db()
+                .from('site_subscriptions')
+                .select('contact_id')
+                .eq('site_id', site_id)
+                .eq('subscribed', true);
+            if (subs?.length) {
+                const ids = subs.map((s) => s.contact_id);
+                const { data: contacts } = await db()
+                    .from('subscribers')
+                    .select('id, email')
+                    .in('id', ids)
+                    .eq('global_unsubscribed', false);
+                const { data: suppressed } = await db()
+                    .from('suppressions')
+                    .select('email')
+                    .eq('project_id', getProjectId());
+                const suppressedSet = new Set((suppressed ?? []).map((s) => s.email));
+                const eligible = (contacts ?? []).filter((c) => !suppressedSet.has(c.email));
+                if (eligible.length) {
+                    const enrollments = eligible.map((c) => ({
+                        campaign_id: campaign.id,
+                        contact_id: c.id,
+                        next_send_at: new Date().toISOString(),
+                    }));
+                    const { error: enrollErr } = await db()
+                        .from('campaign_enrollments')
+                        .insert(enrollments);
+                    if (!enrollErr) {
+                        enrolled = eligible.length;
+                        await db().from('campaigns').update({ total_enrolled: eligible.length }).eq('id', campaign.id);
+                    }
+                }
+            }
+        }
+        // 4. Activate if requested
+        if (activate && segment_id && enrolled > 0) {
+            await db()
+                .from('campaigns')
+                .update({ status: 'active' })
+                .eq('id', campaign.id);
+            // Fire webhook event (non-blocking)
+            fireWebhookEvent('campaign.activated', {
+                campaign_id: campaign.id,
+                campaign_name: name,
+                type,
+                contacts_enrolled: enrolled,
+                steps: steps.length,
+            }).catch(() => { }); // fire-and-forget
+        }
+        return j({
+            campaign_id: campaign.id,
+            name,
+            type,
+            steps_created: steps.length,
+            contacts_enrolled: enrolled,
+            status: activate && enrolled > 0 ? 'active' : 'draft',
+            message: `Campaign "${name}" created with ${steps.length} step(s). ${enrolled > 0 ? `${enrolled} contacts enrolled.` : 'No contacts enrolled.'} ${activate && enrolled > 0 ? 'Campaign is now active — emails will begin sending on the next cron cycle.' : 'Campaign saved as draft.'}`,
+        });
+    });
+    server.registerTool('list_campaign_steps', {
+        description: 'List all steps for a campaign in send order.',
+        inputSchema: { campaign_id: z.string().uuid() },
+    }, async ({ campaign_id }) => {
+        const projectId = getProjectId();
+        const { data: campaign, error: campaignErr } = await db()
+            .from('campaigns')
+            .select('id')
+            .eq('id', campaign_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (campaignErr || !campaign)
+            return j({ error: campaignErr?.message ?? 'Campaign not found', code: 'NOT_FOUND' });
+        const { data, error } = await db()
+            .from('campaign_steps')
+            .select('id, step_order, subject, body_html, body_text, delay_days, delay_hours, created_at, updated_at')
+            .eq('campaign_id', campaign_id)
+            .order('step_order', { ascending: true });
+        if (error)
+            return j({ error: error.message });
+        return j({ steps: data ?? [], count: data?.length ?? 0 });
+    });
+    server.registerTool('update_campaign_step', {
+        description: 'Update a campaign step — change subject, body, delay, or step_order.',
+        inputSchema: {
+            step_id: z.string().uuid(),
+            subject: z.string().optional(),
+            body_html: z.string().optional(),
+            body_text: z.string().optional(),
+            delay_days: z.number().int().min(0).optional(),
+            delay_hours: z.number().int().min(0).optional(),
+            step_order: z.number().int().min(0).optional(),
+        },
+    }, async ({ step_id, ...updates }) => {
+        const projectId = getProjectId();
+        const { data: step, error: stepErr } = await db()
+            .from('campaign_steps')
+            .select('id, campaign_id')
+            .eq('id', step_id)
+            .maybeSingle();
+        if (stepErr || !step)
+            return j({ error: stepErr?.message ?? 'Step not found', code: 'NOT_FOUND' });
+        const { data: campaign } = await db()
+            .from('campaigns')
+            .select('id')
+            .eq('id', step.campaign_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (!campaign)
+            return j({ error: 'Step not found', code: 'NOT_FOUND' });
+        const { data, error } = await db()
+            .from('campaign_steps')
+            .update({ ...updates, updated_at: new Date().toISOString() })
+            .eq('id', step_id)
+            .select('id, step_order, subject, delay_days, delay_hours, updated_at')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j({ step: data, ok: true });
+    });
+    server.registerTool('delete_campaign_step', {
+        description: 'Remove a step from a campaign. Only allowed on draft campaigns.',
+        inputSchema: { step_id: z.string().uuid() },
+    }, async ({ step_id }) => {
+        const projectId = getProjectId();
+        const { data: step } = await db()
+            .from('campaign_steps')
+            .select('campaign_id')
+            .eq('id', step_id)
+            .maybeSingle();
+        if (!step)
+            return j({ error: 'Step not found', code: 'NOT_FOUND' });
+        const { data: campaign } = await db()
+            .from('campaigns')
+            .select('status')
+            .eq('id', step.campaign_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (!campaign)
+            return j({ error: 'Step not found', code: 'NOT_FOUND' });
+        if (campaign.status !== 'draft') {
+            return j({ error: 'Can only delete steps from draft campaigns', code: 'INVALID_STATUS' });
+        }
+        const { error } = await db()
+            .from('campaign_steps')
+            .delete()
+            .eq('id', step_id);
+        if (error)
+            return j({ error: error.message });
+        return j({ ok: true, deleted: step_id });
+    });
+    server.registerTool('delete_campaign', {
+        description: 'Permanently delete a campaign. Campaign must not be active — pause it first. Deletes all steps and enrollments.',
+        inputSchema: { campaign_id: z.string().uuid() },
+    }, async ({ campaign_id }) => {
+        const projectId = getProjectId();
+        const { data: campaign, error: fetchErr } = await db()
+            .from('campaigns')
+            .select('id, name, status')
+            .eq('id', campaign_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (fetchErr || !campaign)
+            return j({ error: 'Campaign not found', code: 'NOT_FOUND' });
+        if (campaign.status === 'active') {
+            return j({ error: 'Pause the campaign before deleting', code: 'INVALID_STATUS' });
+        }
+        const { error } = await db()
+            .from('campaigns')
+            .delete()
+            .eq('id', campaign_id)
+            .eq('project_id', projectId);
+        if (error)
+            return j({ error: error.message });
+        return j({ success: true, deleted: campaign.name });
+    });
+    server.registerTool('update_campaign', {
+        description: 'Update a campaign name, site, segment, send time, topic, or trigger settings. Only provided fields are updated.',
+        inputSchema: {
+            campaign_id: z.string().uuid(),
+            name: z.string().min(1).max(200).optional(),
+            site_id: z.string().uuid().optional(),
+            segment_id: z.string().uuid().nullable().optional(),
+            send_at: z.string().datetime().nullable().optional(),
+            topic: z.string().nullable().optional(),
+            trigger_event_name: z.string().nullable().optional(),
+            trigger_tag: z.string().nullable().optional(),
+            send_in_contact_timezone: z.boolean().optional(),
+        },
+    }, async ({ campaign_id, name, site_id, segment_id, send_at, topic, trigger_event_name, trigger_tag, send_in_contact_timezone }) => {
+        const projectId = getProjectId();
+        const updates = { updated_at: new Date().toISOString() };
+        if (name !== undefined)
+            updates.name = name;
+        if (site_id !== undefined)
+            updates.site_id = site_id;
+        if (segment_id !== undefined)
+            updates.segment_id = segment_id;
+        if (send_at !== undefined)
+            updates.send_at = send_at;
+        if (topic !== undefined)
+            updates.topic = topic;
+        if (trigger_event_name !== undefined)
+            updates.trigger_event_name = trigger_event_name;
+        if (trigger_tag !== undefined)
+            updates.trigger_tag = trigger_tag;
+        if (send_in_contact_timezone !== undefined)
+            updates.send_in_contact_timezone = send_in_contact_timezone;
+        const { data, error } = await db()
+            .from('campaigns')
+            .update(updates)
+            .eq('id', campaign_id)
+            .eq('project_id', projectId)
+            .select()
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j(data);
+    });
+    server.registerTool('get_campaign', {
+        description: 'Get full details of a single campaign including all steps, current enrollment counts, and settings.',
+        inputSchema: { campaign_id: z.string().uuid() },
+    }, async ({ campaign_id }) => {
+        const projectId = getProjectId();
+        const { data: campaign, error: campErr } = await db()
+            .from('campaigns')
+            .select('*')
+            .eq('id', campaign_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (campErr || !campaign)
+            return j({ error: campErr?.message ?? 'Campaign not found', code: 'NOT_FOUND' });
+        const [{ data: steps }, { count: enrollCount }] = await Promise.all([
+            db()
+                .from('campaign_steps')
+                .select('*')
+                .eq('campaign_id', campaign_id)
+                .order('step_order', { ascending: true }),
+            db()
+                .from('campaign_enrollments')
+                .select('id', { count: 'exact', head: true })
+                .eq('campaign_id', campaign_id)
+                .eq('status', 'active'),
+        ]);
+        return j({ ...campaign, steps: steps ?? [], active_enrollments: enrollCount ?? 0 });
+    });
+    server.registerTool('unenroll_contact', {
+        description: 'Remove a contact from an active campaign enrollment. Use when a contact should no longer receive campaign emails.',
+        inputSchema: {
+            campaign_id: z.string().uuid(),
+            contact_id: z.string().uuid(),
+            reason: z.string().optional().describe('Optional reason for unenrollment'),
+        },
+    }, async ({ campaign_id, contact_id, reason }) => {
+        const projectId = getProjectId();
+        // Verify the campaign belongs to this project
+        const { data: campaign } = await db()
+            .from('campaigns')
+            .select('id')
+            .eq('id', campaign_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (!campaign)
+            return j({ error: 'Campaign not found', code: 'NOT_FOUND' });
+        const { error } = await db()
+            .from('campaign_enrollments')
+            .update({ status: 'exited', exited_reason: reason ?? 'manual_unenroll', updated_at: new Date().toISOString() })
+            .eq('campaign_id', campaign_id)
+            .eq('contact_id', contact_id);
+        if (error)
+            return j({ error: error.message });
+        return j({ success: true });
+    });
+}