@sendinel/mcp-server 1.0.100 → 1.0.102

package/build/lib/send-audience.d.ts

@@ -9,7 +9,11 @@ import { type SegmentRules } from '@sendinel/domain';
  * Every read throws on failure: an unknown audience must never read as "nobody" or "everyone".
  */
 export type SendClass = 'broadcast' | 'product';
-/** Contact ids matching segment rules (same semantics as the segments tools and the dashboard). */
+/**
+ * Contact ids matching segment rules (same semantics as the segments tools and the dashboard).
+ * Throws SegmentRulesError for invalid rules (#4270): a malformed rule never widens to everyone,
+ * and `{ match_all: true }` is the only way to ask for every contact.
+ */
 export declare function resolveSegmentContactIds(projectId: string, rules: SegmentRules): Promise<string[]>;
 export type SendAudience = {
     /** People the send will enroll. */

package/build/lib/send-audience.js

@@ -15,9 +15,15 @@ async function loadFieldTypes(projectId) {
     }
     return fields;
 }
-/** Contact ids matching segment rules (same semantics as the segments tools and the dashboard). */
+/**
+ * Contact ids matching segment rules (same semantics as the segments tools and the dashboard).
+ * Throws SegmentRulesError for invalid rules (#4270): a malformed rule never widens to everyone,
+ * and `{ match_all: true }` is the only way to ask for every contact.
+ */
 export async function resolveSegmentContactIds(projectId, rules) {
     const tree = normalizeSegmentRulesToTree(rules);
+    if (tree.match_none)
+        return [];
     const fieldTypes = rules.custom_property ? await loadFieldTypes(projectId) : {};
     const q = buildSegmentBaseQuery(db(), projectId);
     const { query: filtered, siteContactIds } = await applySegmentRules(q, rules, db(), projectId, fieldTypes);

package/build/tools/analytics.js

@@ -1,3 +1,4 @@
+import { readPeriodCampaigns, campaignPeriodFields } from "@sendinel/domain";
 import { isTrueConversionEvent, TRUE_CONVERSION_DEFINITION } from "@sendinel/domain";
 import { percentRate, groupMetricRows, readRevenue, isComplainedRow, isOpenedRow, countPeople, isClickedRow, summarizeEmailRows, countEmailRows, isDeliveredRow, isBouncedRow, fetchAllRows, readAllRows } from "@sendinel/domain";
 import { z } from 'zod';
@@ -851,9 +852,10 @@ export function registerAnalyticsTools(server) {
             days: z.number().int().min(1).max(365).optional().describe('Lookback period in days, default 30'),
             site_id: z.string().uuid().optional(),
             campaign_id: z.string().uuid().optional(),
+            period: z.string().min(1).optional().describe('Return one enrollment period in by_period; existing totals keep their date window.'),
             group_by: z.enum(['campaign', 'site', 'company', 'day', 'week']).optional(),
         },
-    }, async ({ days = 30, site_id, campaign_id, group_by }) => {
+    }, async ({ days = 30, site_id, campaign_id, group_by, period }) => {
         const projectId = getProjectId();
         const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
         let q = db()
@@ -868,20 +870,28 @@ export function registerAnalyticsTools(server) {
         const { data: logs, error } = await q;
         if (error)
             return txt(`Error: ${error.message}`);
+        let periodCampaigns;
+        try {
+            periodCampaigns = campaign_id || group_by === 'campaign' ? await readPeriodCampaigns(db(), projectId, { siteId: site_id, campaignId: campaign_id, start: since }) : new Map();
+        }
+        catch {
+            return txt("Error: Could not load results by period.");
+        }
+        const selectedFields = (id) => campaignPeriodFields(periodCampaigns.get(id)?.result, period);
         const rows = logs ?? [];
-        if (!rows.length)
+        if (!rows.length && !periodCampaigns.size)
             return j({ message: `No email activity in the last ${days} days.`, total: 0 });
         const { data: attributionRows, error: attributionError } = await readRevenue({ sb: db(), projectId, siteId: site_id, campaignId: campaign_id, start: since });
         if (attributionError)
             return txt(`Error: ${attributionError.message}`);
         const scopedAttributionRows = attributionRows ?? [];
-        const computeMetrics = (set) => {
-            const total = set.length;
-            const delivered = set.filter(isDeliveredRow).length;
-            const opened = countPeople(set, isOpenedRow);
-            const clicked = countPeople(set, isClickedRow);
-            const bounced = set.filter(isBouncedRow).length;
-            const complained = set.filter(isComplainedRow).length;
+        const computeMetrics = (set, counts) => {
+            const total = counts?.sent ?? set.length;
+            const delivered = counts?.delivered ?? set.filter(isDeliveredRow).length;
+            const opened = counts?.opened ?? countPeople(set, isOpenedRow);
+            const clicked = counts?.clicked ?? countPeople(set, isClickedRow);
+            const bounced = counts?.bounced ?? set.filter(isBouncedRow).length;
+            const complained = counts?.complained ?? set.filter(isComplainedRow).length;
             return {
                 total_sent: total, delivered, opened, clicked, bounced, complained,
                 delivery_rate: total > 0 ? `${percentRate(delivered, total, 1)?.toFixed(1)}%` : 'N/A',
@@ -892,7 +902,7 @@ export function registerAnalyticsTools(server) {
                 click_to_open: opened > 0 ? `${percentRate(clicked, opened, 1)?.toFixed(1)}%` : 'N/A',
             };
         };
-        const overall = computeMetrics(rows);
+        const overall = computeMetrics(rows, campaign_id ? periodCampaigns.get(campaign_id)?.result.totals : undefined);
         const trueConversionAnalytics = buildTrueConversionAnalytics({
             logs: rows,
             attributionRows: scopedAttributionRows,
@@ -913,9 +923,13 @@ export function registerAnalyticsTools(server) {
                     byKey[key] = [];
                 byKey[key].push(r);
             });
+            if (group_by === 'campaign')
+                for (const id of periodCampaigns.keys())
+                    byKey[id] ??= [];
             grouped = Object.entries(byKey).map(([id, set]) => ({
                 [`${group_by}_id`]: id,
-                ...computeMetrics(set),
+                ...computeMetrics(set, group_by === 'campaign' ? periodCampaigns.get(id)?.result.totals : undefined),
+                ...(group_by === 'campaign' ? selectedFields(id) : {}),
             })).sort((a, b) => b.total_sent - a.total_sent);
         }
         else if (group_by === 'company') {
@@ -987,6 +1001,7 @@ export function registerAnalyticsTools(server) {
         return j({
             period: `Last ${days} days`,
             overall,
+            ...(campaign_id ? selectedFields(campaign_id) : {}),
             true_conversion_analytics: trueConversionAnalytics,
             best_send_times_utc: bestHours,
             trend_vs_prior_period: trend,

package/build/tools/campaigns.js

@@ -1,7 +1,8 @@
+import { readCampaignPeriods, campaignPeriodFields } from "@sendinel/domain";
 import { CAMPAIGN_BRANCH_CONDITIONS, campaignBranchConditionValue, isContactPropertyConditionList, STEP_PROPERTY_CONDITIONS_ERROR, validateStepPropertyRules } from "@sendinel/domain";
 import { z } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
-import { assertSendAccepted, providerSendError, sendError, SendRefusedError, BLOCKING_CONTENT_ISSUE_KINDS, computeSendContentKey, findContentIssues, sendingHostOf, NAME_FALLBACKS, ONE_SEND_MATCH_STATUSES, ONE_SEND_SENT_STATUSES, ONE_SEND_WINDOW_DAYS, normalizeTriggerConfig, renderTemplateString as renderTemplateVars, resolveBrandTokens, brandWarnings, readAllRows, } from '@sendinel/domain';
+import { assertSendAccepted, providerSendError, sendError, SendRefusedError, BLOCKING_CONTENT_ISSUE_KINDS, computeSendContentKey, findContentIssues, sendingHostOf, NAME_FALLBACKS, ONE_SEND_MATCH_STATUSES, ONE_SEND_SENT_STATUSES, ONE_SEND_WINDOW_DAYS, normalizeTriggerConfig, renderTemplateString as renderTemplateVars, resolveBrandTokens, brandWarnings, readAllRows, isSegmentRulesError, scopeSegmentRulesToSite, SegmentRulesError, validateSegmentRules, } from '@sendinel/domain';
 // Subpath import, not the barrel above -- reply-actions.ts uses node:crypto,
 // and MCP-server-side that's fine (this never runs in an Edge Function), but
 // keeping it off the shared barrel avoids re-creating the Edge-Function
@@ -14,7 +15,7 @@ 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 { resolveSendAudience } from '../lib/send-audience.js';
+import { resolveSegmentContactIds, resolveSendAudience } from '../lib/send-audience.js';
 import { generateEmailFromBrief, parseAudienceRules } from '../lib/email-generation.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
 import { assertUsableStopReason } from '@sendinel/domain';
@@ -643,13 +644,14 @@ export function registerCampaignTools(server) {
         description: 'List campaigns, optionally filtered by site and/or status',
         inputSchema: {
             site_id: z.string().uuid().optional(),
+            period: z.string().min(1).optional().describe("Return one enrollment period in by_period; totals remain all-time."),
             status: z.enum(['draft', 'active', 'paused', 'completed', 'archived']).optional(),
             limit: z.number().int().min(1).max(100).optional().default(25),
         },
-    }, async ({ site_id, status, limit }) => {
+    }, async ({ site_id, status, limit, period }) => {
         let q = db()
             .from('campaigns')
-            .select('id, site_id, name, type, status, sends_per_hour, 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, period_key')
             .eq('project_id', getProjectId())
             .order('created_at', { ascending: false })
             .limit(limit ?? 25);
@@ -664,10 +666,16 @@ 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 withPeople = rows.map((row) => ({
-            ...row,
-            unique_opened: engagement.ok ? engagement.opened.get(row.id) ?? 0 : null,
-            unique_clicked: engagement.ok ? engagement.clicked.get(row.id) ?? 0 : null,
+        const withPeople = await Promise.all(rows.map(async (row) => {
+            const periods = await readCampaignPeriods(db(), getProjectId(), row);
+            const { period_key: _periodKey, ...legacy } = row;
+            return {
+                ...legacy,
+                ...campaignPeriodFields(periods, period),
+                ...(periods?.totals ? { total_sent: periods.totals.sent } : {}),
+                unique_opened: periods?.totals?.opened ?? (engagement.ok ? engagement.opened.get(row.id) ?? 0 : null),
+                unique_clicked: periods?.totals?.clicked ?? (engagement.ok ? engagement.clicked.get(row.id) ?? 0 : null),
+            };
         }));
         return { content: [{ type: 'text', text: JSON.stringify(withPeople, null, 2) }] };
     });
@@ -1156,10 +1164,7 @@ export function registerCampaignTools(server) {
             .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 rules = scopeSegmentRulesToSite(segment.rules, segment.site_id);
         // #3669: the same audience rules as send_broadcast and the dashboard: paged, signed up to this
         // sender, consent gate applied. The count shown is the count enrolled.
         let audience;
@@ -1167,6 +1172,9 @@ export function registerCampaignTools(server) {
             audience = await resolveSendAudience(projectId, site_id, rules);
         }
         catch (error) {
+            // #4270: a malformed segment enrolls nobody and says why.
+            if (isSegmentRulesError(error))
+                return j({ error: error.message, code: 'INVALID_SEGMENT_RULES', errors: error.errors });
             return j({ error: `Could not load this audience: ${error instanceof Error ? error.message : String(error)}`, code: 'AUDIENCE_LOOKUP_FAILED' });
         }
         const contactIds = audience.contactIds;
@@ -1415,7 +1423,7 @@ export function registerCampaignTools(server) {
                 return j({ error: segmentErr.message, code: 'SEGMENT_LOOKUP_FAILED' });
             if (!segment)
                 return j({ error: 'Segment not found', code: 'SEGMENT_NOT_FOUND' });
-            rules = { ...(segment.rules ?? {}), ...(segment.site_id ? { site_id: segment.site_id } : {}) };
+            rules = scopeSegmentRulesToSite(segment.rules, segment.site_id);
             segmentName = segment.name;
         }
         else {
@@ -1433,6 +1441,9 @@ export function registerCampaignTools(server) {
             resolved = await resolveSendAudience(projectId, site.id, rules, sendClass);
         }
         catch (error) {
+            // #4270: malformed segment or parsed audience rules send to nobody and say why.
+            if (isSegmentRulesError(error))
+                return j({ error: error.message, code: 'INVALID_SEGMENT_RULES', errors: error.errors, rules });
             return j({ error: `Could not load this audience: ${error instanceof Error ? error.message : String(error)}`, code: 'AUDIENCE_LOOKUP_FAILED' });
         }
         if (resolved.contactIds.length === 0) {
@@ -1876,6 +1887,10 @@ Adapt your tone accordingly:
         async function launchFromPlan(plan) {
             let segId = segment_id;
             if (segment_description) {
+                // #4270: never save a segment from rules the segment engine can't use.
+                const rulesCheck = validateSegmentRules(plan.rules);
+                if (!rulesCheck.ok)
+                    return txt(`Error: Could not use the audience rules. ${rulesCheck.errors[0]} Nothing was created.`);
                 const { data: seg, error: segErr } = await db()
                     .from('segments')
                     .insert({ project_id: projectId, name: plan.segment_name, description: segment_description, rules: plan.rules })
@@ -1998,8 +2013,22 @@ Adapt your tone accordingly:
                 q = q.lte(column, rule.before);
             return q;
         }
-        // Helper to get segment contact IDs (simplified inline)
+        // Helper to get segment contact IDs (simplified inline). #4270: rules are validated first
+        // (SegmentRulesError), and anything this flat helper cannot evaluate (rule trees, markers,
+        // custom_property, company filters, multi-tag) goes through the shared evaluator instead of
+        // being ignored, which used to widen those segments to everyone.
+        const INLINE_RULE_KEYS = new Set([
+            'lifecycle_stage', 'payment', 'min_score', 'max_score', 'source', 'subscribed_after', 'subscribed_before',
+            'has_opened', 'has_clicked', 'tag', 'site_id', 'exclude_suppressed', 'metadata',
+        ]);
         const getContactIds = async (rules) => {
+            const check = validateSegmentRules(rules);
+            if (!check.ok)
+                throw new SegmentRulesError(check.errors);
+            const inlineCanEvaluate = Object.keys(rules).every((key) => rules[key] === undefined || INLINE_RULE_KEYS.has(key))
+                && (rules.tag === undefined || typeof rules.tag === 'string');
+            if (!inlineCanEvaluate)
+                return resolveSegmentContactIds(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);
@@ -2065,7 +2094,14 @@ Adapt your tone accordingly:
             catch {
                 return txt(`Error: Failed to parse segment from "${segment_description}"`);
             }
-            contactIds = await getContactIds(parsedRules);
+            try {
+                contactIds = await getContactIds(parsedRules);
+            }
+            catch (error) {
+                if (isSegmentRulesError(error))
+                    return txt(`Error: Could not use the audience parsed from "${segment_description}". ${error.message}`);
+                throw error;
+            }
             contactCount = contactIds.length;
             segmentName = `${name} — segment`;
         }
@@ -2080,7 +2116,14 @@ Adapt your tone accordingly:
                 return txt('Error: segment not found');
             segmentName = seg.name;
             parsedRules = seg.rules;
-            contactIds = await getContactIds(parsedRules);
+            try {
+                contactIds = await getContactIds(parsedRules);
+            }
+            catch (error) {
+                if (isSegmentRulesError(error))
+                    return txt(`Error: Segment "${seg.name}" has rules that can't be used. ${error.message}`);
+                throw error;
+            }
             contactCount = contactIds.length;
         }
         if (!confirmed) {
@@ -3409,8 +3452,8 @@ Return ONLY valid JSON with this exact shape:
             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 }) => {
+        inputSchema: { campaign_id: z.string().uuid(), period: z.string().min(1).optional().describe("Return results for one enrollment period; totals remain all-time.") },
+    }, async ({ campaign_id, period }) => {
         const projectId = getProjectId();
         const { data: campaign, error: campErr } = await db()
             .from('campaigns')
@@ -3465,6 +3508,7 @@ Return ONLY valid JSON with this exact shape:
         const visibilityError = stepsError ?? enrollError ?? sentError ?? queuedEmailError ?? failedSendError ?? queueError ?? dlqError;
         if (visibilityError)
             return j({ error: visibilityError.message, code: 'CAMPAIGN_VISIBILITY_QUERY_FAILED' });
+        const periods = await readCampaignPeriods(db(), projectId, campaign);
         const outstandingRows = queueRows ?? [];
         const pendingOrRetryRows = outstandingRows.filter((row) => row.status !== 'processing');
         const retryingCount = outstandingRows.filter((row) => row.status === 'retry').length;
@@ -3478,7 +3522,9 @@ Return ONLY valid JSON with this exact shape:
         const unresolvedCount = dlqUnresolvedCount ?? 0;
         return j({
             ...campaign,
-            total_sent: sentCount ?? 0,
+            total_sent: periods?.totals?.sent ?? sentCount ?? 0,
+            ...(periods?.totals ? { unique_opened: periods.totals.opened, unique_clicked: periods.totals.clicked } : {}),
+            ...campaignPeriodFields(periods, period),
             steps: steps ?? [],
             active_enrollments: enrollCount ?? 0,
             send_incomplete: queuedCount > 0 || failedCount > 0 || outstandingRows.length > 0 || unresolvedCount > 0,

package/build/tools/contacts.js

@@ -1,7 +1,7 @@
 import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { CONTACT_ENRICHMENT_PROVIDERS } from '@desler/models';
 import { createContactEnrichmentAdapters, enrichContactFromConnections, } from '@desler/models/contact-enrichment';
-import { buildPreviewAttentionEnvelope, applySegmentRules, ContactPropertyAnomalyLogger, normalizeContactProperties, getAttentionDecision, getContactNeighborhood, getScheduledTouches, findContactDuplicateGroups, readAllPages, readAllRows, chunkIds, } from '@sendinel/domain';
+import { buildPreviewAttentionEnvelope, applySegmentRules, isSegmentRulesError, ContactPropertyAnomalyLogger, normalizeContactProperties, getAttentionDecision, getContactNeighborhood, getScheduledTouches, findContactDuplicateGroups, readAllPages, readAllRows, chunkIds, } from '@sendinel/domain';
 import { z } from 'zod';
 import { callSendinelV1 } from '../lib/v1-client.js';
 import { db, projectClientForWriteback } from '../db.js';
@@ -2103,11 +2103,20 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             q = q.eq('company_id', params.company_id);
         const fieldTypes = params.custom_property ? await loadContactPropertyDefinitions(projectId) : {};
         if (params.custom_property) {
-            ({ query: q } = await applySegmentRules(q, { custom_property: params.custom_property }, db(), projectId, fieldTypes));
+            try {
+                // #4270: the query runs as-is, so a filter it cannot express is an error, not dropped.
+                ({ query: q } = await applySegmentRules(q, { custom_property: params.custom_property }, db(), projectId, fieldTypes, { pushDownOnly: true }));
+            }
+            catch (error) {
+                if (isSegmentRulesError(error))
+                    return txt(`Error: ${error.message}`);
+                throw error;
+            }
         }
         if (params.site_id) {
             // Shared site filter: an inner join, not an id list that overflows past ~350 contacts (#3674).
-            const siteFiltered = await applySegmentRules(q, { site_id: params.site_id }, db(), projectId);
+            // Deliberately everyone on the site, so allowEmpty.
+            const siteFiltered = await applySegmentRules(q, { site_id: params.site_id }, db(), projectId, {}, { allowEmpty: true });
             if (siteFiltered.siteContactIds && siteFiltered.siteContactIds.length === 0)
                 return j({ total: 0, sample: [] });
             q = siteFiltered.query;
@@ -2155,11 +2164,11 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
         if (params.tag)
             countQ = countQ.contains('tags', [params.tag]);
         if (params.custom_property) {
-            ({ query: countQ } = await applySegmentRules(countQ, { custom_property: params.custom_property }, db(), projectId, fieldTypes));
+            ({ query: countQ } = await applySegmentRules(countQ, { custom_property: params.custom_property }, db(), projectId, fieldTypes, { pushDownOnly: true }));
         }
         // The total must count the same site the sample came from (#3674).
         if (params.site_id)
-            ({ query: countQ } = await applySegmentRules(countQ, { site_id: params.site_id }, db(), projectId));
+            ({ query: countQ } = await applySegmentRules(countQ, { site_id: params.site_id }, db(), projectId, {}, { allowEmpty: true }));
         const { count } = await countQ;
         return j({ total: count ?? (data ?? []).length, sample: data ?? [] });
     });

package/build/tools/lists.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, normalizeSegmentRulesToTree, readAllRows, } from '@sendinel/domain';
+import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, isSegmentRulesError, normalizeSegmentRulesToTree, readAllRows, } from '@sendinel/domain';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { logAudit } from '../audit.js';
@@ -28,7 +28,10 @@ async function loadFieldTypes(projectId) {
 }
 async function getSegmentContactIds(rules) {
     const projectId = getProjectId();
+    // Throws SegmentRulesError for invalid rules (#4270) instead of widening to everyone.
     const tree = normalizeSegmentRulesToTree(rules);
+    if (tree.match_none)
+        return [];
     const fieldTypes = rules.custom_property ? await loadFieldTypes(projectId) : {};
     const q = buildSegmentBaseQuery(db(), projectId);
     const { query: filtered, siteContactIds } = await applySegmentRules(q, rules, db(), projectId, fieldTypes);
@@ -357,7 +360,16 @@ export function registerListTools(server) {
         },
     }, async ({ list_id, rules, confirmed, approval_id }) => {
         const projectId = getProjectId();
-        const normalizedRules = normalizeSegmentRulesToTree(rules);
+        let normalizedRules;
+        try {
+            normalizedRules = normalizeSegmentRulesToTree(rules);
+        }
+        catch (rulesError) {
+            // #4270: invalid (or empty) filter rules add nobody and say why. Everyone is { match_all: true }.
+            if (isSegmentRulesError(rulesError))
+                return j({ error: rulesError.message, code: 'INVALID_SEGMENT_RULES', errors: rulesError.errors });
+            throw rulesError;
+        }
         const approvalParams = { list_id, rules: normalizedRules };
         const { data: list, error: listError } = await db()
             .from('contact_lists')

package/build/tools/segments.js

@@ -5,7 +5,7 @@ import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
 import { assertUsableStopReason } from '@sendinel/domain';
-import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, normalizeSegmentRulesToTree, readAllRows, } from '@sendinel/domain';
+import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, isSegmentRulesError, normalizeSegmentRulesToTree, prepareSegmentRulesForStorage, readAllRows, } from '@sendinel/domain';
 async function loadFieldTypes(projectId) {
     const client = db();
     const scoped = typeof client.schema === 'function' ? client.schema('email') : client;
@@ -27,7 +27,10 @@ async function loadFieldTypes(projectId) {
 }
 async function getSegmentContactIds(rules) {
     const projectId = getProjectId();
+    // Throws SegmentRulesError for invalid rules (#4270) instead of widening to everyone.
     const tree = normalizeSegmentRulesToTree(rules);
+    if (tree.match_none)
+        return [];
     const fieldTypes = rules.custom_property ? await loadFieldTypes(projectId) : {};
     // Shared base query (#3084). This used to be hand-written here and omitted
     // is_test / source_deleted_at / the cooled exclusion the dashboard applies,
@@ -53,6 +56,13 @@ async function getSegmentContactIds(rules) {
 }
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
+/**
+ * #4270: invalid segment rules are an error response naming the first problem,
+ * never an audience of everyone. Returns null for any other error.
+ */
+function invalidRules(error) {
+    return isSegmentRulesError(error) ? txt(`Error: ${error.message}`) : null;
+}
 export function registerSegmentTools(server) {
     server.registerTool('create_segment', {
         title: 'Create Segment',
@@ -69,9 +79,19 @@ export function registerSegmentTools(server) {
             rules: z.record(z.string(), z.unknown()).describe('Segment rule tree: {op:"AND"|"OR", conditions:[{field, operator, value}]} or legacy flat rules. Supported fields include lifecycle_stage, engagement_score, source, created_at, last_opened_at, last_clicked_at, introduced_by_subscriber_id, tags, custom_properties.<key>, payment.<key>. tag may be a plain string (one tag) or {values: string[], mode: "any"|"all"} to match several tags at once.'),
         },
     }, async ({ name, description, rules }) => {
+        let storedRules;
+        try {
+            storedRules = prepareSegmentRulesForStorage(rules);
+        }
+        catch (rulesError) {
+            const invalid = invalidRules(rulesError);
+            if (invalid)
+                return invalid;
+            throw rulesError;
+        }
         const { data, error } = await db()
             .from('segments')
-            .insert({ project_id: getProjectId(), name, description, rules: normalizeSegmentRulesToTree(rules) })
+            .insert({ project_id: getProjectId(), name, description, rules: storedRules })
             .select('id, name, description, rules, created_at')
             .single();
         if (error)
@@ -105,7 +125,17 @@ export function registerSegmentTools(server) {
             return txt(`Error: ${error.message}`);
         const segments = [];
         for (const seg of data ?? []) {
-            const ids = await getSegmentContactIds(seg.rules);
+            let ids;
+            try {
+                ids = await getSegmentContactIds(seg.rules);
+            }
+            catch (rulesError) {
+                if (!isSegmentRulesError(rulesError))
+                    throw rulesError;
+                // #4270: one stored segment with invalid rules matches nobody; its count is unknown, not 0.
+                segments.push({ ...seg, contact_count: null, rules_error: rulesError.message });
+                continue;
+            }
             segments.push({ ...seg, contact_count: ids.length });
         }
         return j(segments);
@@ -131,8 +161,17 @@ export function registerSegmentTools(server) {
             updates.name = name;
         if (description !== undefined)
             updates.description = description;
-        if (rules)
-            updates.rules = normalizeSegmentRulesToTree(rules);
+        if (rules) {
+            try {
+                updates.rules = prepareSegmentRulesForStorage(rules);
+            }
+            catch (rulesError) {
+                const invalid = invalidRules(rulesError);
+                if (invalid)
+                    return invalid;
+                throw rulesError;
+            }
+        }
         const { data, error } = await db()
             .from('segments')
             .update(updates)
@@ -199,7 +238,16 @@ export function registerSegmentTools(server) {
         else {
             return txt('Provide either segment_id or rules.');
         }
-        const ids = await getSegmentContactIds(segRules);
+        let ids;
+        try {
+            ids = await getSegmentContactIds(segRules);
+        }
+        catch (rulesError) {
+            const invalid = invalidRules(rulesError);
+            if (invalid)
+                return invalid;
+            throw rulesError;
+        }
         const sample = ids.slice(0, 10);
         let sampleContacts = [];
         if (sample.length) {
@@ -243,9 +291,12 @@ export function registerSegmentTools(server) {
             return txt(`Error: Failed to parse rules from "${description}"`);
         let parsedRules;
         try {
-            parsedRules = normalizeSegmentRulesToTree(JSON.parse(raw.replace(/```json?\n?|```/g, '').trim()));
+            parsedRules = prepareSegmentRulesForStorage(JSON.parse(raw.replace(/```json?\n?|```/g, '').trim()));
         }
-        catch {
+        catch (parseError) {
+            // #4270: parsed rules that are missing or malformed are an error, never "everyone".
+            if (isSegmentRulesError(parseError))
+                return txt(`Error: Could not use the rules parsed from "${description}". ${parseError.message}`);
             return txt(`Error: Failed to parse rules from "${description}"`);
         }
         const ids = await getSegmentContactIds(parsedRules);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendinel/mcp-server",
-  "version": "1.0.100",
+  "version": "1.0.102",
   "description": "AI-controlled email operations control plane for campaigns, contacts, segments, analytics, and multi-provider sending via MCP.",
   "mcpName": "ai.sendinel/mcp-server",
   "type": "module",