@sendinel/mcp-server 1.0.165 → 1.0.167

package/build/tools/campaigns.js

@@ -19,7 +19,7 @@ import { dbErrorResult, dbToolError, toolError } from '../lib/db-error.js';
 import { checkPlanLimit } from '../plan-limits.js';
 import { buildVoicePrompt, buildEmailSystemPrompt, deriveTemplateVariables, validateTemplate } from '../lib/voice.js';
 import { fireWebhookEvent } from '../lib/webhook-events.js';
-import { approvalExcerpt, assertChannelCanExecute, currentChannelContext, requestApproval, checkApproval, withApproval } from '../lib/action-approvals.js';
+import { approvalNext, approvalExcerpt, assertChannelCanExecute, currentChannelContext, requestApproval, checkApproval, withApproval } from '../lib/action-approvals.js';
 import { sandboxAudience, broadcastApprovalNext } from '../lib/sandbox-audience.js';
 import { resolveSegmentContactIds, resolveSendAudience } from '../lib/send-audience.js';
 import { generateEmailFromBrief, parseAudienceRules } from '../lib/email-generation.js';
@@ -190,27 +190,30 @@ async function campaignTimezoneWarnings(campaign) {
     const sendWindow = campaign.send_window ?? (campaign.send_window_inherit !== false ? site?.send_window : null);
     return sendWindow && !validTimezone(site?.timezone) ? [SEND_WINDOW_TIMEZONE_WARNING] : [];
 }
-async function campaignTriggerOutput(campaign) {
-    let seenEvents;
-    const config = normalizeTriggerConfig(campaign.trigger_config);
-    if (normalizeTriggerValue(campaign.trigger_event_name) || config.events.length) {
-        try {
-            // /v1/events -> intakeContactEvent stores event_type=custom and title=event.
-            // Read all pages: a capped sample cannot establish that an event was never seen.
-            const rows = await readAllRows(db().from('contact_events').select('id, title')
-                .eq('project_id', getProjectId()).eq('event_type', 'custom'));
-            seenEvents = new Set(rows.map(row => normalizeTriggerValue(row.title)).filter((value) => value !== null));
-        }
-        catch {
-            seenEvents = null;
-        }
+async function readCampaignTriggerHistory(campaigns) {
+    if (!campaigns.some(campaign => normalizeTriggerValue(campaign.trigger_event_name)
+        || normalizeTriggerConfig(campaign.trigger_config).events.length))
+        return undefined;
+    try {
+        // /v1/events stores event_type=custom and title=event. Read every page once per response.
+        const rows = await readAllRows(db().from('contact_events').select('id, title')
+            .eq('project_id', getProjectId()).eq('event_type', 'custom'));
+        return new Set(rows.map(row => normalizeTriggerValue(row.title)).filter((value) => value !== null));
     }
+    catch {
+        return null;
+    }
+}
+function buildCampaignTriggerOutput(campaign, seenEvents) {
     return {
         trigger_kind: campaignTriggerKind(campaign),
         fires_on: buildCampaignFiresOn(campaign),
         trigger_diagnostics: buildCampaignTriggerDiagnostics(campaign, seenEvents),
     };
 }
+async function campaignTriggerOutput(campaign) {
+    return buildCampaignTriggerOutput(campaign, await readCampaignTriggerHistory([campaign]));
+}
 function applyCampaignSendAtField(updates, sendAt, campaignType) {
     if (sendAt === undefined)
         return null;
@@ -780,14 +783,14 @@ export function registerCampaignTools(server) {
         // counts that cannot exceed total_sent. null = the people-count lookup failed (unknown, not 0).
         const rows = data ?? [];
         const engagement = await countUniqueEngagementByCampaign(db(), getProjectId(), rows.map((row) => row.id));
+        const seenEvents = await readCampaignTriggerHistory(rows);
         const withPeople = await Promise.all(rows.map(async (row) => {
             const periods = await readCampaignPeriods(db(), getProjectId(), row);
             return {
                 ...row,
                 reentry_mode: row.period_key ? "per_event_period" : "once_ever",
                 requires_approval_description: ACTIVATION_APPROVAL_DESCRIPTION,
-                fires_on: buildCampaignFiresOn(row),
-                trigger_diagnostics: buildCampaignTriggerDiagnostics(row),
+                ...buildCampaignTriggerOutput(row, seenEvents),
                 ...campaignPeriodFields(periods, period),
                 total_sent: periods?.totals?.sent ?? (engagement.ok ? engagement.sent.get(row.id) ?? 0 : null),
                 unique_opened: periods?.totals?.opened ?? (engagement.ok ? engagement.opened.get(row.id) ?? 0 : null),
@@ -877,15 +880,15 @@ export function registerCampaignTools(server) {
         };
         const reentry = resolveCampaignReentry({ reentry_mode, period_key }, { type, trigger_type });
         if (!reentry.ok)
-            return j({ error: reentry.error, code: 'INVALID_FIELD' });
+            return j({ error: reentry.error, code: 'validation_failed' });
         if (reentry.period_key !== undefined)
             insertPayload.period_key = reentry.period_key;
         const scheduleError = applyCampaignSendAtField(insertPayload, send_at, type);
         if (scheduleError)
-            return j({ error: scheduleError, code: 'INVALID_FIELD' });
+            return j({ error: scheduleError, code: 'validation_failed' });
         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' });
+            return j({ error: targetingError, code: targetingError === 'Segment not found' ? 'NOT_FOUND' : 'validation_failed' });
         const { data, error } = await db()
             .from('campaigns')
             .insert(insertPayload)
@@ -1110,7 +1113,7 @@ export function registerCampaignTools(server) {
         },
         description: 'Enroll a single contact in a campaign',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             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.'),
@@ -1233,7 +1236,7 @@ export function registerCampaignTools(server) {
         },
         description: 'Enroll all active subscribers from a site into a campaign. Skips globally unsubscribed and suppressed contacts.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             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.'),
@@ -1625,6 +1628,11 @@ export function registerCampaignTools(server) {
             content = { subject: subject, body_html: html, body_text: body_text ?? approvalExcerpt(html, 100000), blocks: null };
         }
         const delivery = await sandboxAudience(projectId, resolved.contactIds);
+        if (delivery.recipient_count === 0) {
+            return j({ error: 'No recipients can be delivered under the sandbox policy. Choose an allowed audience before requesting approval.',
+                code: 'validation_failed', ...delivery,
+                audience: { label: segmentName, segment_id: segment_id ?? null, ...heldBackLines(resolved) } });
+        }
         const campaignName = name ?? `Broadcast - ${content.subject.slice(0, 120)}`;
         const payload = {
             site_id: site.id,
@@ -1729,14 +1737,27 @@ export function registerCampaignTools(server) {
         }
         const copied = new Set(['project_id', 'site_id', 'name', 'type', 'description', 'sends_per_hour', 'requires_approval']);
         const identity = new Set(['id', 'status', 'created_at', 'updated_at', 'campaign_steps']);
+        const configurationFields = [
+            'trigger_type', 'trigger_event_name', 'trigger_tag', 'trigger_config', 'send_class',
+            'period_key', 'reentry_mode', 'campaign_step_branches', 'segment_id',
+            'unsub_footer_template', 'campaign_goals', 'topic', 'send_at', 'send_time', 'timezone',
+            'goal_type', 'goal_value', 'goal_action', 'goal_target_campaign_id',
+        ];
+        // Keep the exhaustive machine-readable inventory, with important settings first.
         const fields_not_copied = [...new Set([
+                ...configurationFields.filter(key => key in original || [
+                    'trigger_type', 'trigger_event_name', 'trigger_tag', 'trigger_config', 'segment_id',
+                    'send_class', 'unsub_footer_template', 'period_key', 'reentry_mode', 'campaign_goals', 'campaign_step_branches',
+                ].includes(key)),
                 ...Object.keys(original).filter(key => !copied.has(key) && !identity.has(key)),
-                'trigger_type', 'trigger_event_name', 'trigger_tag', 'trigger_config', 'segment_id',
-                'send_class', 'unsub_footer_template', 'period_key', 'reentry_mode', 'campaign_goals', 'campaign_step_branches',
             ])];
+        const counters = fields_not_copied.filter(key => /^(?:total_|unique_)|_rate$/.test(key));
+        const warnings = fields_not_copied.filter(key => configurationFields.includes(key)).map(field => `${field} was not copied${field === 'trigger_config' ? ' (including where filters)' : ''}; review and configure the draft before activation.`);
+        if (counters.length)
+            warnings.push(`Counters and reporting statistics are reset for the draft: ${counters.join(', ')}.`);
         await logAudit({ action: 'campaign.cloned', resourceType: 'campaign', resourceId: newCampaign.id, details: { cloned_from: campaign_id, fields_not_copied } });
         return j({ ...newCampaign, steps_copied: steps.length, cloned_from: campaign_id, fields_not_copied,
-            warnings: fields_not_copied.map(field => `${field} was not copied; review and configure the draft before activation.`) });
+            warnings });
     });
     server.registerTool('list_sequence_templates', {
         title: 'List Sequence Templates',
@@ -1995,7 +2016,7 @@ Adapt your tone accordingly:
             idempotentHint: false,
             openWorldHint: true,
         },
-        description: 'Full campaign lifecycle: create segment (from NL or existing), create campaign, generate emails from briefs, enroll contacts, activate. Call with confirmed=true to write the emails and get an approval_id; a person approves those exact emails; call again with the same arguments plus approval_id to launch them. Nothing is created or sent before approval.',
+        description: 'Full campaign lifecycle: create segment (from NL or existing), create campaign, generate emails from briefs, enroll contacts, activate. Call with confirmed=true to write the emails and get an approval_id; a person approves those exact emails; call again with only approval_id to launch them. Nothing is created or sent before approval.',
         inputSchema: {
             name: z.string().min(1).describe('Campaign name'),
             site_id: z.string().uuid(),
@@ -2428,7 +2449,7 @@ Do not include body_html in your response; Sendinel renders body_html from block
                 emails: plan.steps.map((step, i) => ({
                     step: i, subject: step.subject, body_html: step.body_html, body_text: step.body_text, delay_days: step.delay_days, delay_hours: step.delay_hours,
                 })),
-                next: 'Show the user each subject, the recipient count and approve_url. After a person approves, call launch_campaign again with the same arguments plus approval_id. These exact emails are sent; nothing is rewritten. Do not say it launched before that call succeeds.',
+                next: approvalNext('launch_campaign', approval) + ' These exact emails are sent; nothing is rewritten. Do not say it launched before that call succeeds.',
             });
         }
         return launchFromPlan(plan);
@@ -2441,7 +2462,7 @@ Do not include body_html in your response; Sendinel renders body_html from block
             idempotentHint: true,
             openWorldHint: false,
         },
-        description: 'Preview email through the real send renderer: final campaign/site footer, unsubscribe text and send_class scope, sender and physical address. Uses sample contact data; unresolved_tags lists remaining tags. Provide campaign_id, step_id, draft_id, or raw body_html/subject.',
+        description: 'Preview email through the real send renderer: final campaign/site footer, unsubscribe text and send_class scope, sender and physical address. Uses sample contact data; unresolved_tags lists every remaining {{ opener, including malformed and unclosed tags; supported tags keep key names and malformed tags use literal text. Provide campaign_id, step_id, draft_id, or raw body_html/subject.',
         inputSchema: {
             site_id: z.string().uuid().optional().describe('Site UUID for sender tags and footers'),
             campaign_id: z.string().uuid().optional().describe('Campaign UUID; previews its first step in send order. Use step_id to choose a specific step.'),
@@ -2466,7 +2487,7 @@ Do not include body_html in your response; Sendinel renders body_html from block
         },
         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 uses the real send renderer. Optional dry_run previews without sending; suppressed recipients are refused. Logged as test, not counted in campaign metrics.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             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(),
@@ -2512,7 +2533,7 @@ Do not include body_html in your response; Sendinel renders body_html from block
         },
         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: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             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().optional().describe('Email subject line. Required unless template_id is supplied and the template has a subject_hint.'),
@@ -2696,9 +2717,9 @@ Do not include body_html in your response; Sendinel renders body_html from block
             idempotentHint: false,
             openWorldHint: true,
         },
-        description: 'Send a transactional email and track whether the recipient replies within a deadline. Mints a single-use Reply-To address with an expiry window, tags it with a correlation ID, and logs reply actions. Customer replies are captured as data only. Requires human approval: the first call returns an approve_url and does nothing; call again with the same arguments plus approval_id once approved.',
+        description: 'Send a transactional email and track whether the recipient replies within a deadline. Mints a single-use Reply-To address with an expiry window, tags it with a correlation ID, and logs reply actions. Customer replies are captured as data only. Requires human approval: the first call returns an approve_url and does nothing; call again with only approval_id once approved.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             to: z.string().email().describe('Recipient email address'),
             site_id: z.string().uuid().describe('Site UUID (determines from address and provider)'),
             subject: z.string().optional().describe('Email subject line. Required unless template_id is supplied and the template has a subject_hint.'),
@@ -2991,7 +3012,7 @@ Do not include body_html in your response; Sendinel renders body_html from block
             idempotentHint: true,
             openWorldHint: false,
         },
-        description: 'Validate an email template for variable errors and brand voice compliance. Checks for unknown {{variables}}, merge tags with no fallback, placeholder text left from an import ("Not specified in source material"), links to your sending domain, stock phrases, excessive CTAs, and a missing sign-off (only when your brand kit or site sets one). Pass trigger_event_name or event_keys to also check that each merge tag has data behind it.',
+        description: 'Validate an email template for variable errors and brand voice compliance. Checks for unknown {{variables}} in both subject and body as errors, merge tags with no fallback, placeholder text left from an import ("Not specified in source material"), links to your sending domain, stock phrases, excessive CTAs, and a missing sign-off (only when your brand kit or site sets one). Pass trigger_event_name or event_keys to also check that each merge tag has data behind it.',
         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'),
@@ -3188,20 +3209,20 @@ Return ONLY valid JSON with this exact shape:
         if (footerTemplate !== null) {
             const footerError = validateUnsubFooterTemplate(footerTemplate);
             if (footerError)
-                return j({ error: footerError, code: 'INVALID_FIELD' });
+                return j({ error: footerError, code: 'validation_failed' });
         }
         const sendClass = send_class ?? 'broadcast';
         const targeting = {};
         const triggerInput = { trigger_event_name, trigger_tag, trigger_type, trigger_config };
         const targetingError = await applyCampaignTargetingFields(targeting, triggerInput, getProjectId());
         if (targetingError)
-            return j({ error: targetingError, code: 'INVALID_FIELD' });
+            return j({ error: targetingError, code: 'validation_failed' });
         const triggerConfig = normalizeTriggerConfig(targeting.trigger_config);
         const hasEventOrTag = Boolean(targeting.trigger_event_name || targeting.trigger_tag || triggerConfig.events.length || triggerConfig.tags.length);
         const campaignType = type === 'sequence' && hasEventOrTag ? 'triggered' : type;
         const reentry = resolveCampaignReentry({ reentry_mode, period_key }, { type: campaignType, trigger_type: targeting.trigger_type });
         if (!reentry.ok)
-            return j({ error: reentry.error, code: 'INVALID_FIELD' });
+            return j({ error: reentry.error, code: 'validation_failed' });
         if (reentry.period_key !== undefined)
             targeting.period_key = reentry.period_key;
         const canActivateOnTrigger = campaignType === 'triggered' && (hasEventOrTag || targeting.trigger_type === 'date_field' || targeting.trigger_type === 'contact_event');
@@ -3512,7 +3533,7 @@ Return ONLY valid JSON with this exact shape:
             openWorldHint: false,
         },
         description: 'Remove a step from a campaign. Only allowed on draft campaigns.',
-        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'), step_id: z.string().uuid() },
+        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'), step_id: z.string().uuid() },
     }, withApproval('delete_campaign_step', async ({ step_id }) => {
         const projectId = getProjectId();
         const { data: step } = await db()
@@ -3550,7 +3571,7 @@ Return ONLY valid JSON with this exact shape:
             openWorldHint: false,
         },
         description: 'Permanently delete a campaign. Campaign must not be active — pause it first. Deletes all steps and enrollments.',
-        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'), campaign_id: z.string().uuid() },
+        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'), campaign_id: z.string().uuid() },
     }, withApproval('delete_campaign', async ({ campaign_id }) => {
         const projectId = getProjectId();
         const { data: campaign, error: fetchErr } = await db()
@@ -3593,7 +3614,7 @@ Return ONLY valid JSON with this exact shape:
             return j(result.error ? result : { ...result, ...await campaignTriggerOutput(result) });
         }
         if (!args.campaign_id)
-            return j({ error: 'campaign_id is required', code: 'INVALID_FIELD' });
+            return j({ error: 'campaign_id is required', code: 'validation_failed' });
         const projectId = getProjectId();
         const { data: existing, error: loadError } = await db().from('campaigns')
             .select(TRIGGER_EDIT_SELECT)
@@ -3608,14 +3629,14 @@ Return ONLY valid JSON with this exact shape:
         const hasFields = ['trigger_event_name', 'trigger_tag', 'trigger_type', 'trigger_config', 'reentry_mode', 'period_key']
             .some((key) => args[key] !== undefined);
         if ((!args.clear && !hasFields) || (args.clear && hasFields)) {
-            return j({ error: 'Provide trigger fields or clear=true, exclusively', code: 'INVALID_FIELD' });
+            return j({ error: 'Provide trigger fields or clear=true, exclusively', code: 'validation_failed' });
         }
         const updates = {};
         const targetingError = await applyCampaignTargetingFields(updates, args.clear
             ? { trigger_type: 'manual', trigger_event_name: null, trigger_tag: null, trigger_config: null }
             : args, projectId, existing);
         if (targetingError)
-            return j({ error: targetingError, code: 'INVALID_FIELD' });
+            return j({ error: targetingError, code: 'validation_failed' });
         const normalized = normalizeTriggerConfig(updates.trigger_config);
         if (existing.status === 'draft' && existing.type === 'sequence'
             && (updates.trigger_event_name || updates.trigger_tag || normalized.events.length || normalized.tags.length)) {
@@ -3626,7 +3647,7 @@ Return ONLY valid JSON with this exact shape:
             trigger_type: (updates.trigger_type ?? existing.trigger_type),
         });
         if (!reentry.ok)
-            return j({ error: reentry.error, code: 'INVALID_FIELD' });
+            return j({ error: reentry.error, code: 'validation_failed' });
         if (reentry.period_key !== undefined)
             updates.period_key = reentry.period_key;
         const result = await finishCampaignEdit('set_campaign_trigger', args, existing, updates, params => requestApproval('set_campaign_trigger', params));
@@ -3670,11 +3691,11 @@ Return ONLY valid JSON with this exact shape:
         }
         const { campaign_id, name, site_id, segment_id, send_at, topic, trigger_event_name, trigger_tag, trigger_type, trigger_config, type, sends_per_hour, send_in_contact_timezone, send_class, unsub_footer_template, reentry_mode, period_key } = input;
         if (!campaign_id)
-            return j({ error: 'campaign_id is required', code: 'INVALID_FIELD' });
+            return j({ error: 'campaign_id is required', code: 'validation_failed' });
         if (unsub_footer_template !== undefined && unsub_footer_template !== null) {
             const footerError = validateUnsubFooterTemplate(unsub_footer_template);
             if (footerError)
-                return j({ error: footerError, code: 'INVALID_FIELD' });
+                return j({ error: footerError, code: 'validation_failed' });
         }
         const projectId = getProjectId();
         let campaignType;
@@ -3709,9 +3730,9 @@ Return ONLY valid JSON with this exact shape:
                 return j({ error: 'Campaign not found', code: 'NOT_FOUND' });
             if (type !== existing.type) {
                 if (existing.status !== 'draft')
-                    return j({ error: `type can only be changed while the campaign is a draft (this one is ${existing.status})`, code: 'INVALID_FIELD' });
+                    return j({ error: `type can only be changed while the campaign is a draft (this one is ${existing.status})`, code: 'validation_failed' });
                 if (existing.type !== 'sequence' && existing.type !== 'triggered')
-                    return j({ error: `a ${existing.type} campaign cannot become ${type}`, code: 'INVALID_FIELD' });
+                    return j({ error: `a ${existing.type} campaign cannot become ${type}`, code: 'validation_failed' });
             }
         }
         const hasTriggerUpdate = reentry_mode !== undefined || period_key !== undefined || trigger_event_name !== undefined || trigger_tag !== undefined || trigger_type !== undefined || trigger_config !== undefined;
@@ -3733,7 +3754,7 @@ Return ONLY valid JSON with this exact shape:
             updates.type = type;
         const scheduleError = applyCampaignSendAtField(updates, send_at, campaignType);
         if (scheduleError)
-            return j({ error: scheduleError, code: 'INVALID_FIELD' });
+            return j({ error: scheduleError, code: 'validation_failed' });
         if (topic !== undefined)
             updates.topic = topic;
         if (sends_per_hour !== undefined)
@@ -3746,7 +3767,7 @@ Return ONLY valid JSON with this exact shape:
             updates.unsub_footer_template = unsub_footer_template?.trim() ?? null;
         const targetingError = await applyCampaignTargetingFields(updates, { trigger_event_name, trigger_tag, trigger_type, trigger_config, segment_id }, projectId, existingCampaignForTargeting);
         if (targetingError)
-            return j({ error: targetingError, code: targetingError === 'Segment not found' ? 'NOT_FOUND' : 'INVALID_FIELD' });
+            return j({ error: targetingError, code: targetingError === 'Segment not found' ? 'NOT_FOUND' : 'validation_failed' });
         // If type was not explicitly changed, but this update sets an event trigger on a draft sequence,
         // normalize type to 'triggered' so that event intake matches and enrolls it (#3852).
         if (type === undefined && existingCampaignForTargeting?.type === 'sequence' && existingCampaignForTargeting?.status === 'draft') {
@@ -3762,7 +3783,7 @@ Return ONLY valid JSON with this exact shape:
             trigger_type: (updates.trigger_type ?? existingCampaignForTargeting?.trigger_type),
         });
         if (!reentry.ok)
-            return j({ error: reentry.error, code: 'INVALID_FIELD' });
+            return j({ error: reentry.error, code: 'validation_failed' });
         if (reentry.period_key !== undefined)
             updates.period_key = reentry.period_key;
         let data;

package/build/tools/contacts.js

@@ -607,7 +607,7 @@ export function registerContactTools(server) {
         description: 'Record a contact event through POST /api/v1/events and enroll matching active triggered campaigns. Can start real sends; requires standard approval. Returns the REST outcome and sendability unchanged. Does not subscribe the contact or update contact properties.',
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Call once to request approval, then repeat the same arguments with the approved approval_id.'),
+            approval_id: z.string().uuid().optional().describe('Call once to request approval, then call again with only approval_id.'),
             email: z.string().email(),
             event: z.string().trim().min(1),
             data: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
@@ -659,7 +659,7 @@ export function registerContactTools(server) {
         description: 'Identify or update a contact through the v1 identify API. Optional signup/customer consent subscribes new or existing contacts without overriding opt-outs. Customer consent requires a topic; consent requires site_id. Without consent, site_id retains legacy create-only subscription behavior and returns a warning.',
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Call once to request approval, then repeat the same arguments with the approved approval_id.'),
+            approval_id: z.string().uuid().optional().describe('Call once to request approval, then call again with only approval_id.'),
             email: z.string().email(),
             first_name: z.string().optional(),
             last_name: z.string().optional(),
@@ -1212,7 +1212,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
         },
         description: 'Delete a saved subscriber view owned by the current project.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             view_id: z.string().uuid(),
         },
     }, withApproval('delete_subscriber_view', async ({ view_id }) => {
@@ -1461,7 +1461,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
         },
         description: 'Bulk import contacts and subscribe them to a site. Max 200 per call.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             contacts: z.array(z.object({
                 email: z.string().email(),
                 first_name: z.string().optional(),
@@ -1711,7 +1711,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             idempotentHint: true,
             openWorldHint: false,
         },
-        description: 'List contacts filtered by engagement score range and/or lifecycle stage. Useful for building re-engagement campaigns or identifying high-value contacts.',
+        description: 'List contacts using a saved segment_id or inline filters for engagement score, lifecycle stage, site and company. Saved segment_id and inline filters are mutually exclusive. Useful for building re-engagement campaigns or identifying high-value contacts.',
         inputSchema: {
             segment_id: z.string().uuid().optional().describe('Saved segment; mutually exclusive with inline audience filters'),
             lifecycle_stage: z.enum(['new', 'active', 'cooling', 'cold', 'churned', 'lead', 'trial', 'customer', 'win-back']).optional(),
@@ -2222,7 +2222,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
         },
         description: 'Merge custom_properties into many contacts at once. Same merge semantics as update_subscriber, applied across a batch.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             contact_ids: z.array(z.string().uuid()).min(1),
             custom_properties: z.record(z.string(), z.unknown()).describe('Merged into each contact\'s existing custom_properties; a key set to null deletes that key'),
         },
@@ -2521,9 +2521,9 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             idempotentHint: false,
             openWorldHint: false,
         },
-        description: 'Remove an email address from the suppression list. Requires human approval: the first call returns an approve_url and does nothing; call again with the same arguments plus approval_id once approved.',
+        description: 'Remove an email address from the suppression list. Requires human approval: the first call returns an approve_url and does nothing; call again with only approval_id once approved.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             email: z.string().email(),
         },
     }, withApproval('remove_suppression', async ({ email }) => {
@@ -2907,7 +2907,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
         title: 'Delete Custom Field',
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
         description: 'Delete a custom field definition without deleting existing contact values stored under that key.',
-        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'), id: z.string().uuid() },
+        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'), id: z.string().uuid() },
     }, withApproval('delete_custom_field', async ({ id }) => {
         const projectId = getProjectId();
         const { data, error } = await db()

package/build/tools/content.js

@@ -259,7 +259,7 @@ export function registerContentTools(server) {
             openWorldHint: false,
         },
         description: 'Delete a reusable content block.',
-        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'), block_id: z.string().uuid() },
+        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'), block_id: z.string().uuid() },
     }, withApproval('delete_content_block', async ({ block_id }) => {
         const { error } = await db().from('content_blocks').delete().eq('project_id', getProjectId()).eq('id', block_id);
         if (error)
@@ -319,7 +319,7 @@ export function registerContentTools(server) {
         },
         description: 'Ingest a blog post (written by your AI/agent) into Sendinel. By default it lands as a draft in the review queue. For a trusted, hands-off flow, set auto_publish=true with publish_to (a destination name or id from list_blog_destinations) to skip review and publish to the user\'s own site — now, or at scheduled_at. Only title is required; everything else is optional.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             title: z.string().min(1).max(300),
             body: z.string().optional(),
             excerpt: z.string().max(1000).optional(),

package/build/tools/data.js

@@ -563,7 +563,7 @@ export function registerDataTools(server) {
         },
         description: 'Disconnect an external platform connection for the current project organization and remove stored credentials.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             org_id: z.string().uuid().optional(),
             platform: z.enum(CONNECTED_PLATFORMS).optional(),
             connection_id: z.string().uuid().optional(),
@@ -980,7 +980,7 @@ export function registerDataTools(server) {
         },
         description: 'Create an API key and return the secret once.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             name: z.string().min(1),
             slug: z.string().optional(),
             scopes: z.array(z.string()).optional().default(['read']),
@@ -1010,7 +1010,7 @@ export function registerDataTools(server) {
             openWorldHint: false,
         },
         description: 'Revoke an API key.',
-        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'), key_id: z.string().uuid() },
+        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'), key_id: z.string().uuid() },
     }, withApproval('revoke_api_key', async ({ key_id }) => {
         const { error } = await db().from('api_keys').update({ revoked_at: new Date().toISOString() }).eq('project_id', getProjectId()).eq('id', key_id);
         if (error)
@@ -1198,7 +1198,7 @@ export function registerDataTools(server) {
         },
         description: 'Export all tenant data classes for portability. Returns inline data for small exports or a signed archive URL for large exports.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             siteId: z.string().uuid(),
             format: z.enum(['json', 'csv']).optional().default('json'),
         },

package/build/tools/delivery-ops.js

@@ -7,6 +7,7 @@ import { assertChannelCanExecute, checkApproval, currentChannelContext, requestA
 import { callSendinelV1 } from '../lib/v1-client.js';
 import { getProjectId } from '../project.js';
 import { dbToolError, toolError } from '../lib/db-error.js';
+import { readLatestStoredDomainHealth, storedDomainDns, storedDnsReasons } from '../lib/domain-health.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
 function asRecord(value) {
     return value && typeof value === 'object' ? value : {};
@@ -146,7 +147,7 @@ export function registerDeliveryOpsTools(server) {
             idempotentHint: true,
             openWorldHint: false,
         },
-        description: 'Returns stored SPF/DKIM/DMARC from the latest health check; does NOT query DNS live. Use recheck_domain_dns for a live re-check.',
+        description: 'Returns stored SPF/DKIM/DMARC from the latest health check, with verification_source=stored_domain_health and checked_at; does NOT query DNS live. Use recheck_domain_dns for a live re-check.',
         inputSchema: { domain_id: z.string().uuid() },
     }, async ({ domain_id }) => {
         const { data, error } = await db().from('domains')
@@ -158,22 +159,10 @@ export function registerDeliveryOpsTools(server) {
             return toolError(dbToolError(error, 'Unable to load domain'));
         if (!data)
             return toolError({ error: 'Domain not found', code: 'NOT_FOUND' });
-        const { data: health, error: healthError } = await db().from('domain_health')
-            .select('spf_valid, dkim_valid, dmarc_valid, sites!inner(domain_id)')
-            .eq('sites.project_id', getProjectId())
-            .eq('sites.domain_id', domain_id)
-            .order('check_date', { ascending: false })
-            .limit(1)
-            .maybeSingle();
+        const { data: health, error: healthError } = await readLatestStoredDomainHealth(domain_id);
         if (healthError)
             return toolError(dbToolError(healthError, 'Unable to load domain health'));
-        const spf = health?.spf_valid ?? null;
-        const dkim = health?.dkim_valid ?? null;
-        const dmarc = health?.dmarc_valid ?? null;
-        const allVerified = [spf, dkim, dmarc].every((value) => typeof value === 'boolean')
-            ? Boolean(spf && dkim && dmarc)
-            : null;
-        return j({ spf, dkim, dmarc, all_verified: allVerified });
+        return j(storedDomainDns(health));
     });
     server.registerTool('recheck_domain_dns', {
         title: 'Recheck Domain DNS Live',
@@ -546,7 +535,7 @@ export function registerDeliveryOpsTools(server) {
         },
         description: 'Re-enter dead-lettered campaign enrollments into active sending, which can cause real emails to send on the next queue tick. Call once without confirmed to preview the matched count, then call again with confirmed=true to replay them.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             site_id: z.string().uuid(),
             max_count: z.number().int().min(1).max(1000).default(100).optional(),
             failed_after: z.string().datetime().optional(),
@@ -802,7 +791,7 @@ export function registerDeliveryOpsTools(server) {
             idempotentHint: true,
             openWorldHint: false,
         },
-        description: 'List sending domains with Sendinel readiness (ready true/false/null, reasons, provider_detail). Raw provider values, including EE tracking_status_raw, are labelled detail only and do not drive readiness.',
+        description: 'List sending domains with stored domain_health DNS observations and Sendinel readiness (ready true/false/null, reasons, provider_detail). Registration status, provider and verified_at remain saved metadata; unknown DNS never implies ready. Raw provider values, including EE tracking_status_raw, are labelled detail only.',
         inputSchema: { site_id: z.string().uuid().optional() },
     }, async ({ site_id }) => {
         const projectId = getProjectId();
@@ -829,9 +818,20 @@ export function registerDeliveryOpsTools(server) {
             return j(dbToolError(error));
         if (!data)
             return j({ error: 'Domain query returned no result' });
-        return j({ domains: data.map((domain) => ({
-                ...domain, readiness: computeDomainReadiness(domain),
-            })), count: data.length });
+        const domains = [];
+        for (const domain of data) {
+            const { data: health, error: healthError } = await readLatestStoredDomainHealth(domain.id);
+            if (healthError)
+                return toolError(dbToolError(healthError, 'Unable to load domain health'));
+            const dns = storedDomainDns(health);
+            const readiness = computeDomainReadiness(domain);
+            const auth = [dns.spf, dns.dkim, dns.dmarc];
+            readiness.ready = readiness.ready === false || auth.includes(false) ? false
+                : readiness.ready === null || auth.includes(null) ? null : true;
+            readiness.reasons.push(...storedDnsReasons(dns));
+            domains.push({ ...domain, dns, readiness });
+        }
+        return j({ domains, count: domains.length });
     });
     server.registerTool('register_domain', {
         title: 'Register Domain',

package/build/tools/landing-pages.js

@@ -172,7 +172,7 @@ export function registerLandingPageTools(server) {
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
         description: 'Update a landing page. Setting status to published stamps published_at; pass site_id or form_id as null to clear it.',
         inputSchema: {
-            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'),
+            approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             page_id: z.string().uuid(),
             title: z.string().trim().min(1).max(200).optional(),
             slug: z.string().trim().regex(SLUG_RE, 'Lowercase alphanumeric + hyphens, max 63 chars').optional(),
@@ -265,7 +265,7 @@ export function registerLandingPageTools(server) {
         title: 'Delete Landing Page',
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
         description: 'Permanently delete a landing page. Set status to archived instead to unpublish without deleting.',
-        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'), page_id: z.string().uuid() },
+        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'), page_id: z.string().uuid() },
     }, withApproval('delete_landing_page', async ({ page_id }) => {
         const projectId = getProjectId();
         const { error } = await db()

package/build/tools/lists.js

@@ -186,7 +186,7 @@ export function registerListTools(server) {
         title: 'Delete Contact List',
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
         description: 'Permanently delete a static contact list and its memberships.',
-        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with the same arguments plus this approval_id to run the action.'), list_id: z.string().uuid() },
+        inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'), list_id: z.string().uuid() },
     }, withApproval('delete_list', async ({ list_id }) => {
         const projectId = getProjectId();
         const { error } = await db()