@sendinel/mcp-server 1.0.173 → 1.0.175

package/build/lib/action-approvals.js

@@ -382,7 +382,7 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
         throw new Error(`Failed to create approval request: ${error.message}`);
     let projectName;
     let sandboxDisplayRead = false;
-    const sandboxApproved = !(effective.applied && (effective.level === 'ask_every_time' || effective.class === 'F')) && tier === 'gated' && await trySandboxApproval(data.id, getProjectId(), action, approvalPayloadHash(action, frozenParams), name => { projectName = name; sandboxDisplayRead = true; });
+    const sandboxApproved = !(effective.applied && (effective.level === 'ask_every_time' || (effective.class === 'F' && !action.startsWith('delete_')))) && await trySandboxApproval(data.id, getProjectId(), action, approvalPayloadHash(action, frozenParams), name => { projectName = name; sandboxDisplayRead = true; }, frozenParams);
     if (isTesterRequest(action))
         await logTesterRequestAudit('tester_request', action, data.id, null);
     fireWebhookEvent('approval.requested', {
@@ -534,8 +534,8 @@ async function checkApprovalState(approvalId, options = {}) {
         return { approved: false, status: 'human_decision_required' };
     }
     const sandboxDecision = data.decided_via === 'sandbox';
-    if (data.status === 'approved' && sandboxDecision && (data.project_id !== getProjectId() || data.tier !== 'gated' || PROTECTED_ACTIONS.has(data.action) ||
-        !await sandboxApprovalEligible(getProjectId(), data.action))) {
+    if (data.status === 'approved' && sandboxDecision && (data.project_id !== getProjectId() || !['gated', 'protected'].includes(data.tier) || (data.tier === 'protected' && !['delete_segment', 'delete_subscriber_data'].includes(data.action)) ||
+        !await sandboxApprovalEligible(getProjectId(), data.action, undefined, data.params))) {
         return { approved: false, status: 'sandbox_decision_no_longer_eligible' };
     }
     if (data.status === 'approved' && data.params?.__approval_snapshot?.approval_channel_rule === 'human_only' && !['dashboard', 'chat_confirm'].includes(data.decided_via)) {
@@ -598,7 +598,7 @@ async function checkApprovalState(approvalId, options = {}) {
         approved: true,
         status: 'approved',
         decided_by: claimed.decided_by,
-        ...(options.action && ['send_test_email', 'identify_subscriber', 'emit_contact_event'].includes(options.action) ? { consumed_at: consumedAt } : {}),
+        ...(options.action && ['send_test_email', 'identify_subscriber', 'emit_contact_event', 'delete_campaign'].includes(options.action) ? { consumed_at: consumedAt } : {}),
         ...(sandboxDecision ? { decision_channel: 'sandbox' } : {}),
     };
 }

package/build/lib/mcp-created-items.d.ts

@@ -0,0 +1,28 @@
+/** Table names are the entity types in the service-only provenance ledger. */
+export declare const DELETE_ITEM_TARGETS: {
+    readonly delete_campaign: readonly ['campaigns', 'campaign_id', 'campaign_ids'];
+    readonly delete_campaign_step: readonly ['campaign_steps', 'step_id', 'step_ids'];
+    readonly delete_content_block: readonly ['content_blocks', 'block_id', 'block_ids'];
+    readonly delete_custom_field: readonly ['custom_field_definitions', 'id', 'ids'];
+    readonly delete_landing_page: readonly ['landing_pages', 'page_id', 'page_ids'];
+    readonly delete_list: readonly ['contact_lists', 'list_id', 'list_ids'];
+    readonly delete_segment: readonly ['segments', 'segment_id', 'segment_ids'];
+    readonly delete_signature: readonly ['signature_blocks', 'id', 'ids'];
+    readonly delete_social_post: readonly ['social_posts', 'post_id', 'post_ids'];
+    readonly delete_subscriber_data: readonly ['subscribers', 'contact_id', 'contact_ids'];
+    readonly delete_subscriber_view: readonly ['subscriber_list_views', 'view_id', 'view_ids'];
+    readonly delete_template: readonly ['campaign_templates', 'id', 'ids'];
+    readonly delete_webhook_subscription: readonly ['webhook_subscriptions', 'subscription_id', 'subscription_ids'];
+};
+export type CreatedItemType = typeof DELETE_ITEM_TARGETS[keyof typeof DELETE_ITEM_TARGETS][0];
+/** Only server-authenticated credential identity; never user IDs or tool arguments. */
+export declare function requestingCreatorKey(): string | null;
+/** Insert-only provenance: updates, retries and reconnects must never claim an existing item. */
+export declare function recordCreatedItems(entityType: CreatedItemType, data: any): Promise<void>;
+/** The query must return only newly inserted rows, never the result of an updating upsert. */
+export declare function withCreatedItems<T extends {
+    data: any;
+    error: any;
+}>(entityType: CreatedItemType, query: PromiseLike<T>): Promise<T>;
+/** Unknown actions/targets and partial reads fail closed, including defensive bulk inputs. */
+export declare function ownsDeleteTargets(projectId: string, action: string, params: Record<string, unknown>, creatorKey: string | null): Promise<boolean>;

package/build/lib/mcp-created-items.js

@@ -0,0 +1,101 @@
+import { adminDb, requestContext } from '../db.js';
+import { getProjectId } from '../project.js';
+/** Table names are the entity types in the service-only provenance ledger. */
+export const DELETE_ITEM_TARGETS = {
+    delete_campaign: ['campaigns', 'campaign_id', 'campaign_ids'],
+    delete_campaign_step: ['campaign_steps', 'step_id', 'step_ids'],
+    delete_content_block: ['content_blocks', 'block_id', 'block_ids'],
+    delete_custom_field: ['custom_field_definitions', 'id', 'ids'],
+    delete_landing_page: ['landing_pages', 'page_id', 'page_ids'],
+    delete_list: ['contact_lists', 'list_id', 'list_ids'],
+    delete_segment: ['segments', 'segment_id', 'segment_ids'],
+    delete_signature: ['signature_blocks', 'id', 'ids'],
+    delete_social_post: ['social_posts', 'post_id', 'post_ids'],
+    delete_subscriber_data: ['subscribers', 'contact_id', 'contact_ids'],
+    delete_subscriber_view: ['subscriber_list_views', 'view_id', 'view_ids'],
+    delete_template: ['campaign_templates', 'id', 'ids'],
+    delete_webhook_subscription: ['webhook_subscriptions', 'subscription_id', 'subscription_ids'],
+};
+/** Only server-authenticated credential identity; never user IDs or tool arguments. */
+export function requestingCreatorKey() {
+    const ctx = requestContext();
+    if (ctx?.authKind === 'oauth' && ctx.oauthClientId)
+        return `oauth:${ctx.oauthClientId}`;
+    if (ctx?.authKind === 'api_key' && ctx.keyId)
+        return `apikey:${ctx.keyId}`;
+    return null;
+}
+/** Insert-only provenance: updates, retries and reconnects must never claim an existing item. */
+export async function recordCreatedItems(entityType, data) {
+    const creatorKey = requestingCreatorKey();
+    if (!creatorKey)
+        return;
+    const rows = (Array.isArray(data) ? data : data ? [data] : [])
+        .filter(row => typeof row.id === 'string')
+        .map(row => ({ project_id: getProjectId(), entity_type: entityType, entity_id: row.id, creator_key: creatorKey }));
+    if (!rows.length)
+        return;
+    try {
+        const { error } = await adminDb().schema('email').from('mcp_created_items')
+            .upsert(rows, { onConflict: 'project_id,entity_type,entity_id', ignoreDuplicates: true });
+        if (error)
+            console.warn('MCP creation provenance unavailable; deletion will require human approval.');
+    }
+    catch {
+        // The item already exists. Unknown provenance must stay unknown, never inferred later.
+        console.warn('MCP creation provenance unavailable; deletion will require human approval.');
+    }
+}
+/** The query must return only newly inserted rows, never the result of an updating upsert. */
+export async function withCreatedItems(entityType, query) {
+    const result = await query;
+    if (!result.error)
+        await recordCreatedItems(entityType, result.data);
+    return result;
+}
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Unknown actions/targets and partial reads fail closed, including defensive bulk inputs. */
+export async function ownsDeleteTargets(projectId, action, params, creatorKey) {
+    const target = DELETE_ITEM_TARGETS[action];
+    if (!creatorKey || !target)
+        return false;
+    const [entityType, single, bulk] = target;
+    const source = adminDb().schema('email');
+    let ids = [];
+    if (params[single] !== undefined)
+        ids.push(params[single]);
+    if (params[bulk] !== undefined) {
+        if (!Array.isArray(params[bulk]) || !params[bulk].length)
+            return false;
+        ids.push(...params[bulk]);
+    }
+    // GDPR snapshots carry both ID and email. Verify the address names that same target.
+    if (action === 'delete_subscriber_data' && params.email !== undefined) {
+        if (typeof params.email !== 'string' || !params.email.trim())
+            return false;
+        const { data, error } = await source.from('subscribers').select('id').eq('project_id', projectId)
+            .eq('email', params.email.trim().toLowerCase()).maybeSingle();
+        if (error || !data || (ids.length && (ids.length !== 1 || ids[0] !== data.id)))
+            return false;
+        ids.push(data.id);
+    }
+    if (!ids.length || ids.some(id => typeof id !== 'string' || !uuid.test(id)))
+        return false;
+    ids = [...new Set(ids)];
+    const owns = async (type, targets) => {
+        const { data, error } = await source.from('mcp_created_items').select('entity_id')
+            .eq('project_id', projectId).eq('entity_type', type).eq('creator_key', creatorKey).in('entity_id', targets);
+        return !error && Array.isArray(data) && targets.every(id => data.some(row => row.entity_id === id));
+    };
+    if (!await owns(entityType, ids))
+        return false;
+    // Deleting a campaign also deletes its steps; another client may have added one.
+    if (action === 'delete_campaign') {
+        const { data, error } = await source.from('campaign_steps').select('id').in('campaign_id', ids);
+        if (error || !Array.isArray(data))
+            return false;
+        if (data.length && !await owns('campaign_steps', data.map(row => row.id)))
+            return false;
+    }
+    return true;
+}

package/build/lib/sandbox-approvals.d.ts

@@ -27,5 +27,5 @@ export declare const SANDBOX_ADMIN_SCOPE: {
     readonly tenant_export_full: 'project';
 };
 /** Never consult token claims, BYOD clients or cached display data for this authority. */
-export declare function sandboxApprovalEligible(projectId: string, action: string, onProjectRead?: (name: string | undefined) => void): Promise<boolean>;
-export declare function trySandboxApproval(id: string, projectId: string, action: string, payloadHash: string, onProjectRead?: (name: string | undefined) => void): Promise<boolean>;
+export declare function sandboxApprovalEligible(projectId: string, action: string, onProjectRead?: (name: string | undefined) => void, params?: Record<string, unknown>): Promise<boolean>;
+export declare function trySandboxApproval(id: string, projectId: string, action: string, payloadHash: string, onProjectRead?: (name: string | undefined) => void, params?: Record<string, unknown>): Promise<boolean>;

package/build/lib/sandbox-approvals.js

@@ -1,4 +1,6 @@
 import { adminDb } from '../db.js';
+import { DELETE_ITEM_TARGETS, ownsDeleteTargets, requestingCreatorKey } from './mcp-created-items.js';
+import { approvalClass } from '@sendinel/domain';
 import { PROTECTED_ACTIONS } from './approval-actions.js';
 import { isHumanRequestableAdminTool } from './admin-tools.js';
 /** Conservative classification: shared org credentials and grants require an all-sandbox org. */
@@ -14,8 +16,12 @@ export const SANDBOX_ADMIN_SCOPE = {
     tenant_export_full: 'project',
 };
 /** Never consult token claims, BYOD clients or cached display data for this authority. */
-export async function sandboxApprovalEligible(projectId, action, onProjectRead) {
-    if (PROTECTED_ACTIONS.has(action))
+export async function sandboxApprovalEligible(projectId, action, onProjectRead, params = {}) {
+    const deletion = approvalClass(action) === 'D' || action.startsWith('delete_');
+    // No exception for shared org credentials, unknown delete actions or other protected effects.
+    if (deletion && (!(action in DELETE_ITEM_TARGETS) || !requestingCreatorKey()))
+        return false;
+    if (action === 'delete_provider_credential' || (!deletion && PROTECTED_ACTIONS.has(action)))
         return false;
     try {
         const source = adminDb().schema('email');
@@ -24,6 +30,8 @@ export async function sandboxApprovalEligible(projectId, action, onProjectRead)
         onProjectRead?.(!error && typeof data?.name === 'string' ? data.name : undefined);
         if (error || data?.id !== projectId || data.sandbox_mode !== true)
             return false;
+        if (deletion)
+            return await ownsDeleteTargets(projectId, action, params, requestingCreatorKey());
         if (!isHumanRequestableAdminTool(action))
             return true;
         const scope = SANDBOX_ADMIN_SCOPE[action];
@@ -39,8 +47,8 @@ export async function sandboxApprovalEligible(projectId, action, onProjectRead)
         return false;
     }
 }
-export async function trySandboxApproval(id, projectId, action, payloadHash, onProjectRead) {
-    if (!await sandboxApprovalEligible(projectId, action, onProjectRead))
+export async function trySandboxApproval(id, projectId, action, payloadHash, onProjectRead, params = {}) {
+    if (!await sandboxApprovalEligible(projectId, action, onProjectRead, params))
         return false;
     try {
         // The RPC performs one conditional UPDATE + audit INSERT in one transaction.

package/build/tools/advisor.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { countEmailRows, groupMetricRows, percentRate, isBouncedRow, AI_MAX_TOKENS, outputConfig, anthropicCheckedText, readAllRows } from "@sendinel/domain";
 import { z } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
@@ -361,7 +362,7 @@ Each subject should be distinct in approach (urgency, curiosity, benefit, social
             const labels = ['B', 'C'];
             variantsCreated = [];
             for (let i = 0; i < 2; i++) {
-                const { error: insertErr } = await db()
+                const { error: insertErr } = await withCreatedItems('campaign_steps', db()
                     .from('campaign_steps')
                     .insert({
                     campaign_id,
@@ -372,7 +373,7 @@ Each subject should be distinct in approach (urgency, curiosity, benefit, social
                     body_text: currentStep.text_body,
                     delay_days: currentStep.delay_days,
                     delay_hours: currentStep.delay_hours,
-                });
+                }).select('id'));
                 if (!insertErr)
                     variantsCreated.push(labels[i]);
             }

package/build/tools/campaign-sets.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { z } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
@@ -149,7 +150,7 @@ export async function writeCampaignDrafts(projectId, siteId, drafts, source) {
         }, projectId);
         if (targetingError)
             return { error: { error: targetingError, code: 'INVALID_FIELD', campaign: c.name, created_before_failure: createdIds } };
-        const { data: campaign, error } = await db().from('campaigns').insert(insertPayload).select('id').single();
+        const { data: campaign, error } = await withCreatedItems('campaigns', db().from('campaigns').insert(insertPayload).select('id').single());
         if (error || !campaign)
             return { error: { error: (error ? dbToolError(error).error : undefined) ?? 'Failed to create campaign', code: 'CAMPAIGN_CREATE_FAILED', campaign: c.name, created_before_failure: createdIds } };
         createdIds.push(campaign.id);
@@ -164,7 +165,7 @@ export async function writeCampaignDrafts(projectId, siteId, drafts, source) {
             delay_hours: e.delay_hours,
             variant_label: 'A',
         }));
-        const { error: stepError } = await db().from('campaign_steps').insert(rows);
+        const { error: stepError } = await withCreatedItems('campaign_steps', db().from('campaign_steps').insert(rows).select('id'));
         if (stepError)
             return { error: { ...dbToolError(stepError), code: 'STEP_CREATE_FAILED', campaign: c.name, created_before_failure: createdIds } };
     }

package/build/tools/campaigns.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { validateStepMultiEventRules, stepMultiEventRulesView, validateStepAbsenceRule, stepAbsenceRuleView } from "@sendinel/domain";
 import { readCampaignMetricGroups, SENT_STATUSES } from "@sendinel/domain";
 import { resolveCampaignReentry, readCampaignPeriods, campaignPeriodFields } from "@sendinel/domain";
@@ -19,7 +20,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 { approvalNext, approvalExcerpt, assertChannelCanExecute, currentChannelContext, requestApproval, checkApproval, withApproval } from '../lib/action-approvals.js';
+import { approvalNext, approvalExcerpt, assertChannelCanExecute, currentChannelContext, requestApproval, checkApproval, withApproval, markNotExecuted } from '../lib/action-approvals.js';
 import { sandboxAudience, broadcastApprovalNext } from '../lib/sandbox-audience.js';
 import { resolveSegmentContactIds, resolveSendAudience } from '../lib/send-audience.js';
 import { AudienceNotUnderstoodError, generateEmailFromBrief, parseAudienceRules, unsupportedAudienceReason } from '../lib/email-generation.js';
@@ -478,7 +479,7 @@ async function executeBroadcast(input) {
     if (!limit.allowed) {
         return { ok: false, error: `Campaign limit reached (${limit.current}/${limit.limit}). Upgrade your plan for more campaigns.`, code: 'PLAN_LIMIT' };
     }
-    const { data: campaign, error: campaignErr } = await db()
+    const { data: campaign, error: campaignErr } = await withCreatedItems('campaigns', db()
         .from('campaigns')
         .insert({
         project_id: input.projectId,
@@ -494,11 +495,11 @@ async function executeBroadcast(input) {
         metadata: { source: input.source, ...(input.metadata ?? {}), content_key: contentKey },
     })
         .select('id')
-        .single();
+        .single());
     if (campaignErr || !campaign) {
         return { ok: false, error: (campaignErr ? dbToolError(campaignErr).error : undefined) ?? 'Failed to create campaign', code: 'CAMPAIGN_CREATE_FAILED' };
     }
-    const { data: step, error: stepErr } = await db()
+    const { data: step, error: stepErr } = await withCreatedItems('campaign_steps', db()
         .from('campaign_steps')
         .insert({
         campaign_id: campaign.id,
@@ -511,7 +512,7 @@ async function executeBroadcast(input) {
         delay_hours: 0,
     })
         .select('id')
-        .single();
+        .single());
     if (stepErr || !step) {
         return { ok: false, error: (stepErr ? dbToolError(stepErr).error : undefined) ?? 'Campaign created but failed to add broadcast step', code: 'STEP_CREATE_FAILED', campaign_id: campaign.id };
     }
@@ -899,11 +900,11 @@ export function registerCampaignTools(server) {
         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' : 'validation_failed' });
-        const { data, error } = await db()
+        const { data, error } = await withCreatedItems('campaigns', db()
             .from('campaigns')
             .insert(insertPayload)
             .select()
-            .single();
+            .single());
         if (error)
             return { content: [{ type: 'text', text: `Error: ${dbToolError(error).error}` }] };
         const warnings = await campaignTimezoneWarnings(data);
@@ -983,11 +984,11 @@ export function registerCampaignTools(server) {
             const renderedSubject = survey_id ? renderTemplateVars(subject, renderVars) : subject;
             const renderedHtml = body_html !== undefined && survey_id ? renderTemplateVars(body_html, renderVars) : body_html ?? htmlFromBlocks;
             const renderedText = body_text !== undefined && survey_id ? renderTemplateVars(body_text, renderVars) : body_text;
-            const { data, error } = await db()
+            const { data, error } = await withCreatedItems('campaign_steps', db()
                 .from('campaign_steps')
                 .insert({ campaign_id, step_order, subject: renderedSubject, body_html: renderedHtml, body_text: renderedText ?? (normalizedBlocks?.length ? blocksToText(normalizedBlocks) : undefined), blocks: normalizedBlocks ?? null, delay_days, delay_hours, variant_label: variant_label ?? 'A', skip_if_event: skip_if_event ?? null, send_only_if_event: send_only_if_event ?? null, ...events.rules, ...absence.rules, ...properties.rules })
                 .select()
-                .single();
+                .single());
             if (error)
                 return dbErrorResult(error);
             await recordBrandAssetUsage({
@@ -1722,7 +1723,7 @@ export function registerCampaignTools(server) {
         const limit = await checkPlanLimit('active_campaigns');
         if (!limit.allowed)
             return toolError({ error: `Active campaign limit reached (${limit.current}/${limit.limit}).`, code: 'plan_limit' });
-        const { data: newCampaign, error: createErr } = await db()
+        const { data: newCampaign, error: createErr } = await withCreatedItems('campaigns', db()
             .from('campaigns')
             .insert({
             project_id: projectId,
@@ -1735,7 +1736,7 @@ export function registerCampaignTools(server) {
             status: 'draft',
         })
             .select()
-            .single();
+            .single());
         if (createErr)
             return toolError(dbToolError(createErr));
         const steps = (original.campaign_steps ?? []).sort((a, b) => a.step_order - b.step_order);
@@ -1750,7 +1751,7 @@ export function registerCampaignTools(server) {
                 delay_days: s.delay_days,
                 delay_hours: s.delay_hours,
             }));
-            const { error: stepErr } = await db().from('campaign_steps').insert(stepRows);
+            const { error: stepErr } = await withCreatedItems('campaign_steps', db().from('campaign_steps').insert(stepRows).select('id'));
             if (stepErr)
                 return toolError({ ...dbToolError(stepErr, 'Campaign created but copying steps failed'), campaign_id: newCampaign.id });
         }
@@ -1861,7 +1862,7 @@ export function registerCampaignTools(server) {
             return txt('Error: A sending domain is required before cloning a template — create one with create_site first, or pass site_id.');
         }
         const cloneName = new_name?.trim() || `${template.name} (cloned)`;
-        const { data: campaign, error: campaignError } = await db()
+        const { data: campaign, error: campaignError } = await withCreatedItems('campaigns', db()
             .from('campaigns')
             .insert({
             project_id: projectId,
@@ -1871,12 +1872,12 @@ export function registerCampaignTools(server) {
             status: 'draft',
         })
             .select()
-            .single();
+            .single());
         if (campaignError)
             return txt(`Error creating campaign: ${dbToolError(campaignError).error}`);
         const steps = Array.isArray(template.template?.steps) ? template.template.steps : [];
         if (steps.length > 0) {
-            const { error: stepsError } = await db()
+            const { error: stepsError } = await withCreatedItems('campaign_steps', db()
                 .from('campaign_steps')
                 .insert(steps.map((step, index) => ({
                 campaign_id: campaign.id,
@@ -1888,7 +1889,7 @@ export function registerCampaignTools(server) {
                 delay_hours: step.delay_hours ?? 0,
                 condition_type: step.condition_type ?? null,
                 condition_lookback_hours: step.condition_lookback_hours ?? null,
-            })));
+            }))).select('id'));
             if (stepsError)
                 return txt(`Campaign created but steps failed: ${dbToolError(stepsError).error}`);
         }
@@ -2103,11 +2104,11 @@ Adapt your tone accordingly:
                 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()
+                const { data: seg, error: segErr } = await withCreatedItems('segments', db()
                     .from('segments')
                     .insert({ project_id: projectId, name: plan.segment_name, description: segment_description, rules: plan.rules })
                     .select('id')
-                    .single();
+                    .single());
                 if (segErr)
                     return txt(`Error creating segment: ${dbToolError(segErr).error}`);
                 segId = seg.id;
@@ -2115,17 +2116,17 @@ Adapt your tone accordingly:
             const campLimit = await checkPlanLimit('active_campaigns');
             if (!campLimit.allowed)
                 return txt(`Active campaign limit reached (${campLimit.current}/${campLimit.limit}).`);
-            const { data: campaign, error: campErr } = await db()
+            const { data: campaign, error: campErr } = await withCreatedItems('campaigns', db()
                 .from('campaigns')
                 .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();
+                .single());
             if (campErr)
                 return txt(`Error creating campaign: ${dbToolError(campErr).error}`);
             const steps = [];
             for (let i = 0; i < plan.steps.length; i++) {
                 const planned = plan.steps[i];
-                const { data: step, error: stepErr } = await db()
+                const { data: step, error: stepErr } = await withCreatedItems('campaign_steps', db()
                     .from('campaign_steps')
                     .insert({
                     campaign_id: campaign.id, step_order: i,
@@ -2134,7 +2135,7 @@ Adapt your tone accordingly:
                     delay_days: planned.delay_days, delay_hours: planned.delay_hours,
                 })
                     .select('id, step_order, subject')
-                    .single();
+                    .single());
                 if (stepErr)
                     return txt(`Error adding step ${i}: ${dbToolError(stepErr).error}`);
                 steps.push(step);
@@ -3314,7 +3315,7 @@ Return ONLY valid JSON with this exact shape:
         }
         // Execute mode (second call)
         // 1. Create campaign
-        const { data: campaign, error: campErr } = await db()
+        const { data: campaign, error: campErr } = await withCreatedItems('campaigns', db()
             .from('campaigns')
             .insert({
             project_id: getProjectId(),
@@ -3329,7 +3330,7 @@ Return ONLY valid JSON with this exact shape:
             sends_per_hour: sends_per_hour ?? null,
         })
             .select()
-            .single();
+            .single());
         if (campErr)
             return txt(`Failed to create campaign: ${dbToolError(campErr).error}`);
         // 2. Add steps
@@ -3347,9 +3348,9 @@ Return ONLY valid JSON with this exact shape:
             ...stepMultiEventRulesView(s),
             ...stepAbsenceRuleView(s),
         }));
-        const { error: stepErr } = await db()
+        const { error: stepErr } = await withCreatedItems('campaign_steps', db()
             .from('campaign_steps')
-            .insert(stepInserts);
+            .insert(stepInserts).select('id'));
         if (stepErr)
             return txt(`Campaign created (${campaign.id}) but failed to add steps: ${dbToolError(stepErr).error}`);
         // 3. Enroll segment if provided
@@ -3599,10 +3600,13 @@ Return ONLY valid JSON with this exact shape:
             .eq('id', campaign_id)
             .eq('project_id', projectId)
             .maybeSingle();
-        if (fetchErr || !campaign)
-            return j({ error: 'Campaign not found', code: 'NOT_FOUND' });
+        // No write has happened: release the claim so the same approval can be retried.
+        if (fetchErr)
+            return markNotExecuted(j(dbToolError(fetchErr)));
+        if (!campaign)
+            return markNotExecuted(j({ error: 'Campaign not found', code: 'NOT_FOUND' }));
         if (campaign.status === 'active') {
-            return j({ error: 'Pause the campaign before deleting', code: 'INVALID_STATUS' });
+            return markNotExecuted(j({ error: 'Pause the campaign before deleting', code: 'INVALID_STATUS' }));
         }
         const { error } = await db()
             .from('campaigns')

package/build/tools/compound.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { anthropicRequiredText, outputConfig } from '@sendinel/domain';
 import { z } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
@@ -115,7 +116,7 @@ Respond with a JSON array.`,
         catch (error) {
             return j({ error: `AI generation failed: ${error instanceof Error ? error.message : String(error)}`, code: 'GENERATION_FAILED' });
         }
-        const { data: template, error: templateErr } = await sb.from('campaign_templates')
+        const { data: template, error: templateErr } = await withCreatedItems('campaign_templates', sb.from('campaign_templates')
             .insert({
             project_id: projectId,
             name: `${campaign_name} - Template`,
@@ -127,19 +128,19 @@ Respond with a JSON array.`,
             description: `Base template generated for campaign "${campaign_name}"`,
         })
             .select('id')
-            .single();
+            .single());
         if (templateErr)
             return j({ error: `Template creation failed: ${dbToolError(templateErr).error}` });
-        const { data: campaign, error: campaignErr } = await sb.from('campaigns')
+        const { data: campaign, error: campaignErr } = await withCreatedItems('campaigns', sb.from('campaigns')
             .insert({ name: campaign_name, site_id, project_id: projectId, type: campaign_type, status: 'draft' })
             .select('id, name, status')
-            .single();
+            .single());
         if (campaignErr)
             return j({ error: `Campaign creation failed: ${dbToolError(campaignErr).error}` });
         const createdSteps = [];
         for (let i = 0; i < steps.length; i++) {
             const step = steps[i];
-            const { data, error } = await sb.from('campaign_steps')
+            const { data, error } = await withCreatedItems('campaign_steps', sb.from('campaign_steps')
                 .insert({
                 campaign_id: campaign.id,
                 step_order: i,
@@ -152,7 +153,7 @@ Respond with a JSON array.`,
                 template_id: String(template.id),
             })
                 .select('id, step_order, subject')
-                .single();
+                .single());
             if (error)
                 return j({ error: `Step ${i + 1} creation failed: ${dbToolError(error).error}`, campaign_id: campaign.id });
             createdSteps.push(data);
@@ -224,7 +225,7 @@ Respond with JSON: { "subject": "...", "blocks": [...], "body_text": "..." }`,
             console.error("[compound] Generation failed:", error);
             return toolError(dbToolError(error, "Generation failed: unable to generate template"));
         }
-        const { data: template, error } = await db().from('campaign_templates')
+        const { data: template, error } = await withCreatedItems('campaign_templates', db().from('campaign_templates')
             .insert({
             project_id: projectId,
             name,
@@ -236,7 +237,7 @@ Respond with JSON: { "subject": "...", "blocks": [...], "body_text": "..." }`,
             description: 'Generated from MCP brief',
         })
             .select('id, name, subject_hint, created_at')
-            .single();
+            .single());
         if (error)
             return j(dbToolError(error));
         return j({ ok: true, template, preview: generated });

package/build/tools/contacts.js

@@ -1,3 +1,4 @@
+import { recordCreatedItems, withCreatedItems } from '../lib/mcp-created-items.js';
 import { normalizeTagInput, tagInputWarnings } from '../lib/tags.js';
 import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { CONTACT_ENRICHMENT_PROVIDERS } from '@desler/models';
@@ -671,8 +672,12 @@ export function registerContactTools(server) {
         },
     }, withApproval('identify_subscriber', async (params) => {
         const result = await callSendinelV1('/api/v1/identify', { method: 'POST', body: params });
-        if (result.ok)
+        if (result.ok) {
+            const identified = result.data;
+            if (identified.created === true && identified.contact_id)
+                await recordCreatedItems('subscribers', { id: identified.contact_id });
             return j(result.data);
+        }
         const failed = err(JSON.stringify(result.error));
         return isPreExecutionStatus(result.status) ? markNotExecuted(failed) : failed;
     }));
@@ -1133,7 +1138,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
         const normalizedName = name.trim().slice(0, SUBSCRIBER_VIEW_MAX_NAME_LENGTH);
         if (!normalizedName)
             return toolError({ error: 'name is required', code: 'validation_failed' });
-        const { data, error } = await db()
+        const { data, error } = await withCreatedItems('subscriber_list_views', db()
             .from('subscriber_list_views')
             .insert({
             project_id: getProjectId(),
@@ -1144,7 +1149,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             filters: normalizeSubscriberViewFilters(filters),
         })
             .select('id, name, view_mode, columns, filters, created_by, created_at, updated_at')
-            .maybeSingle();
+            .maybeSingle());
         if (error?.code === '23505')
             return toolError({ error: `A view named "${normalizedName}" already exists`, code: 'conflict' });
         if (error)
@@ -1378,9 +1383,9 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
                     row.utm_content = utm_content;
                 if (utm_term)
                     row.utm_term = utm_term;
-                const { data, error } = await db().from('subscribers')
+                const { data, error } = await withCreatedItems('subscribers', db().from('subscribers')
                     .upsert(row, { onConflict: 'project_id,email', ignoreDuplicates: true })
-                    .select(selection).maybeSingle();
+                    .select(selection).maybeSingle());
                 if (error)
                     return dbErrorResult(error);
                 contact = data;
@@ -1532,6 +1537,12 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             source: 'import',
             opted_in_at: new Date().toISOString(),
         }));
+        // ON CONFLICT DO NOTHING returns only actual inserts, even under concurrent imports.
+        // The updating upsert below must never claim a pre-existing subscriber.
+        const { error: creationError } = await withCreatedItems('subscribers', db().from('subscribers')
+            .upsert(rows, { onConflict: 'project_id,email', ignoreDuplicates: true }).select('id'));
+        if (creationError)
+            return j(dbToolError(creationError));
         const { data: upserted, error: uErr } = await db()
             .from('subscribers')
             .upsert(rows, { onConflict: 'project_id,email', ignoreDuplicates: false })
@@ -2326,55 +2337,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
                 return toolError({ error: error.message, code: 'validation_failed' });
             throw error;
         }
-        let q = db()
-            .from('subscribers')
-            .select('id, email, first_name, last_name, engagement_score, lifecycle_stage, source, created_at, last_opened_at, last_clicked_at')
-            .eq('project_id', projectId)
-            .eq('global_unsubscribed', false);
-        if (params.lifecycle_stage)
-            q = q.eq('lifecycle_stage', params.lifecycle_stage);
-        if (params.min_score !== undefined)
-            q = q.gte('engagement_score', params.min_score);
-        if (params.max_score !== undefined)
-            q = q.lte('engagement_score', params.max_score);
-        if (params.source)
-            q = q.eq('source', params.source);
-        if (params.subscribed_after)
-            q = q.gte('created_at', `${params.subscribed_after}T00:00:00Z`);
-        if (params.subscribed_before)
-            q = q.lte('created_at', `${params.subscribed_before}T23:59:59Z`);
-        if (params.has_opened === true)
-            q = q.not('last_opened_at', 'is', null);
-        if (params.has_opened === false)
-            q = q.is('last_opened_at', null);
-        if (params.has_clicked === true)
-            q = q.not('last_clicked_at', 'is', null);
-        if (params.has_clicked === false)
-            q = q.is('last_clicked_at', null);
-        if (params.tag)
-            q = q.contains('tags', [params.tag]);
-        if (params.company_id)
-            q = q.eq('company_id', params.company_id);
-        const fieldTypes = params.custom_property ? await loadContactPropertyDefinitions(projectId) : {};
-        if (params.custom_property) {
-            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 toolError({ error: error.message, code: 'validation_failed' });
-                throw error;
-            }
-        }
-        if (params.site_id) {
-            // Shared site filter: an inner join, not an id list that overflows past ~350 contacts (#3674).
-            // 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;
-        }
+        let companyIds;
         if (params.company_domain) {
             const { data: companies, error } = await db()
                 .from('companies')
@@ -2386,45 +2349,86 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             const ids = (companies ?? []).map((company) => company.id);
             if (!ids.length)
                 return j({ total: 0, sample: [] });
-            q = q.in('company_id', ids);
+            companyIds = ids;
         }
+        const fieldTypes = params.custom_property ? await loadContactPropertyDefinitions(projectId) : {};
+        const applyEstimateFilters = async (baseQuery) => {
+            let filtered = baseQuery;
+            if (params.lifecycle_stage)
+                filtered = filtered.eq('lifecycle_stage', params.lifecycle_stage);
+            if (params.min_score !== undefined)
+                filtered = filtered.gte('engagement_score', params.min_score);
+            if (params.max_score !== undefined)
+                filtered = filtered.lte('engagement_score', params.max_score);
+            if (params.source)
+                filtered = filtered.eq('source', params.source);
+            if (params.subscribed_after)
+                filtered = filtered.gte('created_at', `${params.subscribed_after}T00:00:00Z`);
+            if (params.subscribed_before)
+                filtered = filtered.lte('created_at', `${params.subscribed_before}T23:59:59Z`);
+            if (params.has_opened === true)
+                filtered = filtered.not('last_opened_at', 'is', null);
+            if (params.has_opened === false)
+                filtered = filtered.is('last_opened_at', null);
+            if (params.has_clicked === true)
+                filtered = filtered.not('last_clicked_at', 'is', null);
+            if (params.has_clicked === false)
+                filtered = filtered.is('last_clicked_at', null);
+            if (params.tag)
+                filtered = filtered.contains('tags', [params.tag]);
+            if (params.company_id)
+                filtered = filtered.eq('company_id', params.company_id);
+            if (companyIds)
+                filtered = filtered.in('company_id', companyIds);
+            if (params.custom_property) {
+                try {
+                    // #4270: the query runs as-is, so a filter it cannot express is an error, not dropped.
+                    const res = await applySegmentRules(filtered, { custom_property: params.custom_property }, db(), projectId, fieldTypes, { pushDownOnly: true });
+                    filtered = res.query;
+                }
+                catch (error) {
+                    if (isSegmentRulesError(error))
+                        return { query: filtered, error: toolError({ error: error.message, code: 'validation_failed' }) };
+                    throw error;
+                }
+            }
+            if (params.site_id) {
+                // Shared site filter: an inner join, not an id list that overflows past ~350 contacts (#3674).
+                // Deliberately everyone on the site, so allowEmpty.
+                const siteFiltered = await applySegmentRules(filtered, { site_id: params.site_id }, db(), projectId, {}, { allowEmpty: true });
+                if (siteFiltered.siteContactIds && siteFiltered.siteContactIds.length === 0) {
+                    return { query: siteFiltered.query, empty: true };
+                }
+                filtered = siteFiltered.query;
+            }
+            return { query: filtered };
+        };
+        let sampleBase = db()
+            .from('subscribers')
+            .select('id, email, first_name, last_name, engagement_score, lifecycle_stage, source, created_at, last_opened_at, last_clicked_at')
+            .eq('project_id', projectId)
+            .eq('global_unsubscribed', false);
+        const sampleFilterResult = await applyEstimateFilters(sampleBase);
+        if (sampleFilterResult.error)
+            return sampleFilterResult.error;
+        if (sampleFilterResult.empty)
+            return j({ total: 0, sample: [] });
+        let q = sampleFilterResult.query;
         const { data, error } = await q.order('engagement_score', { ascending: false }).limit(sampleSize);
         if (error)
             return dbErrorResult(error);
-        // Get full count separately
-        let countQ = db()
+        // Get full count separately using the exact same filters
+        let countBase = db()
             .from('subscribers')
             .select('id', { count: 'exact', head: true })
             .eq('project_id', projectId)
             .eq('global_unsubscribed', false);
-        if (params.lifecycle_stage)
-            countQ = countQ.eq('lifecycle_stage', params.lifecycle_stage);
-        if (params.min_score !== undefined)
-            countQ = countQ.gte('engagement_score', params.min_score);
-        if (params.max_score !== undefined)
-            countQ = countQ.lte('engagement_score', params.max_score);
-        if (params.source)
-            countQ = countQ.eq('source', params.source);
-        if (params.subscribed_after)
-            countQ = countQ.gte('created_at', `${params.subscribed_after}T00:00:00Z`);
-        if (params.subscribed_before)
-            countQ = countQ.lte('created_at', `${params.subscribed_before}T23:59:59Z`);
-        if (params.has_opened === true)
-            countQ = countQ.not('last_opened_at', 'is', null);
-        if (params.has_opened === false)
-            countQ = countQ.is('last_opened_at', null);
-        if (params.has_clicked === true)
-            countQ = countQ.not('last_clicked_at', 'is', null);
-        if (params.has_clicked === false)
-            countQ = countQ.is('last_clicked_at', null);
-        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, { 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, {}, { allowEmpty: true }));
+        const countFilterResult = await applyEstimateFilters(countBase);
+        if (countFilterResult.error)
+            return countFilterResult.error;
+        if (countFilterResult.empty)
+            return j({ total: 0, sample: [] });
+        let countQ = countFilterResult.query;
         const { count, error: countError } = await countQ;
         if (countError)
             return dbErrorResult(countError);
@@ -2837,7 +2841,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             : null;
         const projectId = getProjectId();
         const orgId = await getProjectOrgId(projectId);
-        const { data, error } = await db()
+        const { data, error } = await withCreatedItems('custom_field_definitions', db()
             .from('custom_field_definitions')
             .insert({
             org_id: orgId,
@@ -2850,7 +2854,7 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             display_order: display_order ?? 0,
         })
             .select('id, key, label, type, required, options, display_order')
-            .single();
+            .single());
         if (error) {
             if (error.code === '23505')
                 return contactInputError('conflict', `Error: A custom field with key "${key}" already exists.`);

package/build/tools/content.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { adminDb, db } from '../db.js';
@@ -241,10 +242,10 @@ export function registerContentTools(server) {
         if (category === 'footer' && !/href\s*=\s*["']\s*\{\{\s*unsubscribe_url\s*\}\}/i.test(html) && !validateUnsubscribeFooterTemplate(html).ok) {
             return toolError({ error: 'Footer blocks require {{unsubscribe_url}} in a link or <unsubscribe>link text</unsubscribe>', code: 'validation_failed' });
         }
-        const { data, error } = await db().from('content_blocks')
+        const { data, error } = await withCreatedItems('content_blocks', db().from('content_blocks')
             .insert({ project_id: getProjectId(), name, category, html, description: description ?? null })
             .select('id, name, category, html, description, created_at')
-            .single();
+            .single());
         if (error)
             return toolError(dbToolError(error));
         await logAudit({ action: 'content_block.created', resourceType: 'content_block', resourceId: data.id });

package/build/tools/drafts.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { z } from 'zod';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
@@ -179,14 +180,14 @@ export function registerDraftTools(server) {
             insert.trigger_event_name = trigger_event_name;
         if (trigger_tag)
             insert.trigger_tag = trigger_tag.trim().toLowerCase();
-        const { data: campaign, error: campaignError } = await db()
+        const { data: campaign, error: campaignError } = await withCreatedItems('campaigns', db()
             .from('campaigns')
             .insert(insert)
             .select()
-            .single();
+            .single());
         if (campaignError)
             return { content: [{ type: 'text', text: `Failed to create campaign: ${dbToolError(campaignError).error}` }] };
-        const { data: step, error: stepError } = await db()
+        const { data: step, error: stepError } = await withCreatedItems('campaign_steps', db()
             .from('campaign_steps')
             .insert({
             campaign_id: campaign.id,
@@ -198,7 +199,7 @@ export function registerDraftTools(server) {
             delay_hours: 0,
         })
             .select()
-            .single();
+            .single());
         if (stepError)
             return { content: [{ type: 'text', text: `Campaign created (${campaign.id}) but failed to create step: ${dbToolError(stepError).error}` }] };
         await recordBrandAssetUsage({

package/build/tools/landing-pages.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { db } from '../db.js';
@@ -147,11 +148,11 @@ export function registerLandingPageTools(server) {
             insert.accent_color = accent_color;
         if (custom_css)
             insert.custom_css = custom_css;
-        const { data, error } = await db()
+        const { data, error } = await withCreatedItems('landing_pages', db()
             .from('landing_pages')
             .insert(insert)
             .select()
-            .single();
+            .single());
         if (error) {
             if (error.code === '23505')
                 return toolError({ error: 'A page with this slug already exists', code: 'conflict' });

package/build/tools/lists.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { literalIlikePattern } from '@sendinel/domain';
 import { z } from 'zod';
 import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, hydrateEmailSendsContacts, isSegmentRulesError, normalizeSegmentRulesToTree, readAllRows, } from '@sendinel/domain';
@@ -127,7 +128,7 @@ export function registerListTools(server) {
     }, async ({ name, description }) => {
         const projectId = getProjectId();
         const normalizedName = name.trim();
-        const { data, error } = await db()
+        const { data, error } = await withCreatedItems('contact_lists', db()
             .from('contact_lists')
             .insert({
             project_id: projectId,
@@ -135,7 +136,7 @@ export function registerListTools(server) {
             description: description?.trim() ?? null,
         })
             .select('id, name, description, created_at')
-            .single();
+            .single());
         if (error)
             return txt(`Error: ${dbToolError(error).error}`);
         await logAudit({

package/build/tools/newsletters.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { stripActiveEmailContent } from '@sendinel/domain';
@@ -88,7 +89,7 @@ async function ensureNewsletterCampaign(newsletter, issue, projectId, scheduledA
             campaignId = null;
     }
     if (!campaignId) {
-        const { data: campaign, error } = await db().from('campaigns').insert({
+        const { data: campaign, error } = await withCreatedItems('campaigns', db().from('campaigns').insert({
             project_id: projectId,
             site_id: newsletter.site_id,
             name: campaignName,
@@ -97,7 +98,7 @@ async function ensureNewsletterCampaign(newsletter, issue, projectId, scheduledA
             requires_approval: false,
             send_at: scheduledAt,
             metadata,
-        }).select('id').single();
+        }).select('id').single());
         if (error || !campaign)
             return { error: (error ? dbToolError(error).error : undefined) ?? 'Campaign create failed' };
         campaignId = campaign.id;
@@ -117,7 +118,7 @@ async function ensureNewsletterCampaign(newsletter, issue, projectId, scheduledA
             return { ...dbToolError(error) };
     }
     else {
-        const { error } = await db().from('campaign_steps').insert({
+        const { error } = await withCreatedItems('campaign_steps', db().from('campaign_steps').insert({
             campaign_id: campaignId,
             step_order: 0,
             subject: issue.subject,
@@ -125,7 +126,7 @@ async function ensureNewsletterCampaign(newsletter, issue, projectId, scheduledA
             body_text: issue.preheader,
             delay_days: 0,
             delay_hours: 0,
-        });
+        }).select('id'));
         if (error)
             return { ...dbToolError(error) };
     }
@@ -504,6 +505,12 @@ export function registerNewsletterTools(server) {
             return j(dbToolError(newsletterError));
         if (!newsletter)
             return j({ error: 'Newsletter not found', code: 'NOT_FOUND' });
+        // Separate insert from update so reactivating a seed/other client's subscriber grants no ownership.
+        const { error: creationError } = await withCreatedItems('subscribers', db().from('subscribers').upsert({
+            project_id: projectId, email: normalizedEmail, first_name: first_name ?? null, last_name: last_name ?? null, source,
+        }, { onConflict: 'project_id,email', ignoreDuplicates: true }).select('id'));
+        if (creationError)
+            return j(dbToolError(creationError));
         const { data: subscriber, error: subscriberError } = await db().from('subscribers').upsert({
             project_id: projectId,
             email: normalizedEmail,

package/build/tools/segments.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
@@ -94,11 +95,11 @@ export function registerSegmentTools(server) {
                     return invalid;
                 throw rulesError;
             }
-            const { data, error } = await db()
+            const { data, error } = await withCreatedItems('segments', db()
                 .from('segments')
                 .insert({ project_id: getProjectId(), name, description, rules: storedRules })
                 .select('id, name, description, rules, created_at')
-                .single();
+                .single());
             if (error?.code === '23505')
                 return toolError({ error: 'A segment with this name already exists', code: 'conflict' });
             if (error)
@@ -247,14 +248,14 @@ export function registerSegmentTools(server) {
             if (error)
                 return dbErrorResult(error);
             if (!seg)
-                return txt('Error: segment not found');
+                return toolError({ error: 'Segment not found', code: 'not_found' });
             segRules = seg.rules;
         }
         else if (rules !== undefined) {
             segRules = rules;
         }
         else {
-            return txt('Provide either segment_id or rules.');
+            return toolError({ error: 'Provide either segment_id or rules.', code: 'validation_failed' });
         }
         let ids;
         try {
@@ -335,11 +336,11 @@ export function registerSegmentTools(server) {
                 message: `Parsed "${description}" into rules. ${ids.length} contacts match. Call again with confirmed: true to create.`,
             });
         }
-        const { data, error } = await db()
+        const { data, error } = await withCreatedItems('segments', db()
             .from('segments')
             .insert({ project_id: getProjectId(), name, description, rules: parsedRules })
             .select('id, name, description, rules, created_at')
-            .single();
+            .single());
         if (error)
             return txt(`Error: ${dbToolError(error).error}`);
         return j({ ...data, estimated_contacts: ids.length });

package/build/tools/signatures.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { db } from '../db.js';
@@ -58,7 +59,7 @@ export function registerSignatureTools(server) {
             if (clearError)
                 return j(dbToolError(clearError));
         }
-        const { data, error } = await db()
+        const { data, error } = await withCreatedItems('signature_blocks', db()
             .from('signature_blocks')
             .insert({
             project_id: projectId,
@@ -68,7 +69,7 @@ export function registerSignatureTools(server) {
             is_default: is_default ?? false,
         })
             .select(COLUMNS)
-            .single();
+            .single());
         if (error)
             return j(dbToolError(error));
         await logAudit({

package/build/tools/sms.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { assertProjectAllowsSms } from "@sendinel/domain";
 import { randomUUID } from 'crypto';
 import { withApproval } from '../lib/action-approvals.js';
@@ -419,7 +420,7 @@ export function registerSmsTools(server) {
         },
     }, withApproval('send_sms_campaign', async ({ site_id, name, body, type, segment_id, scheduled_at, activate }) => {
         const projectId = getProjectId();
-        const { data: campaign, error: campaignError } = await db()
+        const { data: campaign, error: campaignError } = await withCreatedItems('campaigns', db()
             .from('campaigns')
             .insert({
             project_id: projectId,
@@ -431,10 +432,10 @@ export function registerSmsTools(server) {
             send_at: scheduled_at ?? null,
         })
             .select('id, name, type, status, channel, site_id, send_at')
-            .single();
+            .single());
         if (campaignError || !campaign)
             return j({ error: (campaignError ? dbToolError(campaignError).error : undefined) ?? 'Failed to create campaign' });
-        const { data: step, error: stepError } = await db()
+        const { data: step, error: stepError } = await withCreatedItems('campaign_steps', db()
             .from('campaign_steps')
             .insert({
             project_id: projectId,
@@ -448,7 +449,7 @@ export function registerSmsTools(server) {
             status: 'active',
         })
             .select('id, step_order, channel')
-            .single();
+            .single());
         if (stepError)
             return j({ ...dbToolError(stepError), campaign });
         return j({

package/build/tools/social-posts.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import Anthropic from '@anthropic-ai/sdk';
 import { withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
@@ -535,7 +536,7 @@ export function registerSocialPostTools(server) {
             socialCampaignId = socialCampaign.id;
         }
         const status = statusFromSchedule(scheduledAt, Boolean(queue_requested));
-        const { data, error } = await db()
+        const { data, error } = await withCreatedItems('social_posts', db()
             .from('social_posts')
             .insert({
             org_id: orgId,
@@ -557,7 +558,7 @@ export function registerSocialPostTools(server) {
             status,
         })
             .select()
-            .single();
+            .single());
         if (error)
             return txt(`Error: ${dbToolError(error).error}`);
         fireWebhookEvent('social.post.created', { social_post_id: data.id, title: data.title, status: data.status, platforms: data.platforms }, projectId).catch(() => { });

package/build/tools/templates.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { literalIlikePattern } from '@sendinel/domain';
 import { withApproval } from '../lib/action-approvals.js';
 import { snapshotTemplateVersion, versionHasBodySnapshot } from '@sendinel/domain';
@@ -164,7 +165,7 @@ export function registerTemplateTools(server) {
             return j(dbToolError(error));
         let savedTemplateId = null;
         if (save) {
-            const { data: saved, error: saveError } = await db().from('campaign_templates').insert({
+            const { data: saved, error: saveError } = await withCreatedItems('campaign_templates', db().from('campaign_templates').insert({
                 project_id: projectId,
                 name: translated.name,
                 category: 'migration',
@@ -179,7 +180,7 @@ export function registerTemplateTools(server) {
                 tags: ['migration', provider],
                 imported_from: provider,
                 external_id: source_template_id ?? null,
-            }).select('id').single();
+            }).select('id').single());
             if (saveError)
                 return j(dbToolError(saveError));
             savedTemplateId = saved?.id ?? null;
@@ -242,7 +243,7 @@ export function registerTemplateTools(server) {
         },
     }, async ({ name, brief, subject_hint, body_html, category, description, tags, is_transactional, brand_asset_ids }) => {
         const projectId = getProjectId();
-        const { data, error } = await db().from('campaign_templates')
+        const { data, error } = await withCreatedItems('campaign_templates', db().from('campaign_templates')
             .insert({
             project_id: projectId,
             name,
@@ -256,7 +257,7 @@ export function registerTemplateTools(server) {
             is_transactional: is_transactional ?? false,
         })
             .select('id, name, category, description, subject_hint, brief_template, body_html, body_source, body_text, format, variables, tags, created_at')
-            .single();
+            .single());
         if (error)
             return j(dbToolError(error));
         await recordBrandAssetUsage({

package/build/tools/webhooks.js

@@ -1,3 +1,4 @@
+import { withCreatedItems } from '../lib/mcp-created-items.js';
 import { withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { listSandboxWebhookEvents } from '@sendinel/domain';
@@ -61,7 +62,7 @@ export function registerWebhookTools(server) {
         if (!validation.valid)
             return txt(`Invalid URL: ${validation.reason}`);
         const secret = generateWebhookSecret();
-        const { data, error } = await db()
+        const { data, error } = await withCreatedItems('webhook_subscriptions', db()
             .from('webhook_subscriptions')
             .insert({
             project_id: getProjectId(),
@@ -71,7 +72,7 @@ export function registerWebhookTools(server) {
             description: description ?? null,
         })
             .select('id, url, events, active, created_at')
-            .single();
+            .single());
         if (error)
             return txt(`Error creating subscription: ${dbToolError(error).error}`);
         return j({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendinel/mcp-server",
-  "version": "1.0.173",
+  "version": "1.0.175",
   "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",