@mj-biz-apps/marketing-server 0.7.0 → 0.8.0

package/dist/__tests__/adConversionParity.test.js

@@ -5,6 +5,7 @@ import { LinkedInAdsClient, linkedInConversionTypeFor } from '../programs/linked
 import { LinkedInAdsProgramDriver } from '../programs/linkedin/LinkedInAdsProgramDriver.js';
 import { MetaAdsClient, customConversionActionType, metaCallToActionFor, metaObjectiveFor } from '../programs/meta/MetaAdsClient.js';
 import { MetaAdsProgramDriver } from '../programs/meta/MetaAdsProgramDriver.js';
+import { BrandConversionLookupError } from '../programs/brandConversionBindings.js';
 function googleClient(answer) {
     const calls = [];
     const fetchImpl = (async (input, init) => {
@@ -183,15 +184,45 @@ describe('MetaAdsClient — custom conversions (D-34 parity)', () => {
         expect(post.get('custom_event_type')).toBe('LEAD');
         expect(JSON.parse(post.get('rule'))).toEqual({ and: [{ event: { eq: 'Lead' } }, { URL: { i_contains: 'sidecar.ai/ai' } }] });
     });
-    it('lists Meta saved audiences and merges their targeting spec onto the ad set (KI-144)', async () => {
+    it('lists Meta saved audiences using lower/upper count bounds (pinning fields) and merges their targeting spec onto the ad set (KI-144)', async () => {
         const { client, calls } = metaClient((url) => url.pathname.endsWith('/saved_audiences')
-            ? { data: [{ id: '6002002', name: 'SC | Association Leaders', approximate_count_64bit: 420_000, targeting: { flexible_spec: [{ interests: [{ id: '6003', name: 'Association' }] }] } }] }
+            ? {
+                data: [
+                    {
+                        id: '6002002',
+                        name: 'SC | Association Leaders',
+                        approximate_count_lower_bound: 380_000,
+                        approximate_count_upper_bound: 460_000,
+                        targeting: { flexible_spec: [{ interests: [{ id: '6003', name: 'Association' }] }] },
+                    },
+                    {
+                        id: '6002003',
+                        name: 'SC | Pending Estimate',
+                        approximate_count_lower_bound: -1,
+                        approximate_count_upper_bound: -1,
+                        targeting: { geo_locations: { countries: ['US'] } },
+                    },
+                ],
+            }
             : { id: '3300' });
         const audiences = await client.savedAudiences();
-        expect(audiences).toEqual([{
-                id: '6002002', name: 'SC | Association Leaders', approximateMemberCount: 420_000,
+        expect(calls[0].url.pathname).toBe('/v21.0/act_2312673322359408/saved_audiences');
+        expect(calls[0].url.searchParams.get('fields')).toBe('id,name,approximate_count_lower_bound,approximate_count_upper_bound,targeting');
+        expect(calls[0].url.searchParams.get('fields')).not.toContain('approximate_count_64bit');
+        expect(audiences).toEqual([
+            {
+                id: '6002002',
+                name: 'SC | Association Leaders',
+                approximateMemberCount: 420_000,
                 targeting: { flexible_spec: [{ interests: [{ id: '6003', name: 'Association' }] }] },
-            }]);
+            },
+            {
+                id: '6002003',
+                name: 'SC | Pending Estimate',
+                approximateMemberCount: null,
+                targeting: { geo_locations: { countries: ['US'] } },
+            },
+        ]);
         await client.createAdSet({
             name: 'CX-12 — ad set', campaignId: '120', dailyBudgetUsd: 25, status: 'PAUSED',
             runSchedule: { start: 1_792_000_000_000 }, countries: ['US'],
@@ -203,6 +234,44 @@ describe('MetaAdsClient — custom conversions (D-34 parity)', () => {
             geo_locations: { countries: ['US'] },
         });
     });
+    it('survives partial Graph API failure in MetaAdsProgramDriver.listAudienceOptions so one failing endpoint never takes down the other picker', async () => {
+        const user = { ID: 'u-1', Email: 'ops@example.org' };
+        const makeDriver = (client) => new MetaAdsProgramDriver(user, async () => ({
+            ok: true,
+            client: client,
+            brandConnectionId: 'conn-meta-1',
+            adAccountId: 'act_2312673322359408',
+            pageId: '12345',
+            pixelId: '415938279713144',
+            launchState: 'Paused',
+        }));
+        // 1. savedAudiences fails -> conversions still returned + audiencesError surfaced
+        const d1 = makeDriver({
+            savedAudiences: async () => { throw new Error('(#100) Tried accessing nonexisting field'); },
+            customConversions: async () => [{ id: '1650799', name: 'Demo Submit', enabled: true, customEventType: 'LEAD', pixelId: '415938' }],
+        });
+        expect(await d1.listAudienceOptions('brand-1')).toEqual({
+            audiences: [],
+            conversions: [{ id: '1650799', name: 'Demo Submit', enabled: true }],
+            audiencesError: '(#100) Tried accessing nonexisting field',
+        });
+        // 2. customConversions fails -> audiences still returned + conversionsError surfaced
+        const d2 = makeDriver({
+            savedAudiences: async () => [{ id: '1202433', name: 'Association Leaders', approximateMemberCount: 7500, targeting: {} }],
+            customConversions: async () => { throw new Error('customconversions permission denied'); },
+        });
+        expect(await d2.listAudienceOptions('brand-1')).toEqual({
+            audiences: [{ id: '1202433', name: 'Association Leaders', approximateMemberCount: 7500 }],
+            conversions: [],
+            conversionsError: 'customconversions permission denied',
+        });
+        // 3. Both fail -> throws so callers treat the connection read as failed
+        const d3 = makeDriver({
+            savedAudiences: async () => { throw new Error('Token expired'); },
+            customConversions: async () => { throw new Error('Token expired'); },
+        });
+        await expect(d3.listAudienceOptions('brand-1')).rejects.toThrow('Token expired');
+    });
     it('skips ARCHIVED or DELETED campaigns and ad sets in Meta findByName (KI-158)', async () => {
         const { client } = metaClient(() => ({ data: [
                 { id: '1', name: 'CX-01', status: 'ARCHIVED' },
@@ -524,14 +593,29 @@ describe('LinkedInAdsClient — conversions, URL conversion rules, and pivot=CON
         expect(deletes).toHaveLength(2);
         expect(deletes[0].url).toContain('/rest/campaignConversions/(campaign:urn%3Ali%3AsponsoredCampaign%3A910066056,conversion:urn%3Alla%3AllaPartnerConversion%3A18994420)');
     });
-    it('attaches connection trackingConversions on LinkedIn lock without changing state.conversion or optimizeFor, and detaches removed standing conversions on re-lock', async () => {
+    it('attaches AttachToEveryCampaign brandConversions on LinkedIn lock without changing state.conversion or optimizeFor, detaches removed ones on re-lock, and scopes clicks analytics to standing IDs (D-42)', async () => {
         const associated = [];
         const disassociated = [];
+        const analyticsArgs = [];
         const savedRefs = [];
         const fakeUser = { ID: 'u1' };
-        let currentTracking = [
-            { ID: '30316052', Name: 'Self-Serve Checkout' },
-            { ID: '29325716', Name: 'Demo Form Submit' },
+        const bcConv1Id = '00000000-0000-4000-8000-000000000101';
+        const bcConv2Id = '00000000-0000-4000-8000-000000000102';
+        let currentBrandConversions = [
+            {
+                id: bcConv1Id,
+                name: 'Self-Serve Checkout',
+                isActive: true,
+                attachToEveryCampaign: true,
+                binding: { externalId: '30316052', cachedName: 'Self-Serve Checkout' },
+            },
+            {
+                id: bcConv2Id,
+                name: 'Book Demo',
+                isActive: true,
+                attachToEveryCampaign: true,
+                binding: { externalId: '29325716', cachedName: 'Demo Form Submit' },
+            },
         ];
         const driver = new LinkedInAdsProgramDriver(fakeUser, async () => ({
             ok: true,
@@ -540,7 +624,6 @@ describe('LinkedInAdsClient — conversions, URL conversion rules, and pivot=CON
             launchState: 'Paused',
             organizationUrn: 'urn:li:organization:900001',
             defaultAudienceTemplateId: '70217227',
-            trackingConversions: currentTracking,
             client: {
                 accountReference: async () => 'urn:li:organization:900001',
                 tokenScopes: async () => ['r_ads', 'rw_ads', 'rw_conversions'],
@@ -553,8 +636,12 @@ describe('LinkedInAdsClient — conversions, URL conversion rules, and pivot=CON
                 createCampaign: async () => 'urn:li:sponsoredCampaign:2',
                 associateConversion: async (camp, conv) => { associated.push([camp, conv]); },
                 disassociateConversion: async (camp, conv) => { disassociated.push([camp, conv]); },
+                campaignAnalytics: async (_urns, _from, _to, convId) => {
+                    analyticsArgs.push(convId);
+                    return { impressions: 1200, clicks: 44, landingPageClicks: 31, externalWebsiteConversions: 3, spendUsd: 19.5 };
+                },
             },
-        }));
+        }), async () => currentBrandConversions);
         driver['loadRefs'] = async () => [];
         driver['runScheduleFor'] = async () => ({ start: 1_800_000_000_000 });
         driver['saveRef'] = async (_pid, _bc, kind, urn, state) => {
@@ -585,14 +672,29 @@ describe('LinkedInAdsClient — conversions, URL conversion rules, and pivot=CON
             conversion: null,
             optimizeFor: 'clicks',
             objective: 'WEBSITE_VISIT',
-            trackingConversions: [
-                { id: '30316052', name: 'Self-Serve Checkout' },
-                { id: '29325716', name: 'Demo Form Submit' },
+            standingConversions: [
+                { brandConversionId: bcConv1Id, brandConversionName: 'Self-Serve Checkout', id: '30316052', name: 'Self-Serve Checkout' },
+                { brandConversionId: bcConv2Id, brandConversionName: 'Book Demo', id: '29325716', name: 'Demo Form Submit' },
             ],
         });
-        // Re-lock after removing 29325716 from the connection: detaches 29325716 and updates StateJSON.trackingConversions.
+        // Re-lock after turning off AttachToEveryCampaign on Book Demo: detaches 29325716 and updates StateJSON.standingConversions.
         associated.length = 0;
-        currentTracking = [{ ID: '30316052', Name: 'Self-Serve Checkout' }];
+        currentBrandConversions = [
+            {
+                id: bcConv1Id,
+                name: 'Self-Serve Checkout',
+                isActive: true,
+                attachToEveryCampaign: true,
+                binding: { externalId: '30316052', cachedName: 'Self-Serve Checkout' },
+            },
+            {
+                id: bcConv2Id,
+                name: 'Book Demo',
+                isActive: true,
+                attachToEveryCampaign: false,
+                binding: { externalId: '29325716', cachedName: 'Demo Form Submit' },
+            },
+        ];
         const existingCampaignRow = {
             ExternalKind: 'Campaign',
             ExternalURN: 'urn:li:sponsoredCampaign:2',
@@ -613,40 +715,260 @@ describe('LinkedInAdsClient — conversions, URL conversion rules, and pivot=CON
         expect(JSON.parse(existingCampaignRow.StateJSON)).toMatchObject({
             conversion: null,
             optimizeFor: 'clicks',
-            trackingConversions: [{ id: '30316052', name: 'Self-Serve Checkout' }],
+            standingConversions: [
+                { brandConversionId: bcConv1Id, brandConversionName: 'Self-Serve Checkout', id: '30316052', name: 'Self-Serve Checkout' },
+            ],
+        });
+        // collectMetrics on clicks program scopes conversionsCount to standingIds while keeping observedMetric = landingPageClicks.
+        const obs = await driver.collectMetrics(program, {
+            from: new Date('2026-10-01T00:00:00Z'),
+            to: new Date('2026-10-14T00:00:00Z'),
+            sprintId: null,
+        });
+        expect(analyticsArgs).toEqual([['30316052']]);
+        expect(obs?.[0]).toMatchObject({
+            observedMetric: 31,
+            measures: 'landing-page clicks',
+            conversionsCount: 3,
+            clicksCount: 31,
         });
     });
-    it('validates standing conversions at propose, connection save, and BEFORE onLock creates any group or campaign', async () => {
+    it('enforces brandConversionId lever rules (unknown=error, unbound=notice at propose + refusal at lock, bound=optimise) and clicks-only Google/Meta standing notices + scoped measurement (D-42)', async () => {
         const fakeUser = { ID: 'u1' };
-        let scopes = ['r_ads', 'rw_ads', 'rw_conversions'];
-        let groupCreated = false;
-        let campaignCreated = false;
-        const driver = new LinkedInAdsProgramDriver(fakeUser, async () => ({
+        const unknownId = '00000000-0000-4000-8000-000000000999';
+        const unboundId = '00000000-0000-4000-8000-000000000201';
+        const boundId = '00000000-0000-4000-8000-000000000202';
+        const standingId = '00000000-0000-4000-8000-000000000203';
+        let liGroupCreated = false;
+        const liDriver = new LinkedInAdsProgramDriver(fakeUser, async () => ({
             ok: true,
             brandConnectionId: 'bc-li',
             adAccountId: '509410093',
             launchState: 'Paused',
             organizationUrn: 'urn:li:organization:900001',
             defaultAudienceTemplateId: '70217227',
-            trackingConversions: [{ ID: '99999999', Name: 'Deleted Conversion' }],
             client: {
                 accountReference: async () => 'urn:li:organization:900001',
-                tokenScopes: async () => scopes,
+                tokenScopes: async () => ['r_ads', 'rw_ads', 'rw_conversions'],
                 conversions: async () => [
-                    { id: '30316052', urn: 'urn:lla:llaPartnerConversion:30316052', name: 'Self-Serve Checkout', type: 'PURCHASE', enabled: true },
+                    { id: '29325716', urn: 'urn:lla:llaPartnerConversion:29325716', name: 'Demo Form Submit', type: 'LEAD', enabled: true },
                 ],
+                findConversionById: async (id) => id === '29325716'
+                    ? { id: '29325716', urn: 'urn:lla:llaPartnerConversion:29325716', name: 'Demo Form Submit', type: 'LEAD', enabled: true }
+                    : null,
                 findAudienceTemplateById: async () => ({ id: '70217227', name: 'Execs', approximateMemberCount: 50_000, targetingCriteria: {} }),
-                createCampaignGroup: async () => { groupCreated = true; return 'urn:li:sponsoredCampaignGroup:1'; },
-                createCampaign: async () => { campaignCreated = true; return 'urn:li:sponsoredCampaign:2'; },
+                createCampaignGroup: async () => { liGroupCreated = true; return 'urn:li:sponsoredCampaignGroup:1'; },
+            },
+        }), async () => [
+            { id: unboundId, name: 'Unbound Goal', isActive: true, attachToEveryCampaign: false, binding: null },
+            {
+                id: boundId,
+                name: 'Book Demo',
+                isActive: true,
+                attachToEveryCampaign: false,
+                binding: { externalId: '29325716', cachedName: 'Demo Form Submit' },
             },
+        ]);
+        liDriver['loadRefs'] = async () => [];
+        const makeProg = (levers) => ({
+            id: 'prog-bc-1',
+            brandId: 'brand-1',
+            hypothesis: 'h',
+            metricName: 'Demos',
+            params: {
+                campaignCode: 'CP-11',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/demo',
+                    ...levers,
+                }),
+            },
+        });
+        // 0. brandConversion name without brandConversionId -> AD_BRAND_CONVERSION_ID_REQUIRED (zero by-name fallback)
+        const nameOnlyIssues = await liDriver.validateProposal(makeProg({ brandConversion: 'Book Demo' }));
+        expect(nameOnlyIssues.find(i => i.code === 'AD_BRAND_CONVERSION_ID_REQUIRED')).toMatchObject({ severity: 'error' });
+        // 1. Unknown brandConversionId -> error at propose & refusal at lock
+        const unknownIssues = await liDriver.validateProposal(makeProg({ brandConversionId: unknownId, brandConversion: 'Nonexistent' }));
+        expect(unknownIssues.find(i => i.code === 'AD_BRAND_CONVERSION_UNKNOWN')).toMatchObject({ severity: 'error' });
+        await expect(liDriver.onLock(makeProg({ brandConversionId: unknownId, brandConversion: 'Nonexistent' }))).rejects.toThrow(/no active Brand Conversion with id/);
+        expect(liGroupCreated).toBe(false);
+        // 2. Unbound brandConversionId -> NOTICE at propose, REFUSAL at lock before any object is created
+        const unboundIssues = await liDriver.validateProposal(makeProg({ brandConversionId: unboundId, brandConversion: 'Unbound Goal' }));
+        expect(unboundIssues.filter(i => i.severity === 'error')).toEqual([]);
+        expect(unboundIssues.find(i => i.code === 'AD_BRAND_CONVERSION_UNBOUND')).toMatchObject({ severity: 'notice' });
+        await expect(liDriver.onLock(makeProg({ brandConversionId: unboundId, brandConversion: 'Unbound Goal' }))).rejects.toThrow(/has no LinkedIn Ads binding/);
+        expect(liGroupCreated).toBe(false);
+        // 3. Multi-action standing measurement on LinkedInAdsClient, GoogleAdsClient, and MetaAdsClient
+        const { client: liMultiClient } = linkedInClient((url) => url.includes('pivot=CONVERSION')
+            ? {
+                body: {
+                    elements: [
+                        { externalWebsiteConversions: 4, pivotValues: ['urn:lla:llaPartnerConversion:30316052'] },
+                        { externalWebsiteConversions: 2, pivotValues: ['urn:lla:llaPartnerConversion:29325716'] },
+                        { externalWebsiteConversions: 9, pivotValues: ['urn:lla:llaPartnerConversion:99999999'] },
+                    ],
+                },
+            }
+            : { body: { elements: [{ impressions: 500, clicks: 20, landingPageClicks: 15, externalWebsiteConversions: 15, costInLocalCurrency: '10.00' }] } });
+        const liMulti = await liMultiClient.campaignAnalytics(['urn:li:sponsoredCampaign:2'], new Date('2026-10-01T00:00:00Z'), new Date('2026-10-14T00:00:00Z'), ['30316052', '29325716']);
+        expect(liMulti.externalWebsiteConversions).toBe(6);
+        const { client: gaMultiClient, calls: gaCalls } = googleClient((_url, body) => {
+            const q = body.query;
+            return q.includes('segments.conversion_action')
+                ? [{ results: [{ metrics: { allConversions: 2 } }, { metrics: { allConversions: 5 } }] }]
+                : [{ results: [{ metrics: { impressions: 800, clicks: 30, conversions: 0, costMicros: 15_000_000 } }] }];
+        });
+        const gaMulti = await gaMultiClient.campaignMetrics(['customers/4684433735/campaigns/1'], new Date('2026-10-01T00:00:00Z'), new Date('2026-10-14T00:00:00Z'), ['customers/4684433735/conversionActions/11', 'customers/4684433735/conversionActions/22']);
+        expect(gaMulti.conversions).toBe(7);
+        const gaSegmentedQuery = gaCalls.filter(c => c.url.includes('searchStream')).map(queryOf)[1];
+        expect(gaSegmentedQuery).toContain('SELECT segments.conversion_action, metrics.all_conversions');
+        expect(gaSegmentedQuery).toContain("AND segments.conversion_action IN ('customers/4684433735/conversionActions/11', 'customers/4684433735/conversionActions/22')");
+        const { client: maMultiClient } = metaClient(() => ({
+            data: [{
+                    impressions: '600',
+                    clicks: '25',
+                    spend: '14.0',
+                    actions: [
+                        { action_type: 'offsite_conversion.custom.111', value: '3' },
+                        { action_type: 'offsite_conversion.custom.222', value: '4' },
+                        { action_type: 'offsite_conversion.fb_pixel_lead', value: '19' },
+                    ],
+                }],
         }));
-        const program = {
-            id: 'prog-li-2',
+        const maMulti = await maMultiClient.adSetMetrics(['1'], new Date('2026-10-01T00:00:00Z'), new Date('2026-10-14T00:00:00Z'), ['111', '222']);
+        expect(maMulti.conversions).toBe(7);
+        // 4. Google & Meta drivers emit GA_STANDING_MEASURED_ONLY / MA_STANDING_MEASURED_ONLY ONLY on clicks-only programs (skipped when primary conversion is set)
+        const gaDriver = new GoogleAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-ga',
+            customerId: '4684433735',
+            brandAssets: null,
+            launchState: 'Paused',
+            client: {
+                conversionActions: async () => [{
+                        id: '7217103107',
+                        resourceName: 'customers/4684433735/conversionActions/7217103107',
+                        name: 'Purchase',
+                        enabled: true,
+                        category: 'PURCHASE',
+                        origin: 'WEBSITE',
+                        countsByDefault: true,
+                    }],
+                findConversionActionById: async (id) => id === '7845520214'
+                    ? {
+                        id: '7845520214',
+                        resourceName: 'customers/4684433735/conversionActions/7845520214',
+                        name: 'Book Demo Action',
+                        enabled: true,
+                        category: 'SUBMIT_LEAD_FORM',
+                        origin: 'WEBSITE',
+                        countsByDefault: false,
+                    }
+                    : null,
+            },
+        }), async () => [
+            {
+                id: standingId,
+                name: 'Self-Serve Checkout',
+                isActive: true,
+                attachToEveryCampaign: true,
+                binding: { externalId: '7217103107', cachedName: 'Purchase' },
+            },
+            {
+                id: boundId,
+                name: 'Book Demo',
+                isActive: true,
+                attachToEveryCampaign: false,
+                binding: { externalId: '7845520214', cachedName: 'Book Demo Action' },
+            },
+        ]);
+        const gaStandingIssues = await gaDriver.validateProposal(makeProg({ optimizeFor: 'clicks' }));
+        expect(gaStandingIssues.find(i => i.code === 'GA_STANDING_MEASURED_ONLY')).toMatchObject({ severity: 'notice' });
+        const gaPrimaryIssues = await gaDriver.validateProposal(makeProg({ brandConversionId: boundId, brandConversion: 'Book Demo' }));
+        expect(gaPrimaryIssues.find(i => i.code === 'GA_STANDING_MEASURED_ONLY')).toBeUndefined();
+        const maDriver = new MetaAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-ma',
+            adAccountId: 'act_2312673322359408',
+            pageId: '519210931614315',
+            pixelId: '415938279713144',
+            launchState: 'Paused',
+            client: {
+                customConversions: async () => [{
+                        id: '795683087750734',
+                        name: 'Purchase',
+                        enabled: true,
+                        customEventType: 'PURCHASE',
+                        pixelId: '415938279713144',
+                    }],
+                findCustomConversionById: async (id) => id === '888111222'
+                    ? { id: '888111222', name: 'Demo Lead', enabled: true, customEventType: 'LEAD', pixelId: '415938279713144' }
+                    : null,
+                findByName: async () => null,
+                createCampaign: async () => 'camp-1',
+                createAdSet: async () => 'adset-1',
+            },
+        }), async () => [
+            {
+                id: standingId,
+                name: 'Self-Serve Checkout',
+                isActive: true,
+                attachToEveryCampaign: true,
+                binding: { externalId: '795683087750734', cachedName: 'Purchase' },
+            },
+            {
+                id: boundId,
+                name: 'Book Demo',
+                isActive: true,
+                attachToEveryCampaign: false,
+                binding: { externalId: '888111222', cachedName: 'Demo Lead' },
+            },
+        ]);
+        const maStandingIssues = await maDriver.validateProposal(makeProg({ optimizeFor: 'clicks' }));
+        expect(maStandingIssues.find(i => i.code === 'MA_STANDING_MEASURED_ONLY')).toMatchObject({ severity: 'notice' });
+        const maPrimaryIssues = await maDriver.validateProposal(makeProg({ brandConversionId: boundId, brandConversion: 'Book Demo' }));
+        expect(maPrimaryIssues.find(i => i.code === 'MA_STANDING_MEASURED_ONLY')).toBeUndefined();
+        const maRefs = [];
+        maDriver['loadRefs'] = async () => [];
+        maDriver['runScheduleFor'] = async () => ({ start: 1_800_000_000_000 });
+        maDriver['saveRef'] = async (_pid, _bc, kind, _urn, state) => {
+            maRefs.push({ kind, state });
+        };
+        await maDriver.onLock(makeProg({ optimizeFor: 'clicks' }));
+        expect(maRefs.find(r => r.kind === 'Campaign')?.state).toMatchObject({
+            conversion: null,
+            optimizeFor: 'clicks',
+            standingConversions: [{
+                    brandConversionId: standingId,
+                    brandConversionName: 'Self-Serve Checkout',
+                    id: '795683087750734',
+                    name: 'Purchase',
+                }],
+        });
+        maRefs.length = 0;
+        await maDriver.onLock(makeProg({ brandConversionId: boundId, brandConversion: 'Book Demo' }));
+        const maPrimaryState = maRefs.find(r => r.kind === 'Campaign')?.state ?? {};
+        expect(maPrimaryState).toMatchObject({
+            brandConversionId: boundId,
+            brandConversion: { id: boundId, name: 'Book Demo' },
+            conversion: { id: '888111222', name: 'Demo Lead' },
+            optimizeFor: 'conversions',
+        });
+        expect(maPrimaryState['standingConversions']).toBeUndefined();
+    });
+    it('warns at propose (AD_BRAND_CONVERSION_LOOKUP_FAILED) and fails closed at lock when loadBrandConversions throws BrandConversionLookupError', async () => {
+        const fakeUser = { ID: 'u1' };
+        const failingLoader = async () => {
+            throw new BrandConversionLookupError('BrandConversions query failed: timeout');
+        };
+        const prog = {
+            id: 'prog-fail-closed',
             brandId: 'brand-1',
             hypothesis: 'h',
             metricName: 'Clicks',
             params: {
-                campaignCode: 'CP-10',
+                campaignCode: 'CP-FC',
                 tacticConfigJSON: JSON.stringify({
                     audience: 'targeted',
                     dailyBudgetUsd: 25,
@@ -655,51 +977,194 @@ describe('LinkedInAdsClient — conversions, URL conversion rules, and pivot=CON
                 }),
             },
         };
-        // 1. Propose emits LI_CONVERSION_UNKNOWN for unknown standing conversion
-        const unknownIssues = await driver.validateProposal(program);
-        expect(unknownIssues.some(i => i.code === 'LI_CONVERSION_UNKNOWN' && i.severity === 'error')).toBe(true);
-        // 2. onLock throws BEFORE creating CampaignGroup or Campaign (no KI-148 orphan)
-        driver['loadRefs'] = async () => [];
-        await expect(driver.onLock(program)).rejects.toThrow(/no standing conversion with id 99999999/);
-        expect(groupCreated).toBe(false);
-        expect(campaignCreated).toBe(false);
-        // 3. Connection-save helper refuses unknown ID, refuses missing rw_conversions scope, and resolves canonical names when valid
-        const missingRes = await driver.resolveStandingConversions({
+        const liDriver = new LinkedInAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-li',
+            adAccountId: '509410093',
+            launchState: 'Paused',
+            organizationUrn: 'urn:li:organization:900001',
+            defaultAudienceTemplateId: '70217227',
+            client: {
+                accountReference: async () => 'urn:li:organization:900001',
+                findAudienceTemplateById: async () => ({ id: '70217227', name: 'Execs', approximateMemberCount: 50_000, targetingCriteria: {} }),
+            },
+        }), failingLoader);
+        liDriver['loadRefs'] = async () => [];
+        const liIssues = await liDriver.validateProposal(prog);
+        expect(liIssues.find(i => i.code === 'AD_BRAND_CONVERSION_LOOKUP_FAILED')).toMatchObject({ severity: 'warning' });
+        await expect(liDriver.onLock(prog)).rejects.toThrow(BrandConversionLookupError);
+        const gaDriver = new GoogleAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-ga',
+            customerId: '4684433735',
+            brandAssets: null,
+            launchState: 'Paused',
+            client: { conversionActions: async () => [] },
+        }), failingLoader);
+        gaDriver['loadRefs'] = async () => [];
+        const gaIssues = await gaDriver.validateProposal(prog);
+        expect(gaIssues.find(i => i.code === 'AD_BRAND_CONVERSION_LOOKUP_FAILED')).toMatchObject({ severity: 'warning' });
+        await expect(gaDriver.onLock(prog)).rejects.toThrow(BrandConversionLookupError);
+        const maDriver = new MetaAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-ma',
+            adAccountId: 'act_2312673322359408',
+            pageId: '519210931614315',
+            pixelId: '415938279713144',
+            launchState: 'Paused',
+            client: { customConversions: async () => [] },
+        }), failingLoader);
+        maDriver['loadRefs'] = async () => [];
+        const maIssues = await maDriver.validateProposal(prog);
+        expect(maIssues.find(i => i.code === 'AD_BRAND_CONVERSION_LOOKUP_FAILED')).toMatchObject({ severity: 'warning' });
+        await expect(maDriver.onLock(prog)).rejects.toThrow(BrandConversionLookupError);
+    });
+    it('creates zero conversionRule or audience orphans on LinkedIn or Meta when a downstream preflight check refuses lock', async () => {
+        const fakeUser = { ID: 'u1' };
+        const standingId = '00000000-0000-4000-8000-000000000301';
+        let liUrlConversionCreated = false;
+        const liDriver = new LinkedInAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-li',
+            adAccountId: '509410093',
+            launchState: 'Paused',
+            organizationUrn: 'urn:li:organization:900001',
+            defaultAudienceTemplateId: '70217227',
+            client: {
+                accountReference: async () => 'urn:li:organization:900001',
+                tokenScopes: async () => ['r_ads', 'rw_ads', 'rw_conversions'],
+                conversions: async () => [],
+                findConversionByName: async () => null,
+                findAudienceTemplateById: async () => ({ id: '70217227', name: 'Execs', approximateMemberCount: 50_000, targetingCriteria: {} }),
+                createUrlConversion: async () => {
+                    liUrlConversionCreated = true;
+                    return { id: '999', urn: 'urn:lla:llaPartnerConversion:999', name: 'Created', type: 'LEAD', enabled: true };
+                },
+            },
+        }), async () => [{
+                id: standingId,
+                name: 'Broken Standing',
+                isActive: true,
+                attachToEveryCampaign: true,
+                binding: { externalId: 'missing-on-li', cachedName: 'Missing' },
+            }]);
+        liDriver['loadRefs'] = async () => [];
+        await expect(liDriver.onLock({
+            id: 'prog-li-orphan',
             brandId: 'brand-1',
-            credentialId: 'cred-1',
-            credentialName: 'LinkedIn Cred',
-            externalAccountId: '509410093',
-            requested: [{ ID: '99999999', Name: 'Stale' }],
-        });
-        expect(missingRes).toEqual({
-            ok: false,
-            message: expect.stringContaining('No conversion with id 99999999 on LinkedIn ad account 509410093'),
-        });
-        const validRes = await driver.resolveStandingConversions({
+            hypothesis: 'h',
+            metricName: 'Leads',
+            params: {
+                campaignCode: 'CP-ORPHAN',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/ebook',
+                    conversionRule: '/thank-you',
+                }),
+            },
+        })).rejects.toThrow(/standing Brand Conversion "Broken Standing"/);
+        expect(liUrlConversionCreated).toBe(false);
+        let metaUrlConversionCreated = false;
+        const maDriver = new MetaAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-ma',
+            adAccountId: 'act_2312673322359408',
+            pageId: '519210931614315',
+            pixelId: '415938279713144',
+            launchState: 'Paused',
+            client: {
+                findSavedAudienceById: async () => null,
+                findCustomConversionByName: async () => null,
+                createUrlCustomConversion: async () => {
+                    metaUrlConversionCreated = true;
+                    return { id: '888', name: 'Created', enabled: true, customEventType: 'LEAD', pixelId: '415938279713144' };
+                },
+            },
+        }), async () => []);
+        maDriver['loadRefs'] = async () => [];
+        await expect(maDriver.onLock({
+            id: 'prog-ma-orphan',
             brandId: 'brand-1',
-            credentialId: 'cred-1',
-            credentialName: 'LinkedIn Cred',
-            externalAccountId: '509410093',
-            requested: [{ ID: '30316052', Name: 'Caller Typed Label' }],
-        });
-        expect(validRes).toEqual({
+            hypothesis: 'h',
+            metricName: 'Leads',
+            params: {
+                campaignCode: 'CM-ORPHAN',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    audienceTemplateId: 'missing-saved-aud',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/ebook',
+                    conversionRule: '/thank-you',
+                }),
+            },
+        })).rejects.toThrow(/no saved audience with id missing-saved-aud/);
+        expect(metaUrlConversionCreated).toBe(false);
+    });
+    it('freezes conversion, brandConversionId, brandConversion, and optimizeFor on Meta re-lock and throws when updateRefState Save() returns false', async () => {
+        const fakeUser = { ID: 'u1' };
+        const origBrandConvId = '00000000-0000-4000-8000-000000000401';
+        const newBrandConvId = '00000000-0000-4000-8000-000000000402';
+        let saveOk = true;
+        const existingAdSetRow = {
+            ExternalKind: 'Campaign',
+            ExternalURN: 'adset-existing',
+            StateJSON: JSON.stringify({
+                brandConversionId: origBrandConvId,
+                brandConversion: { id: origBrandConvId, name: 'Original Goal' },
+                conversion: { id: '111', name: 'Original Pixel Event' },
+                optimizeFor: 'conversions',
+            }),
+            LatestResult: { CompleteMessage: 'simulated DB error' },
+            Save: async () => saveOk,
+        };
+        const maDriver = new MetaAdsProgramDriver(fakeUser, async () => ({
             ok: true,
-            conversions: [{ ID: '30316052', Name: 'Self-Serve Checkout' }],
-        });
-        scopes = ['r_ads', 'rw_ads'];
-        const noScopeRes = await driver.resolveStandingConversions({
+            brandConnectionId: 'bc-ma',
+            adAccountId: 'act_2312673322359408',
+            pageId: '519210931614315',
+            pixelId: '415938279713144',
+            launchState: 'Paused',
+            client: {
+                findCustomConversionById: async () => ({ id: '222', name: 'Renamed Event', enabled: true, customEventType: 'LEAD', pixelId: '415938279713144' }),
+                findByName: async () => null,
+            },
+        }), async () => [{
+                id: newBrandConvId,
+                name: 'Mutated Goal',
+                isActive: true,
+                attachToEveryCampaign: false,
+                binding: { externalId: '222', cachedName: 'Renamed Event' },
+            }]);
+        maDriver['loadRefs'] = async () => [
+            { ExternalKind: 'CampaignGroup', ExternalURN: 'camp-existing', StateJSON: null, Save: async () => true },
+            existingAdSetRow,
+        ];
+        const prog = {
+            id: 'prog-ma-freeze',
             brandId: 'brand-1',
-            credentialId: 'cred-1',
-            credentialName: 'LinkedIn Cred',
-            externalAccountId: '509410093',
-            requested: [{ ID: '30316052', Name: null }],
-        });
-        expect(noScopeRes).toEqual({
-            ok: false,
-            message: expect.stringContaining('rw_conversions'),
+            hypothesis: 'h',
+            metricName: 'Leads',
+            params: {
+                campaignCode: 'CM-FRZ',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/ebook',
+                    brandConversionId: newBrandConvId,
+                    brandConversion: 'Mutated Goal',
+                }),
+            },
+        };
+        await maDriver.onLock(prog);
+        expect(JSON.parse(existingAdSetRow.StateJSON)).toMatchObject({
+            brandConversionId: origBrandConvId,
+            brandConversion: { id: origBrandConvId, name: 'Original Goal' },
+            conversion: { id: '111', name: 'Original Pixel Event' },
+            optimizeFor: 'conversions',
         });
-        const noScopeIssues = await driver.validateProposal(program);
-        expect(noScopeIssues.some(i => i.code === 'LI_CONVERSION_SCOPE' && i.severity === 'error')).toBe(true);
+        saveOk = false;
+        await expect(maDriver.onLock(prog)).rejects.toThrow(/simulated DB error/);
     });
     it('keeps Google campaigns on account-default CUSTOMER goals under Maximize clicks (G1) and updates adopted campaigns only after platform writes succeed', async () => {
         const fakeUser = { ID: 'u1' };
@@ -741,7 +1206,7 @@ describe('LinkedInAdsClient — conversions, URL conversion rules, and pivot=CON
                 setCampaignConversionGoal: async () => { customGoalCalled = true; },
                 createAdGroup: async () => 'customers/4684433735/adGroups/22',
             },
-        }));
+        }), async () => []);
         const proposalIssues = await driver.validateProposal({
             id: 'prog-ga-1',
             brandId: 'brand-1',
@@ -807,5 +1272,146 @@ describe('LinkedInAdsClient — conversions, URL conversion rules, and pivot=CON
         });
         expect(JSON.parse(campaignRowAfterFail.StateJSON).conversionGoal).toBeUndefined();
     });
+    it('attaches offsite_conversion tracking_specs on newly created Meta clicks ads (2B-all), omits them on primary-conversion ads, and refuses standing conversions without a Pixel (MA_CONVERSION_NO_PIXEL)', async () => {
+        // 1. MetaAdsClient.createAd serializes deduped tracking_specs when trackingPixelIds is non-empty and omits when empty
+        const { client, calls } = metaClient(() => ({ id: 'ad-901' }));
+        await client.createAd({
+            name: 'CM-01 — ad',
+            adSetId: 'adset-1',
+            creativeId: 'creative-1',
+            status: 'PAUSED',
+            trackingPixelIds: [' 415938279713144 ', '415938279713144', '998877665544332'],
+        });
+        expect(JSON.parse(calls[0].body.get('tracking_specs'))).toEqual([
+            { 'action.type': ['offsite_conversion'], fb_pixel: ['415938279713144', '998877665544332'] },
+        ]);
+        await client.createAd({
+            name: 'CM-02 — ad',
+            adSetId: 'adset-2',
+            creativeId: 'creative-2',
+            status: 'PAUSED',
+        });
+        expect(calls[1].body.has('tracking_specs')).toBe(false);
+        // 2. MetaAdsProgramDriver.onLock passes trackingPixelIds on clicks programs (both with standing conversions and with credential pixelId alone) and omits on primary-conversion programs
+        const fakeUser = { ID: 'u1' };
+        const standingId = '00000000-0000-4000-8000-000000000501';
+        const primaryId = '00000000-0000-4000-8000-000000000502';
+        const createAdPayloads = [];
+        const savedRefs = [];
+        let configuredConversions = [
+            {
+                id: standingId,
+                name: 'Standing Checkout',
+                isActive: true,
+                attachToEveryCampaign: true,
+                binding: { externalId: '777001', cachedName: 'Checkout Event' },
+            },
+            {
+                id: primaryId,
+                name: 'Primary Demo',
+                isActive: true,
+                attachToEveryCampaign: false,
+                binding: { externalId: '777002', cachedName: 'Demo Event' },
+            },
+        ];
+        const makeDriver = (pixelId, customConversionPixelId) => {
+            const d = new MetaAdsProgramDriver(fakeUser, async () => ({
+                ok: true,
+                brandConnectionId: 'bc-ma',
+                adAccountId: 'act_100200300',
+                pageId: 'page-1',
+                pixelId,
+                launchState: 'Paused',
+                client: {
+                    customConversions: async () => [
+                        { id: '777001', name: 'Checkout Event', enabled: true, customEventType: 'PURCHASE', pixelId: customConversionPixelId },
+                    ],
+                    findCustomConversionById: async (id) => id === '777002'
+                        ? { id: '777002', name: 'Demo Event', enabled: true, customEventType: 'LEAD', pixelId: customConversionPixelId ?? '111222333' }
+                        : null,
+                    findByName: async () => null,
+                    createCampaign: async () => 'camp-1',
+                    createAdSet: async () => 'adset-1',
+                    createCreative: async () => 'creative-1',
+                    createAd: async (opts) => {
+                        createAdPayloads.push(opts);
+                        return 'ad-1';
+                    },
+                },
+            }), async () => configuredConversions);
+            d['loadRefs'] = async () => [];
+            d['runScheduleFor'] = async () => ({ start: 1_800_000_000_000 });
+            d['resolveImage'] = async () => ({ imageHash: null, imageNote: 'link ad without an image' });
+            d['saveRef'] = async (_pid, _bc, kind, urn, state) => {
+                savedRefs.push({ kind, urn, state });
+            };
+            return d;
+        };
+        const makeClicksOrConvProgram = (extra) => ({
+            id: 'prog-ma-2b',
+            brandId: 'brand-1',
+            hypothesis: 'h',
+            metricName: 'Clicks',
+            params: {
+                campaignCode: 'CM-2B',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/guide',
+                    creativeHeadlines: ['Practical Guide'],
+                    creativeDescriptions: ['Read the guide'],
+                    ...extra,
+                }),
+            },
+        });
+        // 2a. Clicks + standing conversion with a second pixel -> deduped [ctx.pixelId, conversion.pixelId]
+        const driverWithStanding = makeDriver('111222333', '444555666');
+        const standingNoticeIssues = await driverWithStanding.validateProposal(makeClicksOrConvProgram({ optimizeFor: 'clicks' }));
+        expect(standingNoticeIssues.find(i => i.code === 'MA_STANDING_MEASURED_ONLY')?.message).toContain('counts appear once ads serve');
+        await driverWithStanding.onLock(makeClicksOrConvProgram({ optimizeFor: 'clicks' }));
+        expect(createAdPayloads[0]).toMatchObject({ trackingPixelIds: ['111222333', '444555666'] });
+        expect(savedRefs.find(r => r.kind === 'Other')?.state).toMatchObject({
+            role: 'ad',
+            trackingPixelIds: ['111222333', '444555666'],
+        });
+        // 2b. Clicks + 0 standing conversions + ctx.pixelId (2B-all) -> [ctx.pixelId] still attached
+        createAdPayloads.length = 0;
+        savedRefs.length = 0;
+        configuredConversions = [];
+        const driverClicksOnly = makeDriver('111222333', null);
+        await driverClicksOnly.onLock(makeClicksOrConvProgram({ optimizeFor: 'clicks' }));
+        expect(createAdPayloads[0]).toMatchObject({ trackingPixelIds: ['111222333'] });
+        expect(savedRefs.find(r => r.kind === 'Other')?.state).toMatchObject({
+            role: 'ad',
+            trackingPixelIds: ['111222333'],
+        });
+        // 2c. Primary conversion program -> omits trackingPixelIds on createAd (ad set carries promoted_object)
+        createAdPayloads.length = 0;
+        savedRefs.length = 0;
+        configuredConversions = [{
+                id: primaryId,
+                name: 'Primary Demo',
+                isActive: true,
+                attachToEveryCampaign: false,
+                binding: { externalId: '777002', cachedName: 'Demo Event' },
+            }];
+        const driverPrimary = makeDriver('111222333', '444555666');
+        await driverPrimary.onLock(makeClicksOrConvProgram({ brandConversionId: primaryId, brandConversion: 'Primary Demo' }));
+        expect(createAdPayloads[0]['trackingPixelIds']).toBeUndefined();
+        expect(savedRefs.find(r => r.kind === 'Other')?.state?.['trackingPixelIds']).toBeUndefined();
+        // 3. Standing conversion with neither conversion.pixelId nor ctx.pixelId -> MA_CONVERSION_NO_PIXEL at propose and refusal at lock
+        configuredConversions = [{
+                id: standingId,
+                name: 'Pixel-less Standing',
+                isActive: true,
+                attachToEveryCampaign: true,
+                binding: { externalId: '777001', cachedName: 'Checkout Event' },
+            }];
+        const driverNoPixel = makeDriver(null, null);
+        const noPixelIssues = await driverNoPixel.validateProposal(makeClicksOrConvProgram({ optimizeFor: 'clicks' }));
+        expect(noPixelIssues.find(i => i.code === 'MA_CONVERSION_NO_PIXEL')).toMatchObject({ severity: 'error' });
+        expect(noPixelIssues.find(i => i.code === 'MA_STANDING_MEASURED_ONLY')).toBeUndefined();
+        await expect(driverNoPixel.onLock(makeClicksOrConvProgram({ optimizeFor: 'clicks' }))).rejects.toThrow(/names no Pixel and the Meta Ads credential carries none/);
+    });
 });
 //# sourceMappingURL=adConversionParity.test.js.map