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

package/dist/__tests__/adConversionParity.test.js

@@ -1,7 +1,11 @@
 import { describe, expect, it } from 'vitest';
 import { GoogleAdsClient } from '../programs/google/GoogleAdsClient.js';
+import { buildGoogleCampaignTargetingState, GoogleAdsProgramDriver } from '../programs/google/GoogleAdsProgramDriver.js';
+import { LinkedInAdsClient, linkedInConversionTypeFor } from '../programs/linkedin/LinkedInAdsClient.js';
+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) => {
@@ -37,11 +41,17 @@ describe('GoogleAdsClient — conversion actions (D-34 parity)', () => {
         const create = calls.find(c => c.url.includes('customConversionGoals:mutate'));
         expect(JSON.parse(String(create.init?.body))).toEqual({ operations: [{ create: { name: 'Marketing: Ascend Book Download - Google - Form Submission', conversionActions: ['customers/4684433735/conversionActions/7845520214'], status: 'ENABLED' } }] });
         await client.setCampaignConversionGoal('customers/4684433735/campaigns/24313683017', goal);
-        const point = calls.find(c => c.url.includes('conversionGoalCampaignConfigs:mutate'));
-        expect(JSON.parse(String(point.init?.body))).toEqual({ operations: [{
+        const goalConfigCalls = calls.filter(c => c.url.includes('conversionGoalCampaignConfigs:mutate'));
+        expect(JSON.parse(String(goalConfigCalls[0].init?.body))).toEqual({ operations: [{
                     update: { resourceName: 'customers/4684433735/conversionGoalCampaignConfigs/24313683017', goalConfigLevel: 'CAMPAIGN', customConversionGoal: goal },
                     updateMask: 'goal_config_level,custom_conversion_goal',
                 }] });
+        await client.useCustomerConversionGoals('customers/4684433735/campaigns/24313683017');
+        const customerGoalCalls = calls.filter(c => c.url.includes('conversionGoalCampaignConfigs:mutate'));
+        expect(JSON.parse(String(customerGoalCalls[1].init?.body))).toEqual({ operations: [{
+                    update: { resourceName: 'customers/4684433735/conversionGoalCampaignConfigs/24313683017', goalConfigLevel: 'CUSTOMER' },
+                    updateMask: 'goal_config_level',
+                }] });
         // Google allows ONE goal per action list on the customer: an existing goal holding exactly this action is reused
         // as is (whoever made it, whatever its name), a goal holding more actions is not a match.
         const { client: adoptingClient, calls: adoptCalls } = googleClient(() => [{ results: [
@@ -63,7 +73,7 @@ describe('GoogleAdsClient — conversion actions (D-34 parity)', () => {
         const queries = calls.filter(c => c.url.includes('searchStream')).map(queryOf);
         expect(queries).toHaveLength(2);
         expect(queries[0]).not.toContain('segments.conversion_action');
-        expect(queries[1]).toContain("SELECT metrics.all_conversions FROM campaign WHERE campaign.resource_name IN ('customers/4684433735/campaigns/1') AND segments.date BETWEEN '2026-10-01' AND '2026-10-14' AND segments.conversion_action = 'customers/4684433735/conversionActions/7845520214'");
+        expect(queries[1]).toContain("SELECT segments.conversion_action, metrics.all_conversions FROM campaign WHERE campaign.resource_name IN ('customers/4684433735/campaigns/1') AND segments.date BETWEEN '2026-10-01' AND '2026-10-14' AND segments.conversion_action = 'customers/4684433735/conversionActions/7845520214'");
         const plain = await client.campaignMetrics(['customers/4684433735/campaigns/1'], new Date('2026-10-01T00:00:00Z'), new Date('2026-10-14T00:00:00Z'));
         expect(plain.conversions).toBe(0);
         expect(calls.filter(c => c.url.includes('searchStream'))).toHaveLength(3);
@@ -174,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'],
@@ -194,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' },
@@ -248,10 +326,1092 @@ describe('GoogleAdsClient — user lists, geo targeting, and schedule dates (KI-
         const createBody = JSON.parse(String(calls[1].init?.body));
         expect(createBody.operations[0].create['startDate']).toBe('2026-11-01');
         expect(createBody.operations[0].create['endDate']).toBe('2026-11-15');
+        expect(createBody.operations[0].create['targetSpend']).toEqual({ cpcBidCeilingMicros: '2000000' });
+        expect(createBody.operations[0].create['geoTargetTypeSetting']).toEqual({ positiveGeoTargetType: 'PRESENCE' });
         await client.setCampaignSchedule('customers/4684433735/campaigns/99', { start, end: new Date('2026-11-22T00:00:00Z').getTime() });
         const updateBody = JSON.parse(String(calls[2].init?.body));
         expect(updateBody.operations[0].update['endDate']).toBe('2026-11-22');
         expect(updateBody.operations[0].updateMask).toContain('end_date');
     });
+    it('attaches multi-location, language, and negative mobile-app criteria idempotently and updates delivery settings (D-37, KI-164)', async () => {
+        const { client, calls } = googleClient((url, body) => {
+            if (url.includes('campaignCriteria:mutate') || url.includes('campaigns:mutate')) {
+                return { results: [{ resourceName: 'customers/4684433735/campaignCriteria/99~1' }] };
+            }
+            const q = body.query;
+            if (q.includes('campaign_criterion.location.geo_target_constant')) {
+                return [{ results: [{ campaignCriterion: { location: { geoTargetConstant: 'geoTargetConstants/2840' } } }] }];
+            }
+            return [];
+        });
+        await client.attachCampaignLocations('customers/4684433735/campaigns/99', ['geoTargetConstants/2840', 'geoTargetConstants/2124']);
+        const locMutate = calls.find(c => c.url.includes('campaignCriteria:mutate'));
+        expect(JSON.parse(String(locMutate.init?.body))).toEqual({
+            operations: [{ create: { campaign: 'customers/4684433735/campaigns/99', location: { geoTargetConstant: 'geoTargetConstants/2124' } } }],
+        });
+        await client.attachCampaignLanguages('customers/4684433735/campaigns/99', ['languageConstants/1000']);
+        const criteriaMutates = calls.filter(c => c.url.includes('campaignCriteria:mutate'));
+        expect(JSON.parse(String(criteriaMutates[1].init?.body))).toEqual({
+            operations: [{ create: { campaign: 'customers/4684433735/campaigns/99', language: { languageConstant: 'languageConstants/1000' } } }],
+        });
+        await client.excludeCampaignMobileApps('customers/4684433735/campaigns/99');
+        const criteriaMutatesAfterExclude = calls.filter(c => c.url.includes('campaignCriteria:mutate'));
+        expect(JSON.parse(String(criteriaMutatesAfterExclude[2].init?.body))).toEqual({
+            operations: [{
+                    create: {
+                        campaign: 'customers/4684433735/campaigns/99',
+                        negative: true,
+                        mobileAppCategory: { mobileAppCategoryConstant: 'mobileAppCategoryConstants/69500' },
+                    },
+                }],
+        });
+        await client.updateCampaignDeliverySettings('customers/4684433735/campaigns/99', { maxCpcUsd: 2 });
+        const campaignMutates = calls.filter(c => c.url.includes('campaigns:mutate'));
+        expect(JSON.parse(String(campaignMutates[0].init?.body))).toEqual({
+            operations: [{
+                    update: {
+                        resourceName: 'customers/4684433735/campaigns/99',
+                        targetSpend: { cpcBidCeilingMicros: '2000000' },
+                        geoTargetTypeSetting: { positiveGeoTargetType: 'PRESENCE' },
+                    },
+                    updateMask: 'target_spend.cpc_bid_ceiling_micros,geo_target_type_setting.positive_geo_target_type',
+                }],
+        });
+        await client.setCampaignMaximizeConversions('customers/4684433735/campaigns/99');
+        const campaignMutatesAfterMaxConv = calls.filter(c => c.url.includes('campaigns:mutate'));
+        expect(JSON.parse(String(campaignMutatesAfterMaxConv[1].init?.body))).toEqual({
+            operations: [{
+                    update: {
+                        resourceName: 'customers/4684433735/campaigns/99',
+                        maximizeConversions: {},
+                    },
+                    updateMask: 'maximize_conversions',
+                }],
+        });
+        expect(buildGoogleCampaignTargetingState({
+            maxCpcUsd: 2,
+            locationsAttached: ['geoTargetConstants/2840', 'geoTargetConstants/2124'],
+            languagesAttached: ['languageConstants/1000'],
+            mobileAppsExcluded: true,
+        })).toEqual({
+            bidding: 'TARGET_SPEND',
+            maxCpcUsd: 2,
+            positiveGeoTargetType: 'PRESENCE',
+            locationsAttached: ['geoTargetConstants/2840', 'geoTargetConstants/2124'],
+            languagesAttached: ['languageConstants/1000'],
+            mobileAppsExcluded: true,
+        });
+    });
+    it('emits notice-level parity issues when Google-only targeting/bidding levers are passed to LinkedIn or Meta (D-37)', async () => {
+        const tacticConfigJSON = JSON.stringify({
+            audience: 'targeted',
+            dailyBudgetUsd: 25,
+            maxCpcUsd: 2,
+            locations: ['US', 'CA'],
+            languages: ['en'],
+            landingPageUrl: 'https://example.org/ai',
+            optimizeFor: 'clicks',
+            creativeHeadlines: ['Master AI Strategy', 'AI Roadmap for Leaders'],
+            creativeDescriptions: ['Download the free ebook.'],
+        });
+        const liDriver = new LinkedInAdsProgramDriver();
+        const liIssues = await liDriver.validateProposal({ id: 'P1', brandId: 'B1', params: { campaignCode: 'CL-01', tacticConfigJSON } });
+        expect(liIssues.map(i => [i.code, i.severity])).toEqual([
+            ['LI_MAX_CPC_IGNORED', 'notice'],
+            ['LI_LOCATIONS_IN_AUDIENCE', 'notice'],
+            ['LI_LANGUAGES_IN_AUDIENCE', 'notice'],
+        ]);
+        const metaDriver = new MetaAdsProgramDriver();
+        const metaIssues = await metaDriver.validateProposal({ id: 'P2', brandId: 'B1', params: { campaignCode: 'CM-01', tacticConfigJSON } });
+        expect(metaIssues.map(i => [i.code, i.severity])).toEqual([
+            ['MA_MAX_CPC_IGNORED', 'notice'],
+            ['MA_LOCATIONS_IGNORED', 'notice'],
+            ['MA_LANGUAGES_IGNORED', 'notice'],
+        ]);
+    });
+});
+function linkedInClient(answer) {
+    const calls = [];
+    const fetchImpl = (async (input, init) => {
+        const url = String(input);
+        calls.push({ url, init });
+        if (url.endsWith('/accessToken')) {
+            return new Response(JSON.stringify({ access_token: 'li-tok', expires_in: 3600, scope: 'r_ads,rw_ads,r_ads_reporting,rw_dmp_segments,rw_conversions' }), { status: 200 });
+        }
+        const res = answer(url, init);
+        return new Response(res.body === null ? null : JSON.stringify(res.body), {
+            status: res.status ?? 200,
+            headers: res.headers,
+        });
+    });
+    return { client: new LinkedInAdsClient({ clientId: 'c', clientSecret: 's', refreshToken: 'r', adAccountId: '509410093', fetchImpl }), calls };
+}
+describe('LinkedInAdsClient — conversions, URL conversion rules, and pivot=CONVERSION analytics (D-34, KI-148, KI-152)', () => {
+    it('lists conversions, adopts an enabled conversion by name, creates a URL conversion rule, and maps every CTA to LinkedIn ConversionType', async () => {
+        const { client, calls } = linkedInClient((url, init) => {
+            if (init?.method === 'POST' && url.endsWith('/rest/conversions')) {
+                return { status: 201, headers: { 'x-restli-id': '32001001' }, body: {} };
+            }
+            if (init?.method === 'PUT' && url.includes('/rest/campaignConversions/')) {
+                return { status: 204, body: null };
+            }
+            return {
+                body: {
+                    elements: [
+                        { id: 29519276, name: 'SC | Ascend Download', type: 'DOWNLOAD', enabled: true },
+                        { id: 29325716, name: 'CP-04 — lead conversion', type: 'LEAD', enabled: true },
+                        { id: 100, name: 'CP-05 — lead conversion', type: 'LEAD', enabled: false },
+                    ],
+                },
+            };
+        });
+        const list = await client.conversions();
+        expect(list).toEqual([
+            { id: '29519276', urn: 'urn:lla:llaPartnerConversion:29519276', name: 'SC | Ascend Download', type: 'DOWNLOAD', enabled: true },
+            { id: '29325716', urn: 'urn:lla:llaPartnerConversion:29325716', name: 'CP-04 — lead conversion', type: 'LEAD', enabled: true },
+            { id: '100', urn: 'urn:lla:llaPartnerConversion:100', name: 'CP-05 — lead conversion', type: 'LEAD', enabled: false },
+        ]);
+        expect(await client.findConversionById(' 29519276 ')).toMatchObject({ id: '29519276', name: 'SC | Ascend Download' });
+        expect(await client.findConversionByName('CP-04 — lead conversion')).toMatchObject({ id: '29325716', urn: 'urn:lla:llaPartnerConversion:29325716' });
+        // Disabled conversions are not adopted by name
+        expect(await client.findConversionByName('CP-05 — lead conversion')).toBeNull();
+        const created = await client.createUrlConversion({
+            name: 'CP-06 — lead conversion',
+            urlContains: '/ebook-thank-you',
+            type: linkedInConversionTypeFor('DOWNLOAD'),
+        });
+        expect(created).toEqual({
+            id: '32001001',
+            urn: 'urn:lla:llaPartnerConversion:32001001',
+            name: 'CP-06 — lead conversion',
+            type: 'DOWNLOAD',
+            enabled: true,
+        });
+        const postCall = calls.find(c => c.init?.method === 'POST' && c.url.endsWith('/rest/conversions'));
+        expect(JSON.parse(String(postCall.init?.body))).toEqual({
+            account: 'urn:li:sponsoredAccount:509410093',
+            name: 'CP-06 — lead conversion',
+            type: 'DOWNLOAD',
+            conversionMethod: 'INSIGHT_TAG_URL_MATCH_RULES',
+            postClickAttributionWindowSize: 30,
+            viewThroughAttributionWindowSize: 7,
+            attributionType: 'LAST_TOUCH_BY_CONVERSION',
+            urlMatchRuleExpression: [[{ matchType: 'CONTAINS', matchValue: '/ebook-thank-you' }]],
+        });
+        await client.associateConversion('urn:li:sponsoredCampaign:919676896', created.urn);
+        const putCall = calls.find(c => c.init?.method === 'PUT' && c.url.includes('/rest/campaignConversions/'));
+        expect(putCall.url).toContain('(campaign:urn%3Ali%3AsponsoredCampaign%3A919676896,conversion:urn%3Alla%3AllaPartnerConversion%3A32001001)');
+        let putAttempts = 0;
+        const { client: retryClient } = linkedInClient((url) => {
+            if (url.includes('/rest/campaignConversions/')) {
+                putAttempts++;
+                if (putAttempts === 1)
+                    return { status: 404, body: { message: 'Requester does not have permission to UPDATE the resource.', status: 404 } };
+                return { status: 204, body: null };
+            }
+            return { body: { elements: [] } };
+        });
+        await retryClient.associateConversion('urn:li:sponsoredCampaign:898478323', created.urn, [1]);
+        expect(putAttempts).toBe(2);
+        expect(linkedInConversionTypeFor('DOWNLOAD')).toBe('DOWNLOAD');
+        expect(linkedInConversionTypeFor('REGISTER')).toBe('REGISTER_EVENT');
+        expect(linkedInConversionTypeFor('ATTEND')).toBe('REGISTER_EVENT');
+        expect(linkedInConversionTypeFor('SUBSCRIBE')).toBe('SUBSCRIBE');
+        expect(linkedInConversionTypeFor('SIGN_UP')).toBe('SIGN_UP');
+        expect(linkedInConversionTypeFor('JOIN')).toBe('SIGN_UP');
+        expect(linkedInConversionTypeFor('VIEW_QUOTE')).toBe('REQUEST_QUOTE');
+        expect(linkedInConversionTypeFor('REQUEST_DEMO')).toBe('LEAD');
+        expect(linkedInConversionTypeFor('LEARN_MORE')).toBe('LEAD');
+        expect(linkedInConversionTypeFor(null)).toBe('LEAD');
+    });
+    it('scopes externalWebsiteConversions via pivot=CONVERSION when conversionId is provided, and uses pivot=CAMPAIGN alone for clicks programs (D-34 addendum)', async () => {
+        const { client, calls } = linkedInClient((url) => {
+            if (url.includes('pivot=CONVERSION')) {
+                return {
+                    body: {
+                        elements: [
+                            { externalWebsiteConversions: 5, pivotValues: ['urn:lla:llaPartnerConversion:25692636'] },
+                            { externalWebsiteConversions: 2, pivotValues: ['urn:lla:llaPartnerConversion:29519276'] },
+                            { externalWebsiteConversions: 1, pivotValues: ['urn:lla:llaPartnerConversion:18994420'] },
+                        ],
+                    },
+                };
+            }
+            return {
+                body: {
+                    elements: [
+                        { impressions: 1400, clicks: 35, landingPageClicks: 28, externalWebsiteConversions: 8, costInLocalCurrency: '42.75' },
+                    ],
+                },
+            };
+        });
+        const scoped = await client.campaignAnalytics(['urn:li:sponsoredCampaign:919676896'], new Date('2026-11-01T00:00:00Z'), new Date('2026-11-15T00:00:00Z'), '29519276');
+        expect(scoped).toEqual({
+            impressions: 1400,
+            clicks: 35,
+            landingPageClicks: 28,
+            externalWebsiteConversions: 2,
+            spendUsd: 42.75,
+        });
+        const analyticsCalls = calls.filter(c => c.url.includes('/adAnalytics'));
+        expect(analyticsCalls).toHaveLength(2);
+        expect(analyticsCalls[0].url).toContain('pivot=CAMPAIGN');
+        expect(analyticsCalls[1].url).toContain('pivot=CONVERSION');
+        expect(analyticsCalls[1].url).toContain('fields=externalWebsiteConversions,pivotValues');
+        const unsegmented = await client.campaignAnalytics(['urn:li:sponsoredCampaign:919676896'], new Date('2026-11-01T00:00:00Z'), new Date('2026-11-15T00:00:00Z'));
+        expect(unsegmented.externalWebsiteConversions).toBe(8);
+        expect(calls.filter(c => c.url.includes('/adAnalytics'))).toHaveLength(3);
+    });
+    it('refuses conversionRule on Google Ads with GA_CONVERSION_RULE_UNSUPPORTED (driver parity)', async () => {
+        const gDriver = new GoogleAdsProgramDriver();
+        const tacticConfigJSON = JSON.stringify({
+            audience: 'targeted',
+            dailyBudgetUsd: 25,
+            landingPageUrl: 'https://example.org/ai',
+            conversionRule: '/ebook-thank-you',
+            creativeHeadlines: ['Master AI Strategy'],
+            creativeDescriptions: ['Download the free ebook.'],
+        });
+        const issues = await gDriver.validateProposal({ id: 'P3', brandId: 'B1', params: { campaignCode: 'CG-05', tacticConfigJSON } });
+        expect(issues.find(i => i.code === 'GA_CONVERSION_RULE_UNSUPPORTED')).toMatchObject({
+            severity: 'error',
+            code: 'GA_CONVERSION_RULE_UNSUPPORTED',
+        });
+    });
+    it('detaches a conversion via DELETE /campaignConversions and treats 404 as already detached', async () => {
+        let count = 0;
+        const { client, calls } = linkedInClient((url, init) => {
+            if (init?.method === 'DELETE' && url.includes('/rest/campaignConversions/')) {
+                count += 1;
+                return count === 1 ? { status: 204, body: null } : { status: 404, body: { message: 'Not found' } };
+            }
+            return { body: {} };
+        });
+        await client.disassociateConversion('urn:li:sponsoredCampaign:910066056', 'urn:lla:llaPartnerConversion:18994420');
+        await client.disassociateConversion('urn:li:sponsoredCampaign:910066056', 'urn:lla:llaPartnerConversion:18994420');
+        const deletes = calls.filter(c => c.init?.method === 'DELETE');
+        expect(deletes).toHaveLength(2);
+        expect(deletes[0].url).toContain('/rest/campaignConversions/(campaign:urn%3Ali%3AsponsoredCampaign%3A910066056,conversion:urn%3Alla%3AllaPartnerConversion%3A18994420)');
+    });
+    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' };
+        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,
+            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 () => [
+                    { 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 },
+                ],
+                findAudienceTemplateById: async () => ({ id: '70217227', name: 'Execs', approximateMemberCount: 50_000, targetingCriteria: {} }),
+                createCampaignGroup: async () => 'urn:li:sponsoredCampaignGroup:1',
+                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) => {
+            savedRefs.push({ kind, urn, state });
+        };
+        const program = {
+            id: 'prog-li-1',
+            brandId: 'brand-1',
+            hypothesis: 'h',
+            metricName: 'Clicks',
+            params: {
+                campaignCode: 'CP-09',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/ebook',
+                    optimizeFor: 'clicks',
+                }),
+            },
+        };
+        await driver.onLock(program);
+        expect(associated).toEqual([
+            ['urn:li:sponsoredCampaign:2', 'urn:lla:llaPartnerConversion:30316052'],
+            ['urn:li:sponsoredCampaign:2', 'urn:lla:llaPartnerConversion:29325716'],
+        ]);
+        const campaignRef = savedRefs.find(r => r.kind === 'Campaign');
+        expect(campaignRef?.state).toMatchObject({
+            conversion: null,
+            optimizeFor: 'clicks',
+            objective: 'WEBSITE_VISIT',
+            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 turning off AttachToEveryCampaign on Book Demo: detaches 29325716 and updates StateJSON.standingConversions.
+        associated.length = 0;
+        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',
+            StateJSON: JSON.stringify(campaignRef?.state ?? {}),
+            Save: async () => true,
+        };
+        driver['loadRefs'] = async () => [
+            { ExternalKind: 'CampaignGroup', ExternalURN: 'urn:li:sponsoredCampaignGroup:1', StateJSON: null, Save: async () => true },
+            existingCampaignRow,
+        ];
+        await driver.onLock(program);
+        expect(disassociated).toEqual([
+            ['urn:li:sponsoredCampaign:2', 'urn:lla:llaPartnerConversion:29325716'],
+        ]);
+        expect(associated).toEqual([
+            ['urn:li:sponsoredCampaign:2', 'urn:lla:llaPartnerConversion:30316052'],
+        ]);
+        expect(JSON.parse(existingCampaignRow.StateJSON)).toMatchObject({
+            conversion: null,
+            optimizeFor: 'clicks',
+            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('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' };
+        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',
+            client: {
+                accountReference: async () => 'urn:li:organization:900001',
+                tokenScopes: async () => ['r_ads', 'rw_ads', 'rw_conversions'],
+                conversions: async () => [
+                    { 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 () => { 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 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-FC',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/ebook',
+                    optimizeFor: 'clicks',
+                }),
+            },
+        };
+        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',
+            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',
+            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,
+            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',
+            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',
+        });
+        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' };
+        const deliveryCalls = [];
+        const customerGoalCalls = [];
+        let customGoalCalled = false;
+        let shouldFailDeliveryUpdate = true;
+        const storedRefs = [];
+        const driver = new GoogleAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-ga',
+            customerId: '4684433735',
+            brandAssets: null,
+            launchState: 'Paused',
+            defaultLocations: ['US', 'CA'],
+            defaultLanguages: ['en'],
+            client: {
+                findConversionActionById: async () => ({
+                    id: '7845520214',
+                    name: 'Ebook Form Submit',
+                    resourceName: 'customers/4684433735/conversionActions/7845520214',
+                    enabled: true,
+                    countsByDefault: false,
+                }),
+                findByName: async (resource) => resource === 'campaign' ? 'customers/4684433735/campaigns/777' : null,
+                createCampaignBudget: async () => 'customers/4684433735/campaignBudgets/11',
+                updateCampaignDeliverySettings: async (camp, opts) => {
+                    deliveryCalls.push([camp, opts]);
+                    if (shouldFailDeliveryUpdate)
+                        throw new Error('Simulated delivery update failure');
+                },
+                useCustomerConversionGoals: async (camp) => {
+                    customerGoalCalls.push(camp);
+                },
+                attachCampaignLocations: async () => { },
+                attachCampaignLanguages: async () => { },
+                excludeCampaignMobileApps: async () => { },
+                ensureCustomConversionGoal: async () => { customGoalCalled = true; return 'customers/4684433735/customConversionGoals/6459709271'; },
+                setCampaignConversionGoal: async () => { customGoalCalled = true; },
+                createAdGroup: async () => 'customers/4684433735/adGroups/22',
+            },
+        }), async () => []);
+        const proposalIssues = await driver.validateProposal({
+            id: 'prog-ga-1',
+            brandId: 'brand-1',
+            hypothesis: 'h',
+            metricName: 'Downloads',
+            params: {
+                campaignCode: 'CG-09',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/ebook',
+                    conversionId: '7845520214',
+                }),
+            },
+        });
+        expect(proposalIssues).toEqual([]);
+        driver['loadRefs'] = async () => storedRefs;
+        driver['runScheduleFor'] = async () => ({ start: 1_800_000_000_000 });
+        driver['saveRef'] = async (_pid, _bc, kind, urn, state) => {
+            const row = {
+                ExternalKind: kind,
+                ExternalURN: urn,
+                StateJSON: state ? JSON.stringify(state) : null,
+                Save: async () => true,
+            };
+            storedRefs.push(row);
+            return row;
+        };
+        const programArg = {
+            id: 'prog-ga-1',
+            brandId: 'brand-1',
+            hypothesis: 'h',
+            metricName: 'Downloads',
+            params: {
+                campaignCode: 'CG-09',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    maxCpcUsd: 2,
+                    landingPageUrl: 'https://example.org/ebook',
+                    conversionId: '7845520214',
+                }),
+            },
+        };
+        await expect(driver.onLock(programArg)).rejects.toThrow('Simulated delivery update failure');
+        const campaignRowAfterFail = storedRefs.find(r => r.ExternalKind === 'Campaign');
+        expect(JSON.parse(campaignRowAfterFail.StateJSON).bidding).toBeUndefined();
+        expect(JSON.parse(campaignRowAfterFail.StateJSON).goalConfigLevel).toBeUndefined();
+        shouldFailDeliveryUpdate = false;
+        await driver.onLock(programArg);
+        expect(deliveryCalls).toHaveLength(2);
+        expect(customerGoalCalls).toEqual(['customers/4684433735/campaigns/777']);
+        expect(customGoalCalled).toBe(false);
+        expect(JSON.parse(campaignRowAfterFail.StateJSON)).toMatchObject({
+            bidding: 'TARGET_SPEND',
+            maxCpcUsd: 2,
+            positiveGeoTargetType: 'PRESENCE',
+            goalConfigLevel: 'CUSTOMER',
+            optimizeFor: 'conversions',
+            locationsAttached: ['geoTargetConstants/2840', 'geoTargetConstants/2124'],
+            languagesAttached: ['languageConstants/1000'],
+            mobileAppsExcluded: true,
+        });
+        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