@sendinel/mcp-server 1.0.3 → 1.0.5

package/build/tools/campaigns.js

@@ -5,13 +5,260 @@ 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 { assertChannelCanExecute, currentChannelContext, requestApproval, checkApproval } from '../lib/action-approvals.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
 import { getScheduleWindowBounds, groupScheduleByCampaign } from '../lib/schedule.js';
+import { sendEmailForSite } from '../lib/email-provider.js';
+import { renderTemplateString, resolveSurveyShortLink } from '../lib/survey-link-resolver.js';
+import { logAudit } from '../audit.js';
+import { recordBrandAssetUsage } from '../lib/brand-asset-usage.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
+function normalizeTriggerValue(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, '_');
+    return normalized || null;
+}
+function normalizeTriggerList(value) {
+    const raw = Array.isArray(value) ? value : typeof value === 'string' ? [value] : [];
+    return Array.from(new Set(raw.map(normalizeTriggerValue).filter((item) => Boolean(item))));
+}
+function buildCampaignTriggerConfig(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const config = value;
+    const events = normalizeTriggerList(config.events ?? config.event_names ?? config.trigger_event_names);
+    const tags = normalizeTriggerList(config.tags ?? config.trigger_tags ?? config.entity_tags ?? config.project_tags);
+    if (!events.length && !tags.length)
+        return null;
+    return { events, tags };
+}
+async function applyCampaignTargetingFields(updates, input, projectId) {
+    if (input.trigger_event_name !== undefined)
+        updates.trigger_event_name = input.trigger_event_name?.trim() || null;
+    if (input.trigger_tag !== undefined)
+        updates.trigger_tag = input.trigger_tag?.trim().toLowerCase() || null;
+    if (input.trigger_type === 'date_field') {
+        const config = input.trigger_config ?? {};
+        const field = typeof config.field === 'string' ? config.field.trim() : '';
+        if (!/^[A-Za-z0-9_.-]{1,80}$/.test(field))
+            return 'date field is required';
+        updates.trigger_type = 'date_field';
+        updates.trigger_config = {
+            field,
+            days_before: Math.max(0, Math.min(30, Number(config.days_before ?? 0) || 0)),
+            recurring: config.recurring !== false,
+        };
+    }
+    else if (input.trigger_config !== undefined) {
+        if (input.trigger_config === null) {
+            updates.trigger_config = null;
+        }
+        else {
+            const config = buildCampaignTriggerConfig(input.trigger_config);
+            if (!config)
+                return 'trigger_config must include events or tags';
+            updates.trigger_config = config;
+        }
+    }
+    if (input.segment_id !== undefined) {
+        if (!input.segment_id) {
+            updates.segment_id = null;
+        }
+        else {
+            const { data: segment, error } = await db()
+                .from('segments')
+                .select('id')
+                .eq('id', input.segment_id)
+                .eq('project_id', projectId)
+                .maybeSingle();
+            if (error)
+                return error.message;
+            if (!segment)
+                return 'Segment not found';
+            updates.segment_id = input.segment_id;
+        }
+    }
+    return null;
+}
+function applySegmentPaymentRules(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 = applySegmentPaymentDateRule(q, 'trial_ends_at', payment.trial_ends_at);
+    q = applySegmentPaymentDateRule(q, 'churned_at', payment.churned_at);
+    q = applySegmentPaymentDateRule(q, 'paid_at', payment.paid_at);
+    return q;
+}
+function applySegmentPaymentDateRule(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;
+}
+async function getSegmentContactIds(projectId, rules) {
+    let q = db()
+        .from('subscribers')
+        .select('id, email')
+        .eq('project_id', projectId)
+        .eq('global_unsubscribed', false)
+        .is('cooled_at', null);
+    if (rules.lifecycle_stage)
+        q = q.eq('lifecycle_stage', rules.lifecycle_stage);
+    q = applySegmentPaymentRules(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;
+}
+function extractJsonObject(raw) {
+    const cleaned = raw.replace(/```(?:json)?/gi, '').replace(/```/g, '').trim();
+    const start = cleaned.indexOf('{');
+    const end = cleaned.lastIndexOf('}');
+    if (start === -1 || end === -1 || end <= start) {
+        throw new Error('No JSON object found in consistency response');
+    }
+    return cleaned.slice(start, end + 1);
+}
+function cleanConsistencyText(value) {
+    return typeof value === 'string' ? value.trim().slice(0, 1000) : '';
+}
+function normalizeConsistencyResult(value) {
+    const obj = value && typeof value === 'object' ? value : {};
+    const rawFlags = Array.isArray(obj.flags) ? obj.flags : [];
+    const flags = rawFlags
+        .map((flag) => {
+        const record = flag && typeof flag === 'object' ? flag : {};
+        return {
+            claim_a: cleanConsistencyText(record.claim_a),
+            location_a: cleanConsistencyText(record.location_a),
+            claim_b: cleanConsistencyText(record.claim_b),
+            location_b: cleanConsistencyText(record.location_b),
+            explanation: cleanConsistencyText(record.explanation),
+        };
+    })
+        .filter((flag) => flag.claim_a && flag.claim_b && flag.explanation)
+        .slice(0, 50);
+    return {
+        consistent: typeof obj.consistent === 'boolean' ? obj.consistent : flags.length === 0,
+        flags,
+    };
+}
 export function registerCampaignTools(server) {
+    server.registerTool('review_campaign_portfolio', {
+        title: 'Review Campaign Portfolio',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Run the campaign portfolio review and optionally raise agent proposals for start/end/modify recommendations.',
+        inputSchema: {
+            dry_run: z.boolean().optional().default(false),
+            dormant_draft_days: z.number().int().min(1).max(365).optional(),
+            abandoned_days: z.number().int().min(1).max(365).optional(),
+        },
+    }, async ({ dry_run = false, dormant_draft_days, abandoned_days }) => {
+        const apiKey = process.env.SENDINEL_API_KEY;
+        if (!apiKey)
+            return j({ error: 'SENDINEL_API_KEY is required to run review_campaign_portfolio from MCP' });
+        const base = (process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? process.env.APP_URL ?? 'https://sendinel.ai').replace(/\/$/, '');
+        const res = await fetch(`${base}/api/v1/campaigns/review`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+                'X-Sendinel-Project-Id': getProjectId(),
+            },
+            body: JSON.stringify({
+                dry_run,
+                ...(dormant_draft_days !== undefined ? { dormant_draft_days } : {}),
+                ...(abandoned_days !== undefined ? { abandoned_days } : {}),
+            }),
+        });
+        const body = await res.text();
+        if (!res.ok)
+            return j({ error: `Campaign portfolio review failed: ${res.status}`, body });
+        try {
+            return j(JSON.parse(body));
+        }
+        catch {
+            return txt(body);
+        }
+    });
     server.registerTool('get_campaign_calendar', {
+        title: 'Get Campaign Calendar',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         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 }) => {
@@ -41,6 +288,13 @@ export function registerCampaignTools(server) {
         return j({ days });
     });
     server.registerTool('preview_campaign_audience', {
+        title: 'Preview Campaign Audience',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Preview active campaign audience and suppression warnings.',
         inputSchema: { campaign_id: z.string().uuid() },
     }, async ({ campaign_id }) => {
@@ -59,6 +313,13 @@ export function registerCampaignTools(server) {
         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', {
+        title: 'List Campaigns',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List campaigns, optionally filtered by site and/or status',
         inputSchema: {
             site_id: z.string().uuid().optional(),
@@ -68,7 +329,7 @@ export function registerCampaignTools(server) {
     }, 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')
+            .select('id, site_id, name, type, status, sends_per_hour, total_enrolled, total_sent, total_opened, total_clicked, created_at')
             .eq('project_id', getProjectId())
             .order('created_at', { ascending: false })
             .limit(limit ?? 25);
@@ -82,6 +343,13 @@ export function registerCampaignTools(server) {
         return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     });
     server.registerTool('get_schedule', {
+        title: 'Get Schedule',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Get scheduled campaign sends for a site within a time window, grouped by campaign.',
         inputSchema: {
             site_id: z.string().uuid(),
@@ -113,22 +381,48 @@ export function registerCampaignTools(server) {
         });
     });
     server.registerTool('create_campaign', {
-        description: 'Create a new email campaign',
+        title: 'Create Campaign',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Create a new email campaign. For triggered campaigns, provide one trigger shape: trigger_event_name, trigger_tag, trigger_type=date_field with trigger_config, or segment_id for ongoing audience targeting.',
         inputSchema: {
             site_id: z.string().uuid(),
             name: z.string().min(1).max(200),
             type: z.enum(['sequence', 'broadcast', 'triggered']),
             description: z.string().optional(),
+            sends_per_hour: z.number().int().min(1).nullable().optional().describe('Optional hourly send cap for wave sending. Null or omitted sends without a campaign-specific cap.'),
             requires_approval: z.boolean().optional().default(true),
+            trigger_event_name: z.string().optional().describe('For type=triggered: event name that fires this campaign'),
+            trigger_tag: z.string().optional().describe('For type=triggered: contact tag that fires this campaign when applied'),
+            trigger_type: z.enum(['date_field']).optional().describe('Set for elapsed-time triggers keyed on a contact custom_properties date field'),
+            trigger_config: z.record(z.string(), z.unknown()).nullable().optional().describe('For trigger_type=date_field: { field, days_before?, recurring? }. Otherwise: { events?: string[], tags?: string[] }.'),
+            segment_id: z.string().uuid().nullable().optional().describe('Segment UUID for ongoing audience targeting; membership is re-evaluated on sends'),
         },
-    }, async ({ site_id, name, type, description, requires_approval }) => {
+    }, async ({ site_id, name, type, description, sends_per_hour, requires_approval, trigger_event_name, trigger_tag, trigger_type, trigger_config, segment_id }) => {
         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 projectId = getProjectId();
+        const insertPayload = {
+            project_id: projectId,
+            site_id,
+            name,
+            type,
+            description,
+            sends_per_hour: sends_per_hour ?? null,
+            requires_approval,
+        };
+        const targetingError = await applyCampaignTargetingFields(insertPayload, { trigger_event_name, trigger_tag, trigger_type, trigger_config, segment_id }, projectId);
+        if (targetingError)
+            return j({ error: targetingError, code: targetingError === 'Segment not found' ? 'NOT_FOUND' : 'INVALID_FIELD' });
         const { data, error } = await db()
             .from('campaigns')
-            .insert({ project_id: getProjectId(), site_id, name, type, description, requires_approval })
+            .insert(insertPayload)
             .select()
             .single();
         if (error)
@@ -136,6 +430,13 @@ export function registerCampaignTools(server) {
         return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     });
     server.registerTool('add_campaign_step', {
+        title: 'Add Campaign Step',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         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(),
@@ -146,18 +447,47 @@ export function registerCampaignTools(server) {
             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.'),
+            survey_id: z.string().uuid().optional(),
+            brand_asset_ids: z.array(z.string().uuid()).optional().describe('Stable brand_media_assets ids explicitly referenced by this step.'),
         },
-    }, async ({ campaign_id, step_order, subject, body_html, body_text, delay_days, delay_hours, variant_label }) => {
+    }, async ({ campaign_id, step_order, subject, body_html, body_text, delay_days, delay_hours, variant_label, survey_id, brand_asset_ids }) => {
+        const renderVars = {};
+        if (survey_id) {
+            const surveyLink = await resolveSurveyShortLink(db(), getProjectId(), survey_id);
+            if (!surveyLink)
+                return j({ error: 'Survey has no short link yet', code: 'SURVEY_LINK_NOT_READY' });
+            renderVars.survey_link = surveyLink;
+        }
+        const renderedSubject = survey_id ? renderTemplateString(subject, renderVars) : subject;
+        const renderedHtml = body_html !== undefined && survey_id ? renderTemplateString(body_html, renderVars) : body_html;
+        const renderedText = body_text !== undefined && survey_id ? renderTemplateString(body_text, renderVars) : body_text;
         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' })
+            .insert({ campaign_id, step_order, subject: renderedSubject, body_html: renderedHtml, body_text: renderedText, delay_days, delay_hours, variant_label: variant_label ?? 'A' })
             .select()
             .single();
         if (error)
             return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        await recordBrandAssetUsage({
+            client: db(),
+            projectId: getProjectId(),
+            source: 'campaign_step',
+            resourceId: data.id,
+            html: renderedHtml,
+            assetIds: brand_asset_ids,
+        }).catch((err) => {
+            console.warn('Failed to record brand asset usage for MCP campaign step:', err);
+        });
         return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     });
     server.registerTool('update_campaign_status', {
+        title: 'Update Campaign Status',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
         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(),
@@ -167,13 +497,22 @@ export function registerCampaignTools(server) {
     }, async ({ campaign_id, status, approval_id }) => {
         // Human approval required for activation
         if (status === 'active') {
+            const approvalParams = { campaign_id, status };
             if (!approval_id) {
-                const approval = await requestApproval('update_campaign_status', { campaign_id, status });
-                return j(approval);
+                const channelContext = currentChannelContext();
+                const decision = assertChannelCanExecute('update_campaign_status', approvalParams, channelContext);
+                if (!decision.allowed)
+                    return txt(decision.reason ?? 'This channel cannot request this action.');
+                if (decision.tier !== 'autonomous') {
+                    const approval = await requestApproval('update_campaign_status', approvalParams, undefined, channelContext);
+                    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.'}`);
+            else {
+                const check = await checkApproval(approval_id, { consume: true, action: 'update_campaign_status', params: approvalParams });
+                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()
@@ -196,6 +535,13 @@ export function registerCampaignTools(server) {
         return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     });
     server.registerTool('enroll_contact', {
+        title: 'Enroll Contact',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Enroll a single contact in a campaign',
         inputSchema: {
             campaign_id: z.string().uuid(),
@@ -203,6 +549,20 @@ export function registerCampaignTools(server) {
             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: contact, error: contactError } = await db()
+            .from('subscribers')
+            .select('id, global_unsubscribed, cooled_at')
+            .eq('id', contact_id)
+            .eq('project_id', getProjectId())
+            .maybeSingle();
+        if (contactError)
+            return txt(`Error: ${contactError.message}`);
+        if (!contact)
+            return j({ error: 'Contact not found', code: 'NOT_FOUND' });
+        if (contact.global_unsubscribed)
+            return j({ enrolled: 0, skipped: 'global_unsubscribed' });
+        if (contact.cooled_at)
+            return j({ enrolled: 0, skipped: 'cooled_contact' });
         const { data, error } = await db()
             .from('campaign_enrollments')
             .insert({ campaign_id, contact_id, next_send_at: next_send_at ?? new Date().toISOString() })
@@ -218,6 +578,13 @@ export function registerCampaignTools(server) {
         return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
     });
     server.registerTool('get_enrollment_status', {
+        title: 'Get Enrollment Status',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: "Get one contact's enrollment status and sequence position for a campaign",
         inputSchema: {
             campaign_id: z.string().uuid(),
@@ -275,6 +642,13 @@ export function registerCampaignTools(server) {
         });
     });
     server.registerTool('enroll_segment', {
+        title: 'Enroll Segment',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Enroll all active subscribers from a site into a campaign. Skips globally unsubscribed and suppressed contacts.',
         inputSchema: {
             campaign_id: z.string().uuid(),
@@ -297,7 +671,8 @@ export function registerCampaignTools(server) {
             .from('subscribers')
             .select('id, email')
             .in('id', ids)
-            .eq('global_unsubscribed', false);
+            .eq('global_unsubscribed', false)
+            .is('cooled_at', null);
         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));
@@ -316,7 +691,228 @@ export function registerCampaignTools(server) {
         }
         return { content: [{ type: 'text', text: JSON.stringify({ enrolled: eligible.length, campaign_id, site_id }, null, 2) }] };
     });
+    server.registerTool('broadcast_to_segment', {
+        title: 'Broadcast To Segment',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Create a one-email broadcast campaign for an existing segment, enroll eligible contacts immediately, and activate it. Uses two-call confirmation plus approval before sending to real contacts.',
+        inputSchema: {
+            site_id: z.string().uuid().describe('Site/sender to send from'),
+            segment_id: z.string().uuid().describe('Existing segment to target'),
+            subject: z.string().min(1).max(300).describe('Broadcast subject line'),
+            body_html: z.string().min(1).describe('Full HTML email body'),
+            body_text: z.string().optional().describe('Plain text fallback'),
+            name: z.string().min(1).max(200).optional().describe('Optional campaign name. Defaults from subject.'),
+            sends_per_hour: z.number().int().min(1).nullable().optional().describe('Optional hourly send cap for wave sending. Null or omitted sends without a campaign-specific cap.'),
+            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 confirmed call without approval_id. Required when the action is not autonomous.'),
+            brand_asset_ids: z.array(z.string().uuid()).optional().describe('Stable brand_media_assets ids explicitly referenced by this broadcast body.'),
+        },
+    }, async ({ site_id, segment_id, subject, body_html, body_text, name, sends_per_hour, confirmed, approval_id, brand_asset_ids }) => {
+        const projectId = getProjectId();
+        const campaignName = name ?? `Broadcast - ${subject.slice(0, 120)}`;
+        const approvalParams = {
+            site_id,
+            segment_id,
+            subject,
+            body_html,
+            body_text,
+            name: campaignName,
+            sends_per_hour,
+        };
+        const { data: site, error: siteErr } = await db()
+            .from('sites')
+            .select('id, name, sending_domain, from_email')
+            .eq('id', site_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (siteErr || !site)
+            return j({ error: siteErr?.message ?? 'Site not found', code: 'SITE_NOT_FOUND' });
+        const { data: segment, error: segmentErr } = await db()
+            .from('segments')
+            .select('id, name, rules, site_id')
+            .eq('id', segment_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (segmentErr || !segment)
+            return j({ error: segmentErr?.message ?? 'Segment not found', code: 'SEGMENT_NOT_FOUND' });
+        const rules = {
+            ...(segment.rules ?? {}),
+            ...(segment.site_id ? { site_id: segment.site_id } : {}),
+        };
+        const contactIds = await getSegmentContactIds(projectId, rules);
+        if (!confirmed) {
+            return j({
+                confirmation_required: true,
+                tool: 'broadcast_to_segment',
+                campaign: {
+                    name: campaignName,
+                    type: 'broadcast',
+                    site: { id: site.id, name: site.name, from_email: site.from_email },
+                    segment: { id: segment.id, name: segment.name },
+                    subject,
+                    sends_per_hour: sends_per_hour ?? null,
+                },
+                matching_contacts: contactIds.length,
+                will_send_at: 'immediately',
+                message: `Broadcast "${campaignName}" will enroll ${contactIds.length} eligible contact(s) from segment "${segment.name}" and activate immediately. Call again with confirmed=true to proceed.`,
+            });
+        }
+        if (contactIds.length === 0) {
+            return j({
+                error: 'No eligible contacts match this segment.',
+                code: 'EMPTY_SEGMENT',
+                segment_id,
+                site_id,
+            });
+        }
+        const channelContext = currentChannelContext();
+        const decision = assertChannelCanExecute('broadcast_to_segment', approvalParams, channelContext);
+        if (!decision.allowed)
+            return txt(decision.reason ?? 'This channel cannot request this action.');
+        if (decision.tier !== 'autonomous') {
+            if (!approval_id) {
+                const approval = await requestApproval('broadcast_to_segment', approvalParams, undefined, channelContext);
+                return j(approval);
+            }
+            const check = await checkApproval(approval_id, { consume: true, action: 'broadcast_to_segment', params: approvalParams });
+            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 limit = await checkPlanLimit('active_campaigns');
+        if (!limit.allowed) {
+            return j({
+                error: `Campaign limit reached (${limit.current}/${limit.limit}). Upgrade your plan for more campaigns.`,
+                code: 'PLAN_LIMIT',
+            });
+        }
+        const { data: campaign, error: campaignErr } = await db()
+            .from('campaigns')
+            .insert({
+            project_id: projectId,
+            site_id,
+            segment_id,
+            name: campaignName,
+            type: 'broadcast',
+            status: 'draft',
+            sends_per_hour: sends_per_hour ?? null,
+            requires_approval: false,
+            metadata: { source: 'mcp_broadcast_to_segment' },
+        })
+            .select('id')
+            .single();
+        if (campaignErr || !campaign) {
+            return j({ error: campaignErr?.message ?? 'Failed to create campaign', code: 'CAMPAIGN_CREATE_FAILED' });
+        }
+        const { data: step, error: stepErr } = await db()
+            .from('campaign_steps')
+            .insert({
+            campaign_id: campaign.id,
+            step_order: 0,
+            subject,
+            body_html,
+            body_text: body_text ?? null,
+            delay_days: 0,
+            delay_hours: 0,
+        })
+            .select('id')
+            .single();
+        if (stepErr || !step) {
+            return j({
+                error: stepErr?.message ?? 'Campaign created but failed to add broadcast step',
+                code: 'STEP_CREATE_FAILED',
+                campaign_id: campaign.id,
+            });
+        }
+        await recordBrandAssetUsage({
+            client: db(),
+            projectId,
+            source: 'campaign_step',
+            resourceId: step.id,
+            html: body_html,
+            assetIds: brand_asset_ids,
+        }).catch((err) => {
+            console.warn('Failed to record brand asset usage for MCP broadcast:', err);
+        });
+        const sendAt = new Date().toISOString();
+        const batchSize = 500;
+        for (let i = 0; i < contactIds.length; i += batchSize) {
+            const batch = contactIds.slice(i, i + batchSize).map((contact_id) => ({
+                campaign_id: campaign.id,
+                contact_id,
+                next_send_at: sendAt,
+            }));
+            const { error: enrollErr } = await db()
+                .from('campaign_enrollments')
+                .upsert(batch, { onConflict: 'campaign_id,contact_id', ignoreDuplicates: true });
+            if (enrollErr) {
+                return j({
+                    error: enrollErr.message,
+                    code: 'ENROLLMENT_FAILED',
+                    campaign_id: campaign.id,
+                    enrolled_before_failure: i,
+                });
+            }
+        }
+        const { error: activateErr } = await db()
+            .from('campaigns')
+            .update({
+            status: 'active',
+            total_enrolled: contactIds.length,
+            updated_at: new Date().toISOString(),
+        })
+            .eq('id', campaign.id)
+            .eq('project_id', projectId);
+        if (activateErr) {
+            return j({
+                error: activateErr.message,
+                code: 'ACTIVATION_FAILED',
+                campaign_id: campaign.id,
+                enrolled: contactIds.length,
+            });
+        }
+        await logAudit({
+            action: 'campaign.broadcast_to_segment',
+            resourceType: 'campaign',
+            resourceId: campaign.id,
+            details: {
+                site_id,
+                segment_id,
+                contacts_enrolled: contactIds.length,
+                source: 'mcp',
+            },
+        }).catch(() => { });
+        fireWebhookEvent('campaign.activated', {
+            campaign_id: campaign.id,
+            campaign_name: campaignName,
+            type: 'broadcast',
+            contacts_enrolled: contactIds.length,
+            steps: 1,
+        }).catch(() => { });
+        return j({
+            campaign_id: campaign.id,
+            step_id: step.id,
+            name: campaignName,
+            status: 'active',
+            segment: { id: segment.id, name: segment.name },
+            contacts_enrolled: contactIds.length,
+            next_send_at: sendAt,
+            message: `Broadcast "${campaignName}" is active with ${contactIds.length} contact(s) enrolled for immediate sending.`,
+        });
+    });
     server.registerTool('clone_campaign', {
+        title: 'Clone Campaign',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Clone an existing campaign (with all steps) into a new draft campaign',
         inputSchema: {
             campaign_id: z.string().uuid().describe('Source campaign to clone'),
@@ -344,6 +940,7 @@ export function registerCampaignTools(server) {
             name: new_name,
             type: original.type,
             description: original.description,
+            sends_per_hour: original.sends_per_hour ?? null,
             requires_approval: original.requires_approval,
             status: 'draft',
         })
@@ -369,6 +966,13 @@ export function registerCampaignTools(server) {
         return j({ ...newCampaign, steps_copied: steps.length, cloned_from: campaign_id });
     });
     server.registerTool('generate_email', {
+        title: 'Generate Email',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
         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(),
@@ -450,7 +1054,14 @@ Adapt your tone accordingly:
         }
     });
     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.',
+        title: 'Launch Campaign',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Full campaign lifecycle in one call: create segment (from NL or existing), create campaign, generate emails from briefs, enroll contacts, activate. Requires human approval via the dashboard before confirmed execution.',
         inputSchema: {
             name: z.string().min(1).describe('Campaign name'),
             site_id: z.string().uuid(),
@@ -462,9 +1073,11 @@ Adapt your tone accordingly:
                 delay_days: z.number().int().min(0).optional().default(0),
                 delay_hours: z.number().int().min(0).optional().default(0),
             })).min(1),
+            sends_per_hour: z.number().int().min(1).nullable().optional().describe('Optional hourly send cap for wave sending. Null or omitted sends without a campaign-specific cap.'),
             confirmed: z.boolean().optional().describe('Set true after previewing to execute'),
+            approval_id: z.string().uuid().optional().describe('Required when executing. Get this by calling with confirmed=true and no approval_id, then have a human approve.'),
         },
-    }, async ({ name, site_id, type, segment_description, segment_id, emails, confirmed }) => {
+    }, async ({ name, site_id, type, segment_description, segment_id, emails, sends_per_hour, confirmed, approval_id }) => {
         if (!segment_description && !segment_id)
             return txt('Provide segment_description or segment_id.');
         const apiKey = process.env.ANTHROPIC_API_KEY;
@@ -472,6 +1085,31 @@ Adapt your tone accordingly:
             return txt('Error: ANTHROPIC_API_KEY not configured');
         const anthropic = new Anthropic({ apiKey });
         const projectId = getProjectId();
+        const approvalParams = {
+            name,
+            site_id,
+            type: type ?? 'sequence',
+            segment_description,
+            segment_id,
+            emails,
+            sends_per_hour,
+        };
+        if (confirmed) {
+            const channelContext = currentChannelContext();
+            const decision = assertChannelCanExecute('launch_campaign', approvalParams, channelContext);
+            if (!decision.allowed)
+                return txt(decision.reason ?? 'This channel cannot request this action.');
+            if (decision.tier !== 'autonomous') {
+                if (!approval_id) {
+                    const approval = await requestApproval('launch_campaign', approvalParams, undefined, channelContext);
+                    return j(approval);
+                }
+                const check = await checkApproval(approval_id, { consume: true, action: 'launch_campaign', params: approvalParams });
+                if (!check.approved) {
+                    return txt(`Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`);
+                }
+            }
+        }
         function applyPaymentRules(query, payment) {
             if (!payment)
                 return query;
@@ -510,7 +1148,7 @@ Adapt your tone accordingly:
         }
         // 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);
+            let q = db().from('subscribers').select('id, email').eq('project_id', projectId).eq('global_unsubscribed', false).is('cooled_at', null);
             if (rules.lifecycle_stage)
                 q = q.eq('lifecycle_stage', rules.lifecycle_stage);
             q = applyPaymentRules(q, rules.payment);
@@ -610,6 +1248,7 @@ Adapt your tone accordingly:
                 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,
                 })),
+                sends_per_hour: sends_per_hour ?? null,
                 message: `Campaign "${name}" will target ${contactCount} contacts with ${emails.length} email(s). Call again with confirmed: true to create everything.`,
             });
         }
@@ -631,7 +1270,7 @@ Adapt your tone accordingly:
             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 })
+            .insert({ project_id: projectId, site_id, name, type: type ?? 'sequence', segment_id: segId, sends_per_hour: sends_per_hour ?? null, requires_approval: false })
             .select('id')
             .single();
         if (campErr)
@@ -693,6 +1332,13 @@ Adapt your tone accordingly:
         });
     });
     server.registerTool('preview_email', {
+        title: 'Preview Email',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         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'),
@@ -751,7 +1397,14 @@ Adapt your tone accordingly:
         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.',
+        title: 'Send Test Email',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Send a test email to a specified address using the site\'s configured provider. 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)'),
@@ -808,26 +1461,22 @@ Adapt your tone accordingly:
             .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 resolvedHtml = resolve(html);
+        const resolvedText = resolve(text);
         const payload = {
             from: `${site.from_name} <${site.from_email}>`,
             to: to_email,
             subject: `[TEST] ${resolve(subj)}`,
+            html: resolvedHtml || undefined,
+            text: resolvedText || undefined,
         };
-        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}`);
+        let sendResult;
+        try {
+            sendResult = await sendEmailForSite(projectId, site_id, payload);
+        }
+        catch (error) {
+            return txt(`Error: Send failed — ${error instanceof Error ? error.message : 'unknown provider error'}`);
+        }
         await db().from('email_log').insert({
             project_id: projectId,
             site_id,
@@ -838,13 +1487,26 @@ Adapt your tone accordingly:
             status: 'sent',
             category: 'test',
             sent_at: new Date().toISOString(),
-            provider_message_id: resendData?.id ?? null,
+            provider_message_id: sendResult.messageId ?? null,
             body_html: resolvedHtml ?? null,
         });
-        return j({ sent: true, to: to_email, resend_id: resendData?.id });
+        return j({
+            sent: true,
+            to: to_email,
+            provider: sendResult.provider,
+            provider_message_id: sendResult.messageId,
+            resend_id: sendResult.provider === 'resend' ? sendResult.messageId : null,
+        });
     });
     server.registerTool('send_transactional', {
-        description: 'Send a transactional email (password reset, receipt, notification). Checks suppressions and plan limits. Logged with category transactional.',
+        title: 'Send Transactional',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Send a transactional email (password reset, receipt, notification) using the site\'s configured provider. 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)'),
@@ -876,8 +1538,14 @@ Adapt your tone accordingly:
                 .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 });
+            if (existing) {
+                return j({
+                    error: 'Duplicate send',
+                    id: existing.id,
+                    provider_message_id: existing.provider_message_id,
+                    resend_id: existing.provider_message_id,
+                });
+            }
         }
         // Site verification
         const { data: site } = await db()
@@ -888,26 +1556,21 @@ Adapt your tone accordingly:
             .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,
+            html,
+            text,
+            replyTo: reply_to,
         };
-        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}`);
+        let sendResult;
+        try {
+            sendResult = await sendEmailForSite(projectId, site_id, payload);
+        }
+        catch (error) {
+            return txt(`Error: Send failed — ${error instanceof Error ? error.message : 'unknown provider error'}`);
+        }
         // Log to email_log
         const { data: logRow } = await db().from('email_log').insert({
             project_id: projectId,
@@ -919,13 +1582,27 @@ Adapt your tone accordingly:
             status: 'sent',
             category: 'transactional',
             sent_at: new Date().toISOString(),
-            provider_message_id: resendData?.id ?? null,
+            provider_message_id: sendResult.messageId ?? 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 });
+        return j({
+            sent: true,
+            id: logRow?.id,
+            to,
+            provider: sendResult.provider,
+            provider_message_id: sendResult.messageId,
+            resend_id: sendResult.provider === 'resend' ? sendResult.messageId : null,
+        });
     });
     server.registerTool('validate_template', {
+        title: 'Validate Template',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         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'),
@@ -945,11 +1622,91 @@ Adapt your tone accordingly:
         const result = validateTemplate(html, voiceConfig);
         return j(result);
     });
+    server.registerTool('check_content_consistency', {
+        title: 'Check Content Consistency',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        description: 'Analyze long-form campaign or nurture content for cross-document factual and numeric inconsistencies. Returns contradictions between entities, dates, dollar amounts, percentages, and other concrete claims without rewriting the content.',
+        inputSchema: {
+            content: z.string().min(1).max(120000).describe('Full drafted content to scan, including section labels or multiple documents when available'),
+            site_id: z.string().uuid().optional().describe('Optional site UUID for audit context only'),
+        },
+    }, async ({ content, site_id }) => {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey)
+            return txt('Error: ANTHROPIC_API_KEY not configured');
+        const anthropic = new Anthropic({ apiKey });
+        const system = `You are Sendinel's factual consistency auditor for outbound marketing drafts.
+
+PREMISES
+- Analyze only the supplied content. Do not use outside knowledge.
+- Find contradictions across sections, variants, or documents.
+- Prioritize concrete factual and numeric claims: names, companies, places, dates, times, dollars, percentages, counts, product facts, eligibility rules, links, and deadlines.
+- Similar wording is not a contradiction. Only flag claims that cannot both be true or are likely to confuse a recipient.
+- Do not rewrite the content.
+
+EXECUTION TRACE
+1. Extract concrete claims with their section/location clues.
+2. Compare claims across the full input.
+3. Keep only material inconsistencies.
+
+CONCLUSION
+Return ONLY valid JSON with this exact shape:
+{
+  "consistent": boolean,
+  "flags": [
+    {
+      "claim_a": "first conflicting claim",
+      "location_a": "section, paragraph, or document label for claim_a",
+      "claim_b": "second conflicting claim",
+      "location_b": "section, paragraph, or document label for claim_b",
+      "explanation": "why the claims conflict"
+    }
+  ]
+}`;
+        let result;
+        try {
+            const response = await anthropic.messages.create({
+                model: getAnthropicModelId(),
+                max_tokens: 1500,
+                system,
+                messages: [{ role: 'user', content }],
+            });
+            const block = response.content.find((item) => item.type === 'text');
+            const raw = block && 'text' in block ? block.text : '';
+            result = normalizeConsistencyResult(JSON.parse(extractJsonObject(raw)));
+        }
+        catch (error) {
+            return txt(`Error: Consistency check failed — ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+        await logAudit({
+            action: 'check_content_consistency',
+            resourceType: 'content_consistency_check',
+            details: {
+                site_id: site_id ?? null,
+                content_length: content.length,
+                flag_count: result.flags.length,
+                flags: result.flags,
+            },
+        });
+        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', {
+        title: 'Create Campaign With Content',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         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'),
@@ -963,22 +1720,27 @@ Adapt your tone accordingly:
                 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.'),
+            sends_per_hour: z.number().int().min(1).nullable().optional().describe('Optional hourly send cap for wave sending. Null or omitted sends without a campaign-specific cap.'),
             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 }) => {
+    }, async ({ site_id, name, type, steps, segment_id, sends_per_hour, 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') {
+            const approvalParams = { site_id, name, type, steps, segment_id, sends_per_hour, activate };
+            const channelContext = currentChannelContext();
+            const decision = assertChannelCanExecute('create_campaign_with_content', { activate }, channelContext);
+            if (!decision.allowed)
+                return txt(decision.reason ?? 'This channel cannot request this action.');
+            if (decision.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 });
+                    const approval = await requestApproval('create_campaign_with_content', approvalParams, undefined, channelContext);
                     return j(approval);
                 }
                 // Have a token — verify it's approved
-                const status = await checkApproval(approval_id, { consume: true });
+                const status = await checkApproval(approval_id, { consume: true, action: 'create_campaign_with_content', params: approvalParams });
                 if (!status.approved) {
                     return txt(`Approval ${approval_id} is ${status.status}. ${status.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`);
                 }
@@ -1021,6 +1783,7 @@ Adapt your tone accordingly:
                     has_text: !!s.body_text,
                 })),
                 segment_id: segment_id ?? null,
+                sends_per_hour: sends_per_hour ?? 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.`,
@@ -1037,6 +1800,7 @@ Adapt your tone accordingly:
             type,
             status: 'draft',
             segment_id: segment_id ?? null,
+            sends_per_hour: sends_per_hour ?? null,
         })
             .select()
             .single();
@@ -1071,7 +1835,8 @@ Adapt your tone accordingly:
                     .from('subscribers')
                     .select('id, email')
                     .in('id', ids)
-                    .eq('global_unsubscribed', false);
+                    .eq('global_unsubscribed', false)
+                    .is('cooled_at', null);
                 const { data: suppressed } = await db()
                     .from('suppressions')
                     .select('email')
@@ -1120,6 +1885,13 @@ Adapt your tone accordingly:
         });
     });
     server.registerTool('list_campaign_steps', {
+        title: 'List Campaign Steps',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List all steps for a campaign in send order.',
         inputSchema: { campaign_id: z.string().uuid() },
     }, async ({ campaign_id }) => {
@@ -1142,6 +1914,13 @@ Adapt your tone accordingly:
         return j({ steps: data ?? [], count: data?.length ?? 0 });
     });
     server.registerTool('update_campaign_step', {
+        title: 'Update Campaign Step',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Update a campaign step — change subject, body, delay, or step_order.',
         inputSchema: {
             step_id: z.string().uuid(),
@@ -1151,9 +1930,11 @@ Adapt your tone accordingly:
             delay_days: z.number().int().min(0).optional(),
             delay_hours: z.number().int().min(0).optional(),
             step_order: z.number().int().min(0).optional(),
+            survey_id: z.string().uuid().optional(),
         },
     }, async ({ step_id, ...updates }) => {
         const projectId = getProjectId();
+        const { survey_id, ...stepUpdates } = updates;
         const { data: step, error: stepErr } = await db()
             .from('campaign_steps')
             .select('id, campaign_id')
@@ -1169,9 +1950,22 @@ Adapt your tone accordingly:
             .maybeSingle();
         if (!campaign)
             return j({ error: 'Step not found', code: 'NOT_FOUND' });
+        const renderVars = {};
+        if (survey_id) {
+            const surveyLink = await resolveSurveyShortLink(db(), projectId, survey_id);
+            if (!surveyLink)
+                return j({ error: 'Survey has no short link yet', code: 'SURVEY_LINK_NOT_READY' });
+            renderVars.survey_link = surveyLink;
+        }
+        const renderedUpdates = {
+            ...stepUpdates,
+            ...(survey_id && stepUpdates.subject !== undefined ? { subject: renderTemplateString(stepUpdates.subject, renderVars) } : {}),
+            ...(survey_id && stepUpdates.body_html !== undefined ? { body_html: renderTemplateString(stepUpdates.body_html, renderVars) } : {}),
+            ...(survey_id && stepUpdates.body_text !== undefined ? { body_text: renderTemplateString(stepUpdates.body_text, renderVars) } : {}),
+        };
         const { data, error } = await db()
             .from('campaign_steps')
-            .update({ ...updates, updated_at: new Date().toISOString() })
+            .update({ ...renderedUpdates, updated_at: new Date().toISOString() })
             .eq('id', step_id)
             .select('id, step_order, subject, delay_days, delay_hours, updated_at')
             .single();
@@ -1180,6 +1974,13 @@ Adapt your tone accordingly:
         return j({ step: data, ok: true });
     });
     server.registerTool('delete_campaign_step', {
+        title: 'Delete Campaign Step',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Remove a step from a campaign. Only allowed on draft campaigns.',
         inputSchema: { step_id: z.string().uuid() },
     }, async ({ step_id }) => {
@@ -1211,6 +2012,13 @@ Adapt your tone accordingly:
         return j({ ok: true, deleted: step_id });
     });
     server.registerTool('delete_campaign', {
+        title: 'Delete Campaign',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         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 }) => {
@@ -1236,6 +2044,13 @@ Adapt your tone accordingly:
         return j({ success: true, deleted: campaign.name });
     });
     server.registerTool('update_campaign', {
+        title: 'Update Campaign',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Update a campaign name, site, segment, send time, topic, or trigger settings. Only provided fields are updated.',
         inputSchema: {
             campaign_id: z.string().uuid(),
@@ -1246,27 +2061,29 @@ Adapt your tone accordingly:
             topic: z.string().nullable().optional(),
             trigger_event_name: z.string().nullable().optional(),
             trigger_tag: z.string().nullable().optional(),
+            trigger_type: z.enum(['date_field']).nullable().optional(),
+            trigger_config: z.record(z.string(), z.unknown()).nullable().optional(),
+            sends_per_hour: z.number().int().min(1).nullable().optional().describe('Optional hourly send cap for wave sending. Set null to clear.'),
             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 }) => {
+    }, async ({ campaign_id, name, site_id, segment_id, send_at, topic, trigger_event_name, trigger_tag, trigger_type, trigger_config, sends_per_hour, 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 (sends_per_hour !== undefined)
+            updates.sends_per_hour = sends_per_hour;
         if (send_in_contact_timezone !== undefined)
             updates.send_in_contact_timezone = send_in_contact_timezone;
+        const targetingError = await applyCampaignTargetingFields(updates, { trigger_event_name, trigger_tag, trigger_type, trigger_config, segment_id }, projectId);
+        if (targetingError)
+            return j({ error: targetingError, code: targetingError === 'Segment not found' ? 'NOT_FOUND' : 'INVALID_FIELD' });
         const { data, error } = await db()
             .from('campaigns')
             .update(updates)
@@ -1279,6 +2096,13 @@ Adapt your tone accordingly:
         return j(data);
     });
     server.registerTool('get_campaign', {
+        title: 'Get Campaign',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         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 }) => {
@@ -1306,6 +2130,13 @@ Adapt your tone accordingly:
         return j({ ...campaign, steps: steps ?? [], active_enrollments: enrollCount ?? 0 });
     });
     server.registerTool('unenroll_contact', {
+        title: 'Unenroll Contact',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         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(),