@adcp/client 4.8.0 → 4.10.0

package/dist/lib/testing/scenarios/governance.js

@@ -12,9 +12,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.testGovernancePropertyLists = testGovernancePropertyLists;
 exports.testGovernanceContentStandards = testGovernanceContentStandards;
 exports.testPropertyListFilters = testPropertyListFilters;
+exports.testCampaignGovernance = testCampaignGovernance;
+exports.testCampaignGovernanceDenied = testCampaignGovernanceDenied;
+exports.testCampaignGovernanceConditions = testCampaignGovernanceConditions;
+exports.testCampaignGovernanceDelivery = testCampaignGovernanceDelivery;
 exports.hasGovernanceTools = hasGovernanceTools;
+exports.hasCampaignGovernanceTools = hasCampaignGovernanceTools;
 const client_1 = require("../client");
 const capabilities_1 = require("../../utils/capabilities");
+const GovernanceMiddleware_1 = require("../../core/GovernanceMiddleware");
 // Property list tools
 const PROPERTY_LIST_TOOLS = [
     'create_property_list',
@@ -65,7 +71,7 @@ async function testGovernancePropertyLists(agentUrl, options) {
     // Test: create_property_list
     if (profile.tools.includes('create_property_list')) {
         const listName = options.property_list_name || `E2E Test List ${Date.now()}`;
-        const { result, step } = await (0, client_1.runStep)('Create property list', 'create_property_list', async () => client.executeTask('create_property_list', {
+        const { result, step } = await (0, client_1.runStep)('Create property list', 'create_property_list', async () => client.createPropertyList({
             name: listName,
             description: 'E2E test property list for governance testing',
             base_properties: {
@@ -89,7 +95,7 @@ async function testGovernancePropertyLists(agentUrl, options) {
         }));
         if (result?.success && result?.data) {
             const data = result.data;
-            createdListId = data.list?.list_id || data.list_id;
+            createdListId = data.list?.list_id;
             authToken = data.auth_token;
             step.created_id = createdListId;
             step.details = `Created list: ${createdListId}`;
@@ -107,18 +113,19 @@ async function testGovernancePropertyLists(agentUrl, options) {
     }
     // Test: get_property_list
     if (profile.tools.includes('get_property_list') && createdListId) {
-        const { result, step } = await (0, client_1.runStep)('Get property list', 'get_property_list', async () => client.executeTask('get_property_list', {
+        const { result, step } = await (0, client_1.runStep)('Get property list', 'get_property_list', async () => client.getPropertyList({
             list_id: createdListId,
             resolve: true,
             max_results: 10,
         }));
         if (result?.success && result?.data) {
             const data = result.data;
-            step.details = `Retrieved list with ${data.total_count || 0} properties`;
+            const dataRecord = result.data;
+            step.details = `Retrieved list with ${dataRecord.total_count || 0} properties`;
             step.response_preview = JSON.stringify({
                 list_id: data.list?.list_id,
                 name: data.list?.name,
-                property_count: data.total_count,
+                property_count: dataRecord.total_count,
                 has_identifiers: !!data.identifiers?.length,
             }, null, 2);
         }
@@ -130,7 +137,7 @@ async function testGovernancePropertyLists(agentUrl, options) {
     }
     // Test: update_property_list
     if (profile.tools.includes('update_property_list') && createdListId) {
-        const { result, step } = await (0, client_1.runStep)('Update property list', 'update_property_list', async () => client.executeTask('update_property_list', {
+        const { result, step } = await (0, client_1.runStep)('Update property list', 'update_property_list', async () => client.updatePropertyList({
             list_id: createdListId,
             auth_token: authToken,
             description: 'Updated E2E test property list',
@@ -166,16 +173,17 @@ async function testGovernancePropertyLists(agentUrl, options) {
     }
     // Test: list_property_lists
     if (profile.tools.includes('list_property_lists')) {
-        const { result, step } = await (0, client_1.runStep)('List property lists', 'list_property_lists', async () => client.executeTask('list_property_lists', {
+        const { result, step } = await (0, client_1.runStep)('List property lists', 'list_property_lists', async () => client.listPropertyLists({
             max_results: 10,
         }));
         if (result?.success && result?.data) {
             const data = result.data;
+            const dataRecord = result.data;
             const lists = data.lists || [];
             step.details = `Found ${lists.length} property list(s)`;
             step.response_preview = JSON.stringify({
-                total_count: data.total_count,
-                returned_count: data.returned_count || lists.length,
+                total_count: dataRecord.total_count,
+                returned_count: dataRecord.returned_count || lists.length,
                 lists: lists.slice(0, 3).map((l) => ({
                     list_id: l.list_id,
                     name: l.name,
@@ -190,7 +198,7 @@ async function testGovernancePropertyLists(agentUrl, options) {
     }
     // Test: delete_property_list
     if (profile.tools.includes('delete_property_list') && createdListId && options.dry_run === false) {
-        const { result, step } = await (0, client_1.runStep)('Delete property list', 'delete_property_list', async () => client.executeTask('delete_property_list', {
+        const { result, step } = await (0, client_1.runStep)('Delete property list', 'delete_property_list', async () => client.deletePropertyList({
             list_id: createdListId,
             auth_token: authToken,
         }));
@@ -209,7 +217,7 @@ async function testGovernancePropertyLists(agentUrl, options) {
         steps.push(step);
         // Test: get deleted list (should fail)
         if (profile.tools.includes('get_property_list')) {
-            const { result: errorResult, step: errorStep } = await (0, client_1.runStep)('Get deleted list (error expected)', 'get_property_list', async () => client.executeTask('get_property_list', {
+            const { result: errorResult, step: errorStep } = await (0, client_1.runStep)('Get deleted list (error expected)', 'get_property_list', async () => client.getPropertyList({
                 list_id: createdListId,
             }));
             if (errorResult?.success) {
@@ -265,13 +273,13 @@ async function testGovernanceContentStandards(agentUrl, options) {
     let discoveredStandardsId;
     // Test: list_content_standards
     if (profile.tools.includes('list_content_standards')) {
-        const { result, step } = await (0, client_1.runStep)('List content standards', 'list_content_standards', async () => client.executeTask('list_content_standards', {
+        const { result, step } = await (0, client_1.runStep)('List content standards', 'list_content_standards', async () => client.listContentStandards({
             context: 'E2E testing - list available brand safety configurations',
             max_results: 10,
         }));
         if (result?.success && result?.data) {
             const data = result.data;
-            const standards = data.standards || [];
+            const standards = 'standards' in data ? data.standards : [];
             if (standards.length > 0) {
                 discoveredStandardsId = standards[0].standards_id;
             }
@@ -302,16 +310,18 @@ async function testGovernanceContentStandards(agentUrl, options) {
     // Test: get_content_standards (if we found one)
     const standardsIdToTest = options.content_standards_id || discoveredStandardsId;
     if (profile.tools.includes('get_content_standards') && standardsIdToTest) {
-        const { result, step } = await (0, client_1.runStep)('Get content standards', 'get_content_standards', async () => client.executeTask('get_content_standards', {
+        const { result, step } = await (0, client_1.runStep)('Get content standards', 'get_content_standards', async () => client.getContentStandards({
             standards_id: standardsIdToTest,
         }));
         if (result?.success && result?.data) {
             const data = result.data;
-            step.details = `Retrieved standards: ${data.standards?.name || standardsIdToTest}`;
+            // Response may be a ContentStandards directly or wrapped in { standards: ... }
+            const standards = data.standards || data;
+            step.details = `Retrieved standards: ${String(standards.name || standardsIdToTest)}`;
             step.response_preview = JSON.stringify({
-                standards_id: data.standards?.standards_id,
-                name: data.standards?.name,
-                features_count: data.standards?.features?.length || 0,
+                standards_id: standards.standards_id,
+                name: standards.name,
+                features_count: Array.isArray(standards.features) ? standards.features.length : 0,
             }, null, 2);
         }
         else if (result && !result.success) {
@@ -322,7 +332,7 @@ async function testGovernanceContentStandards(agentUrl, options) {
     }
     // Test: calibrate_content
     if (profile.tools.includes('calibrate_content')) {
-        const { result, step } = await (0, client_1.runStep)('Calibrate content', 'calibrate_content', async () => client.executeTask('calibrate_content', {
+        const { result, step } = await (0, client_1.runStep)('Calibrate content', 'calibrate_content', async () => client.calibrateContent({
             context: 'E2E testing - evaluate sample content for brand safety',
             standards_id: standardsIdToTest,
             artifacts: [
@@ -343,12 +353,12 @@ async function testGovernanceContentStandards(agentUrl, options) {
         }));
         if (result?.success && result?.data) {
             const data = result.data;
-            step.details = `Calibration session: ${data.session_status || 'completed'}`;
+            step.details = `Calibration session: ${String(data.session_status || 'completed')}`;
             step.response_preview = JSON.stringify({
                 session_id: data.session_id,
                 session_status: data.session_status,
-                pending_artifacts: data.pending_artifacts?.length || 0,
-                evaluated_artifacts: data.evaluated_artifacts?.length || 0,
+                pending_artifacts: Array.isArray(data.pending_artifacts) ? data.pending_artifacts.length : 0,
+                evaluated_artifacts: Array.isArray(data.evaluated_artifacts) ? data.evaluated_artifacts.length : 0,
             }, null, 2);
         }
         else if (result && !result.success) {
@@ -366,7 +376,7 @@ async function testGovernanceContentStandards(agentUrl, options) {
     }
     // Test: validate_content_delivery
     if (profile.tools.includes('validate_content_delivery')) {
-        const { result, step } = await (0, client_1.runStep)('Validate content delivery', 'validate_content_delivery', async () => client.executeTask('validate_content_delivery', {
+        const { result, step } = await (0, client_1.runStep)('Validate content delivery', 'validate_content_delivery', async () => client.validateContentDelivery({
             context: 'E2E testing - validate delivery records against content standards',
             standards_id: standardsIdToTest,
             records: [
@@ -383,11 +393,12 @@ async function testGovernanceContentStandards(agentUrl, options) {
         }));
         if (result?.success && result?.data) {
             const data = result.data;
-            step.details = `Validated ${data.summary?.total_records || 0} record(s)`;
+            const summary = data.summary;
+            step.details = `Validated ${summary?.total_records || 0} record(s)`;
             step.response_preview = JSON.stringify({
-                total_records: data.summary?.total_records,
-                passed_records: data.summary?.passed_records,
-                failed_records: data.summary?.failed_records,
+                total_records: summary?.total_records,
+                passed_records: summary?.passed_records,
+                failed_records: summary?.failed_records,
             }, null, 2);
         }
         else if (result && !result.success) {
@@ -405,7 +416,7 @@ async function testGovernanceContentStandards(agentUrl, options) {
     }
     // Test: get_content_standards with invalid ID (error expected)
     if (profile.tools.includes('get_content_standards')) {
-        const { result: errorResult, step: errorStep } = await (0, client_1.runStep)('Get invalid content standards (error expected)', 'get_content_standards', async () => client.executeTask('get_content_standards', {
+        const { result: errorResult, step: errorStep } = await (0, client_1.runStep)('Get invalid content standards (error expected)', 'get_content_standards', async () => client.getContentStandards({
             standards_id: 'INVALID_STANDARDS_ID_DOES_NOT_EXIST_12345',
         }));
         if (errorResult?.success) {
@@ -454,12 +465,15 @@ async function testPropertyListFilters(agentUrl, options) {
     // Optionally discover feature IDs from get_adcp_capabilities
     let featureRequirements;
     if (profile.tools.includes('get_adcp_capabilities')) {
-        const { result: capResult, step: capStep } = await (0, client_1.runStep)('Discover available features (for feature_requirements filter)', 'get_adcp_capabilities', async () => client.executeTask('get_adcp_capabilities', {}));
+        const { result: capResult, step: capStep } = await (0, client_1.runStep)('Discover available features (for feature_requirements filter)', 'get_adcp_capabilities', async () => client.getAdcpCapabilities({}));
         if (capResult?.success && capResult?.data) {
-            const rawFeatures = capResult.data?.media_buy?.features;
+            const capData = capResult.data;
+            const mediaBuy = capData.media_buy;
+            const rawFeatures = mediaBuy?.features;
             if (rawFeatures && typeof rawFeatures === 'object') {
                 // Use boolean feature keys as feature_ids (agents that support dynamic features will have IDs)
-                const featureIds = Object.keys(rawFeatures).filter(k => rawFeatures[k] === true);
+                const featuresRecord = rawFeatures;
+                const featureIds = Object.keys(featuresRecord).filter(k => featuresRecord[k] === true);
                 if (featureIds.length > 0) {
                     featureRequirements = featureIds.map(id => ({
                         feature_id: id,
@@ -498,7 +512,7 @@ async function testPropertyListFilters(agentUrl, options) {
     let authToken;
     // Create property list with all filters
     const listName = `E2E Filter Test ${Date.now()}`;
-    const { result: createResult, step: createStep } = await (0, client_1.runStep)('Create property list with all filter types', 'create_property_list', async () => client.executeTask('create_property_list', {
+    const { result: createResult, step: createStep } = await (0, client_1.runStep)('Create property list with all filter types', 'create_property_list', async () => client.createPropertyList({
         name: listName,
         description: 'E2E filter round-trip test',
         base_properties: {
@@ -512,7 +526,7 @@ async function testPropertyListFilters(agentUrl, options) {
     }));
     if (createResult?.success && createResult?.data) {
         const data = createResult.data;
-        createdListId = data.list?.list_id || data.list_id;
+        createdListId = data.list?.list_id;
         authToken = data.auth_token;
         createStep.created_id = createdListId;
         createStep.details = `Created list: ${createdListId} with ${Object.keys(filters).length} filter type(s)`;
@@ -526,7 +540,7 @@ async function testPropertyListFilters(agentUrl, options) {
         return { steps, profile };
     }
     // Retrieve with resolve:true and validate filter round-trip
-    const { result: getResult, step: getStep } = await (0, client_1.runStep)('Get property list (resolve: true, validate filter round-trip)', 'get_property_list', async () => client.executeTask('get_property_list', {
+    const { result: getResult, step: getStep } = await (0, client_1.runStep)('Get property list (resolve: true, validate filter round-trip)', 'get_property_list', async () => client.getPropertyList({
         list_id: createdListId,
         resolve: true,
         max_results: 5,
@@ -536,16 +550,19 @@ async function testPropertyListFilters(agentUrl, options) {
         const returnedFilters = data.list?.filters;
         const issues = [];
         if (returnedFilters) {
-            if (!returnedFilters.garm_categories?.exclude?.length) {
+            const garmCategories = returnedFilters.garm_categories;
+            if (!Array.isArray(garmCategories?.exclude) || !garmCategories.exclude.length) {
                 issues.push('garm_categories.exclude not preserved');
             }
-            if (returnedFilters.mfa_thresholds?.min_score !== 0.75) {
-                issues.push(`mfa_thresholds.min_score mismatch: got ${returnedFilters.mfa_thresholds?.min_score}, expected 0.75`);
+            const mfaThresholds = returnedFilters.mfa_thresholds;
+            if (mfaThresholds?.min_score !== 0.75) {
+                issues.push(`mfa_thresholds.min_score mismatch: got ${mfaThresholds?.min_score}, expected 0.75`);
             }
             if (!returnedFilters.custom_tags) {
                 issues.push('custom_tags filter not preserved');
             }
-            if (featureRequirements && !returnedFilters.feature_requirements?.length) {
+            const featureReqs = returnedFilters.feature_requirements;
+            if (featureRequirements && !(Array.isArray(featureReqs) && featureReqs.length)) {
                 issues.push('feature_requirements filter not preserved');
             }
         }
@@ -571,7 +588,7 @@ async function testPropertyListFilters(agentUrl, options) {
     steps.push(getStep);
     // Cleanup: delete if not dry-run
     if (options.dry_run === false && profile.tools.includes('delete_property_list')) {
-        const { result: delResult, step: delStep } = await (0, client_1.runStep)('Delete test property list (cleanup)', 'delete_property_list', async () => client.executeTask('delete_property_list', {
+        const { result: delResult, step: delStep } = await (0, client_1.runStep)('Delete test property list (cleanup)', 'delete_property_list', async () => client.deletePropertyList({
             list_id: createdListId,
             auth_token: authToken,
         }));
@@ -593,10 +610,679 @@ async function testPropertyListFilters(agentUrl, options) {
     }
     return { steps, profile };
 }
+// Campaign governance tools
+const CAMPAIGN_GOVERNANCE_TOOLS = [
+    'sync_plans',
+    'check_governance',
+    'report_plan_outcome',
+    'get_plan_audit_logs',
+];
+/**
+ * Test: Campaign Governance - Full Lifecycle
+ *
+ * Flow: sync_plans -> check_governance(proposed, approved) -> create_media_buy
+ *       -> report_plan_outcome(completed)
+ *
+ * Tests the happy path: buyer syncs a plan, gets approval, executes,
+ * and reports the outcome back to the governance agent.
+ */
+async function testCampaignGovernance(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    // Discover agent profile
+    const { profile, step: profileStep } = await (0, client_1.discoverAgentProfile)(client);
+    steps.push(profileStep);
+    if (!profileStep.passed) {
+        return { steps, profile };
+    }
+    // Check if agent supports campaign governance tools
+    const hasCampaignGovernance = CAMPAIGN_GOVERNANCE_TOOLS.some(t => profile.tools.includes(t));
+    if (!hasCampaignGovernance) {
+        steps.push({
+            step: 'Campaign governance support check',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent does not support campaign governance tools',
+            details: `Required: at least one of ${CAMPAIGN_GOVERNANCE_TOOLS.join(', ')}. Available: ${profile.tools.join(', ')}`,
+        });
+        return { steps, profile };
+    }
+    profile.supports_governance = true;
+    const testPlanId = `test-plan-${Date.now()}`;
+    const testCampaignRef = `test-campaign-${Date.now()}`;
+    const callerUrl = 'https://test-orchestrator.example.com';
+    const flightStart = new Date();
+    const flightEnd = new Date(flightStart.getTime() + 30 * 24 * 60 * 60 * 1000); // 30 days
+    // Step 1: sync_plans
+    if (profile.tools.includes('sync_plans')) {
+        const { result, step } = await (0, client_1.runStep)('Sync campaign governance plan', 'sync_plans', async () => client.executeTask('sync_plans', {
+            plans: [
+                {
+                    plan_id: testPlanId,
+                    brand: options.brand || { domain: 'test.example.com' },
+                    objectives: 'E2E test campaign for governance protocol validation',
+                    budget: {
+                        total: options.budget || 10000,
+                        currency: 'USD',
+                        authority_level: 'agent_full',
+                    },
+                    flight: {
+                        start: flightStart.toISOString(),
+                        end: flightEnd.toISOString(),
+                    },
+                    countries: ['US'],
+                    channels: {
+                        allowed: ['display', 'video'],
+                    },
+                    delegations: [
+                        {
+                            agent_url: callerUrl,
+                            authority: 'full',
+                        },
+                    ],
+                },
+            ],
+        }));
+        if (result?.success && result?.data) {
+            const data = result.data;
+            const plans = data.plans || [];
+            const synced = plans.find((p) => p.plan_id === testPlanId);
+            if (synced?.status === 'active') {
+                step.details = `Plan synced: ${testPlanId}, version ${synced.version}, ${(synced.categories || []).length} categories active`;
+                step.response_preview = JSON.stringify({
+                    plan_id: synced.plan_id,
+                    status: synced.status,
+                    version: synced.version,
+                    categories: synced.categories?.map((c) => c.category_id),
+                    resolved_policies: synced.resolved_policies?.length || 0,
+                }, null, 2);
+            }
+            else {
+                step.passed = false;
+                step.error = synced
+                    ? `Plan sync returned status '${synced.status}' instead of 'active'`
+                    : 'Plan not found in sync response';
+            }
+        }
+        else if (result && !result.success) {
+            step.passed = false;
+            step.error = result.error || 'sync_plans failed';
+        }
+        steps.push(step);
+    }
+    // Step 2: check_governance (proposed, expecting approved)
+    let checkId;
+    if (profile.tools.includes('check_governance')) {
+        const { result, step } = await (0, client_1.runStep)('Check governance (proposed buy)', 'check_governance', async () => client.executeTask('check_governance', {
+            plan_id: testPlanId,
+            buyer_campaign_ref: testCampaignRef,
+            binding: 'proposed',
+            caller: callerUrl,
+            tool: 'create_media_buy',
+            payload: {
+                buyer_ref: `e2e-test-${Date.now()}`,
+                channel: 'display',
+                budget: { total: 1000, currency: 'USD' },
+                flight: {
+                    start: flightStart.toISOString(),
+                    end: flightEnd.toISOString(),
+                },
+                countries: ['US'],
+            },
+        }));
+        if (result?.success && result?.data) {
+            const data = result.data;
+            checkId = data.check_id;
+            const status = data.status;
+            step.details = `Governance check: status=${status}, binding=${data.binding}, mode=${data.mode || 'unknown'}`;
+            step.response_preview = JSON.stringify({
+                check_id: data.check_id,
+                status: data.status,
+                binding: data.binding,
+                mode: data.mode,
+                explanation: data.explanation,
+                findings_count: data.findings?.length || 0,
+                expires_at: data.expires_at,
+            }, null, 2);
+            // Any status is valid — we're testing the protocol, not the policy
+            if (!['approved', 'denied', 'conditions', 'escalated'].includes(status)) {
+                step.passed = false;
+                step.error = `Unexpected governance status: ${status}`;
+            }
+        }
+        else if (result && !result.success) {
+            step.passed = false;
+            step.error = result.error || 'check_governance failed';
+        }
+        steps.push(step);
+    }
+    // Step 3: report_plan_outcome (completed)
+    if (profile.tools.includes('report_plan_outcome') && checkId) {
+        const { result, step } = await (0, client_1.runStep)('Report plan outcome (completed)', 'report_plan_outcome', async () => client.executeTask('report_plan_outcome', {
+            plan_id: testPlanId,
+            check_id: checkId,
+            buyer_campaign_ref: testCampaignRef,
+            outcome: 'completed',
+            seller_response: {
+                media_buy_id: `test-mb-${Date.now()}`,
+                buyer_ref: `e2e-test-${Date.now()}`,
+                packages: [
+                    {
+                        package_id: 'test-pkg-1',
+                        name: 'E2E Test Package',
+                        budget: { total: 1000, currency: 'USD' },
+                    },
+                ],
+            },
+        }));
+        if (result?.success && result?.data) {
+            step.details = 'Outcome reported to governance agent';
+            step.response_preview = JSON.stringify(result.data, null, 2);
+        }
+        else if (result && !result.success) {
+            step.passed = false;
+            step.error = result.error || 'report_plan_outcome failed';
+        }
+        steps.push(step);
+    }
+    // Step 4: get_plan_audit_logs
+    if (profile.tools.includes('get_plan_audit_logs')) {
+        const { result, step } = await (0, client_1.runStep)('Get plan audit logs', 'get_plan_audit_logs', async () => client.executeTask('get_plan_audit_logs', {
+            plan_ids: [testPlanId],
+            buyer_campaign_ref: testCampaignRef,
+            include_entries: true,
+        }));
+        if (result?.success && result?.data) {
+            const data = result.data;
+            step.details = 'Audit logs retrieved';
+            step.response_preview = JSON.stringify({
+                plans_returned: data.plans?.length || 0,
+                has_entries: !!data.plans?.[0]?.entries?.length,
+                budget: data.plans?.[0]?.budget,
+            }, null, 2);
+        }
+        else if (result && !result.success) {
+            step.passed = false;
+            step.error = result.error || 'get_plan_audit_logs failed';
+        }
+        steps.push(step);
+    }
+    return { steps, profile };
+}
+/**
+ * Test: Campaign Governance - Denied Flow
+ *
+ * Sends a check_governance request that should be denied (budget exceeds plan,
+ * unauthorized market). Validates that the governance agent returns meaningful
+ * findings and explanations.
+ */
+async function testCampaignGovernanceDenied(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    const { profile, step: profileStep } = await (0, client_1.discoverAgentProfile)(client);
+    steps.push(profileStep);
+    if (!profileStep.passed) {
+        return { steps, profile };
+    }
+    if (!profile.tools.includes('sync_plans') || !profile.tools.includes('check_governance')) {
+        steps.push({
+            step: 'Campaign governance denied flow support check',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent requires sync_plans + check_governance for denied flow testing',
+        });
+        return { steps, profile };
+    }
+    profile.supports_governance = true;
+    const testPlanId = `test-denied-plan-${Date.now()}`;
+    const testCampaignRef = `test-denied-campaign-${Date.now()}`;
+    const callerUrl = 'https://test-orchestrator.example.com';
+    const flightStart = new Date();
+    const flightEnd = new Date(flightStart.getTime() + 7 * 24 * 60 * 60 * 1000);
+    // Sync a restrictive plan: small budget, US only
+    const { result: syncResult, step: syncStep } = await (0, client_1.runStep)('Sync restrictive plan (small budget, US only)', 'sync_plans', async () => client.executeTask('sync_plans', {
+        plans: [
+            {
+                plan_id: testPlanId,
+                brand: options.brand || { domain: 'test.example.com' },
+                objectives: 'E2E denial test: budget and geo restrictions',
+                budget: {
+                    total: 500,
+                    currency: 'USD',
+                    authority_level: 'agent_limited',
+                    reallocation_threshold: 100,
+                },
+                flight: {
+                    start: flightStart.toISOString(),
+                    end: flightEnd.toISOString(),
+                },
+                countries: ['US'],
+                channels: {
+                    allowed: ['display'],
+                },
+            },
+        ],
+    }));
+    steps.push(syncStep);
+    if (!syncResult?.success) {
+        return { steps, profile };
+    }
+    // Check governance with over-budget request
+    const { result: overBudgetResult, step: overBudgetStep } = await (0, client_1.runStep)('Check governance (over-budget, expecting denial or conditions)', 'check_governance', async () => client.executeTask('check_governance', {
+        plan_id: testPlanId,
+        buyer_campaign_ref: testCampaignRef,
+        binding: 'proposed',
+        caller: callerUrl,
+        tool: 'create_media_buy',
+        payload: {
+            buyer_ref: `e2e-overbudget-${Date.now()}`,
+            channel: 'display',
+            budget: { total: 50000, currency: 'USD' },
+            flight: {
+                start: flightStart.toISOString(),
+                end: flightEnd.toISOString(),
+            },
+            countries: ['US'],
+        },
+    }));
+    if (overBudgetResult?.success && overBudgetResult?.data) {
+        const data = overBudgetResult.data;
+        overBudgetStep.details = `Over-budget check: status=${data.status}, explanation: ${data.explanation}`;
+        overBudgetStep.response_preview = JSON.stringify({
+            status: data.status,
+            explanation: data.explanation,
+            findings: data.findings?.map((f) => ({
+                category_id: f.category_id,
+                severity: f.severity,
+                explanation: f.explanation,
+            })),
+            conditions: data.conditions,
+        }, null, 2);
+        if (data.status === 'approved' && data.mode !== 'advisory' && data.mode !== 'audit') {
+            overBudgetStep.passed = false;
+            overBudgetStep.error =
+                'Governance approved a $50,000 buy against a $500 plan in enforce mode — expected denial or conditions';
+        }
+        else if (data.status === 'approved') {
+            overBudgetStep.warnings = [
+                'Governance approved a $50,000 buy against a $500 plan — advisory/audit mode detected',
+            ];
+        }
+    }
+    else if (overBudgetResult && !overBudgetResult.success) {
+        overBudgetStep.passed = false;
+        overBudgetStep.error = overBudgetResult.error || 'check_governance failed';
+    }
+    steps.push(overBudgetStep);
+    // Check governance with unauthorized market
+    const { result: geoResult, step: geoStep } = await (0, client_1.runStep)('Check governance (unauthorized market, expecting denial or conditions)', 'check_governance', async () => client.executeTask('check_governance', {
+        plan_id: testPlanId,
+        buyer_campaign_ref: testCampaignRef,
+        binding: 'proposed',
+        caller: callerUrl,
+        tool: 'create_media_buy',
+        payload: {
+            buyer_ref: `e2e-badgeo-${Date.now()}`,
+            channel: 'display',
+            budget: { total: 100, currency: 'USD' },
+            flight: {
+                start: flightStart.toISOString(),
+                end: flightEnd.toISOString(),
+            },
+            countries: ['CN', 'RU'],
+        },
+    }));
+    if (geoResult?.success && geoResult?.data) {
+        const data = geoResult.data;
+        geoStep.details = `Unauthorized market check: status=${data.status}`;
+        geoStep.response_preview = JSON.stringify({
+            status: data.status,
+            explanation: data.explanation,
+            findings: data.findings?.map((f) => ({
+                category_id: f.category_id,
+                explanation: f.explanation,
+            })),
+        }, null, 2);
+        if (data.status === 'approved') {
+            geoStep.warnings = [
+                'Governance approved targeting CN/RU against US-only plan — may indicate audit/advisory mode',
+            ];
+        }
+    }
+    else if (geoResult && !geoResult.success) {
+        geoStep.passed = false;
+        geoStep.error = geoResult.error || 'check_governance failed';
+    }
+    steps.push(geoStep);
+    // Report failed outcome
+    if (profile.tools.includes('report_plan_outcome') && overBudgetResult?.data?.check_id) {
+        const { step: outcomeStep } = await (0, client_1.runStep)('Report failed outcome for denied check', 'report_plan_outcome', async () => client.executeTask('report_plan_outcome', {
+            plan_id: testPlanId,
+            check_id: overBudgetResult.data.check_id,
+            buyer_campaign_ref: testCampaignRef,
+            outcome: 'failed',
+            error: {
+                code: 'governance_denied',
+                message: 'Action blocked by governance check',
+            },
+        }));
+        steps.push(outcomeStep);
+    }
+    return { steps, profile };
+}
+/**
+ * Test: Campaign Governance - Conditions Flow
+ *
+ * Syncs a plan, sends a check that may trigger conditions (e.g., budget
+ * concentration limit), applies machine-actionable conditions, and re-checks.
+ */
+async function testCampaignGovernanceConditions(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    const { profile, step: profileStep } = await (0, client_1.discoverAgentProfile)(client);
+    steps.push(profileStep);
+    if (!profileStep.passed) {
+        return { steps, profile };
+    }
+    if (!profile.tools.includes('sync_plans') || !profile.tools.includes('check_governance')) {
+        steps.push({
+            step: 'Campaign governance conditions flow support check',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent requires sync_plans + check_governance for conditions flow testing',
+        });
+        return { steps, profile };
+    }
+    profile.supports_governance = true;
+    const testPlanId = `test-conditions-plan-${Date.now()}`;
+    const testCampaignRef = `test-conditions-campaign-${Date.now()}`;
+    const callerUrl = 'https://test-orchestrator.example.com';
+    const flightStart = new Date();
+    const flightEnd = new Date(flightStart.getTime() + 14 * 24 * 60 * 60 * 1000);
+    // Sync a plan with per_seller_max_pct constraint
+    const { result: syncResult, step: syncStep } = await (0, client_1.runStep)('Sync plan with seller concentration limit', 'sync_plans', async () => client.executeTask('sync_plans', {
+        plans: [
+            {
+                plan_id: testPlanId,
+                brand: options.brand || { domain: 'test.example.com' },
+                objectives: 'E2E conditions test: budget cap per seller',
+                budget: {
+                    total: 5000,
+                    currency: 'USD',
+                    authority_level: 'agent_limited',
+                    per_seller_max_pct: 50,
+                    reallocation_threshold: 500,
+                },
+                flight: {
+                    start: flightStart.toISOString(),
+                    end: flightEnd.toISOString(),
+                },
+                countries: ['US'],
+                channels: {
+                    allowed: ['display', 'video'],
+                    mix_targets: {
+                        display: { min_pct: 30, max_pct: 70 },
+                        video: { min_pct: 30, max_pct: 70 },
+                    },
+                },
+            },
+        ],
+    }));
+    steps.push(syncStep);
+    if (!syncResult?.success) {
+        return { steps, profile };
+    }
+    // First check: send budget that might trigger conditions
+    const { result: checkResult, step: checkStep } = await (0, client_1.runStep)('Check governance (may trigger conditions)', 'check_governance', async () => client.executeTask('check_governance', {
+        plan_id: testPlanId,
+        buyer_campaign_ref: testCampaignRef,
+        binding: 'proposed',
+        caller: callerUrl,
+        tool: 'create_media_buy',
+        payload: {
+            buyer_ref: `e2e-conditions-${Date.now()}`,
+            channel: 'display',
+            budget: { total: 4000, currency: 'USD' },
+            flight: {
+                start: flightStart.toISOString(),
+                end: flightEnd.toISOString(),
+            },
+            countries: ['US'],
+        },
+    }));
+    if (checkResult?.success && checkResult?.data) {
+        const data = checkResult.data;
+        checkStep.details = `Initial check: status=${data.status}`;
+        checkStep.response_preview = JSON.stringify({
+            check_id: data.check_id,
+            status: data.status,
+            explanation: data.explanation,
+            conditions: data.conditions,
+            findings: data.findings?.map((f) => ({
+                category_id: f.category_id,
+                explanation: f.explanation,
+            })),
+        }, null, 2);
+        // If we got conditions, apply them and re-check
+        if (data.status === 'conditions' && data.conditions?.length > 0) {
+            const conditions = data.conditions;
+            const appliedConditions = conditions
+                .filter((c) => c.required_value !== undefined)
+                .map((c) => `${c.field}=${JSON.stringify(c.required_value)}`);
+            checkStep.details += `. Conditions received: ${conditions.length} (${appliedConditions.length} machine-actionable)`;
+            // Build adjusted payload by applying conditions
+            const adjustedPayload = {
+                buyer_ref: `e2e-conditions-adjusted-${Date.now()}`,
+                channel: 'display',
+                budget: { total: 4000, currency: 'USD' },
+                flight: {
+                    start: flightStart.toISOString(),
+                    end: flightEnd.toISOString(),
+                },
+                countries: ['US'],
+            };
+            for (const condition of conditions) {
+                if (condition.required_value !== undefined) {
+                    (0, GovernanceMiddleware_1.setAtPath)(adjustedPayload, condition.field, condition.required_value);
+                }
+            }
+            // Re-check with adjusted parameters
+            const { result: recheckResult, step: recheckStep } = await (0, client_1.runStep)('Re-check governance (after applying conditions)', 'check_governance', async () => client.executeTask('check_governance', {
+                plan_id: testPlanId,
+                buyer_campaign_ref: testCampaignRef,
+                binding: 'proposed',
+                caller: callerUrl,
+                tool: 'create_media_buy',
+                payload: adjustedPayload,
+            }));
+            if (recheckResult?.success && recheckResult?.data) {
+                const recheckData = recheckResult.data;
+                recheckStep.details = `Re-check after conditions: status=${recheckData.status}`;
+                recheckStep.response_preview = JSON.stringify({
+                    check_id: recheckData.check_id,
+                    status: recheckData.status,
+                    explanation: recheckData.explanation,
+                }, null, 2);
+            }
+            else if (recheckResult && !recheckResult.success) {
+                recheckStep.passed = false;
+                recheckStep.error = recheckResult.error || 'Re-check after conditions failed';
+            }
+            steps.push(recheckStep);
+        }
+    }
+    else if (checkResult && !checkResult.success) {
+        checkStep.passed = false;
+        checkStep.error = checkResult.error || 'check_governance failed';
+    }
+    steps.push(checkStep);
+    return { steps, profile };
+}
+/**
+ * Test: Campaign Governance - Delivery Monitoring
+ *
+ * Tests delivery-phase check_governance with delivery_metrics, including
+ * normal pacing and overspend drift detection.
+ */
+async function testCampaignGovernanceDelivery(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    const { profile, step: profileStep } = await (0, client_1.discoverAgentProfile)(client);
+    steps.push(profileStep);
+    if (!profileStep.passed) {
+        return { steps, profile };
+    }
+    if (!profile.tools.includes('check_governance')) {
+        steps.push({
+            step: 'Campaign governance delivery monitoring support check',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent requires check_governance for delivery monitoring testing',
+        });
+        return { steps, profile };
+    }
+    profile.supports_governance = true;
+    const testPlanId = `test-delivery-plan-${Date.now()}`;
+    const testCampaignRef = `test-delivery-campaign-${Date.now()}`;
+    const callerUrl = 'https://test-seller.example.com';
+    const flightStart = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+    const flightEnd = new Date(Date.now() + 23 * 24 * 60 * 60 * 1000);
+    // Sync plan if supported
+    if (profile.tools.includes('sync_plans')) {
+        const { result: syncResult, step: syncStep } = await (0, client_1.runStep)('Sync plan for delivery monitoring', 'sync_plans', async () => client.executeTask('sync_plans', {
+            plans: [
+                {
+                    plan_id: testPlanId,
+                    brand: options.brand || { domain: 'test.example.com' },
+                    objectives: 'E2E delivery monitoring test',
+                    budget: {
+                        total: 10000,
+                        currency: 'USD',
+                        authority_level: 'agent_full',
+                    },
+                    flight: {
+                        start: flightStart.toISOString(),
+                        end: flightEnd.toISOString(),
+                    },
+                    countries: ['US'],
+                },
+            ],
+        }));
+        steps.push(syncStep);
+        if (!syncResult?.success) {
+            return { steps, profile };
+        }
+    }
+    // Delivery-phase committed check with metrics
+    const reportingStart = new Date(Date.now() - 24 * 60 * 60 * 1000);
+    const reportingEnd = new Date();
+    const { result: deliveryResult, step: deliveryStep } = await (0, client_1.runStep)('Check governance (delivery phase with metrics)', 'check_governance', async () => client.executeTask('check_governance', {
+        plan_id: testPlanId,
+        buyer_campaign_ref: testCampaignRef,
+        binding: 'committed',
+        caller: callerUrl,
+        media_buy_id: `test-mb-${Date.now()}`,
+        phase: 'delivery',
+        planned_delivery: {
+            total_budget: 3000,
+            currency: 'USD',
+            channels: ['display'],
+            geo: { countries: ['US'] },
+        },
+        delivery_metrics: {
+            reporting_period: {
+                start: reportingStart.toISOString(),
+                end: reportingEnd.toISOString(),
+            },
+            spend: 450,
+            cumulative_spend: 2800,
+            impressions: 15000,
+            cumulative_impressions: 85000,
+            geo_distribution: { US: 100 },
+            channel_distribution: { display: 100 },
+            pacing: 'on_track',
+        },
+    }));
+    if (deliveryResult?.success && deliveryResult?.data) {
+        const data = deliveryResult.data;
+        deliveryStep.details = `Delivery check: status=${data.status}, next_check=${data.next_check || 'not specified'}`;
+        deliveryStep.response_preview = JSON.stringify({
+            check_id: data.check_id,
+            status: data.status,
+            binding: data.binding,
+            explanation: data.explanation,
+            findings: data.findings?.map((f) => ({
+                category_id: f.category_id,
+                severity: f.severity,
+                explanation: f.explanation,
+            })),
+            next_check: data.next_check,
+        }, null, 2);
+    }
+    else if (deliveryResult && !deliveryResult.success) {
+        deliveryStep.passed = false;
+        deliveryStep.error = deliveryResult.error || 'Delivery-phase check_governance failed';
+    }
+    steps.push(deliveryStep);
+    // Delivery-phase check with drift (overspend)
+    const { result: driftResult, step: driftStep } = await (0, client_1.runStep)('Check governance (delivery phase with overspend drift)', 'check_governance', async () => client.executeTask('check_governance', {
+        plan_id: testPlanId,
+        buyer_campaign_ref: testCampaignRef,
+        binding: 'committed',
+        caller: callerUrl,
+        media_buy_id: `test-mb-${Date.now()}`,
+        phase: 'delivery',
+        planned_delivery: {
+            total_budget: 3000,
+            currency: 'USD',
+            channels: ['display'],
+            geo: { countries: ['US'] },
+        },
+        delivery_metrics: {
+            reporting_period: {
+                start: reportingStart.toISOString(),
+                end: reportingEnd.toISOString(),
+            },
+            spend: 2000,
+            cumulative_spend: 9500,
+            impressions: 5000,
+            cumulative_impressions: 90000,
+            pacing: 'ahead',
+        },
+    }));
+    if (driftResult?.success && driftResult?.data) {
+        const data = driftResult.data;
+        driftStep.details = `Overspend drift check: status=${data.status}`;
+        driftStep.response_preview = JSON.stringify({
+            status: data.status,
+            explanation: data.explanation,
+            findings: data.findings?.map((f) => ({
+                category_id: f.category_id,
+                severity: f.severity,
+                explanation: f.explanation,
+            })),
+        }, null, 2);
+        if (data.status === 'approved' && !data.findings?.length) {
+            driftStep.warnings = ['Governance approved delivery at 95% budget with no findings — verify drift detection'];
+        }
+    }
+    else if (driftResult && !driftResult.success) {
+        driftStep.passed = false;
+        driftStep.error = driftResult.error || 'Drift detection check_governance failed';
+    }
+    steps.push(driftStep);
+    return { steps, profile };
+}
 /**
  * Check if agent has any governance protocol tools
  */
 function hasGovernanceTools(tools) {
     return capabilities_1.GOVERNANCE_TOOLS.some(t => tools.includes(t));
 }
+/**
+ * Check if agent has campaign governance tools
+ */
+function hasCampaignGovernanceTools(tools) {
+    return CAMPAIGN_GOVERNANCE_TOOLS.some(t => tools.includes(t));
+}
 //# sourceMappingURL=governance.js.map