@adcp/client 4.14.0 → 4.15.0

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

@@ -16,10 +16,13 @@ exports.testCampaignGovernance = testCampaignGovernance;
 exports.testCampaignGovernanceDenied = testCampaignGovernanceDenied;
 exports.testCampaignGovernanceConditions = testCampaignGovernanceConditions;
 exports.testCampaignGovernanceDelivery = testCampaignGovernanceDelivery;
+exports.testSellerGovernanceContext = testSellerGovernanceContext;
 exports.hasGovernanceTools = hasGovernanceTools;
 exports.hasCampaignGovernanceTools = hasCampaignGovernanceTools;
 const client_1 = require("../client");
 const capabilities_1 = require("../../utils/capabilities");
+const stubs_1 = require("../stubs");
+const mcp_1 = require("../../protocols/mcp");
 const GovernanceMiddleware_1 = require("../../core/GovernanceMiddleware");
 // Property list tools
 const PROPERTY_LIST_TOOLS = [
@@ -46,9 +49,9 @@ const CONTENT_STANDARDS_TOOLS = [
  */
 async function testGovernancePropertyLists(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
     // Discover agent profile
-    const { profile, step: profileStep } = await (0, client_1.discoverAgentProfile)(client);
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
     steps.push(profileStep);
     if (!profileStep.passed) {
         return { steps, profile };
@@ -250,9 +253,9 @@ async function testGovernancePropertyLists(agentUrl, options) {
  */
 async function testGovernanceContentStandards(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
     // Discover agent profile
-    const { profile, step: profileStep } = await (0, client_1.discoverAgentProfile)(client);
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
     steps.push(profileStep);
     if (!profileStep.passed) {
         return { steps, profile };
@@ -445,8 +448,8 @@ async function testGovernanceContentStandards(agentUrl, options) {
  */
 async function testPropertyListFilters(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);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
     steps.push(profileStep);
     if (!profileStep.passed) {
         return { steps, profile };
@@ -628,9 +631,9 @@ const CAMPAIGN_GOVERNANCE_TOOLS = [
  */
 async function testCampaignGovernance(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
     // Discover agent profile
-    const { profile, step: profileStep } = await (0, client_1.discoverAgentProfile)(client);
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
     steps.push(profileStep);
     if (!profileStep.passed) {
         return { steps, profile };
@@ -649,7 +652,7 @@ async function testCampaignGovernance(agentUrl, options) {
     }
     profile.supports_governance = true;
     const testPlanId = `test-plan-${Date.now()}`;
-    const testCampaignRef = `test-campaign-${Date.now()}`;
+    const testMediaBuyId = `test-mb-${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
@@ -712,15 +715,14 @@ async function testCampaignGovernance(agentUrl, options) {
     }
     // Step 2: check_governance (proposed, expecting approved)
     let checkId;
+    let governanceContext;
     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: {
@@ -733,6 +735,7 @@ async function testCampaignGovernance(agentUrl, options) {
         if (result?.success && result?.data) {
             const data = result.data;
             checkId = data.check_id;
+            governanceContext = data.governance_context;
             const status = data.status;
             step.details = `Governance check: status=${status}, binding=${data.binding}, mode=${data.mode || 'unknown'}`;
             step.response_preview = JSON.stringify({
@@ -743,12 +746,25 @@ async function testCampaignGovernance(agentUrl, options) {
                 explanation: data.explanation,
                 findings_count: data.findings?.length || 0,
                 expires_at: data.expires_at,
+                governance_context: data.governance_context ? '(present)' : '(absent)',
             }, 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}`;
             }
+            // Validate governance_context format if present
+            if (governanceContext !== undefined) {
+                if (typeof governanceContext !== 'string') {
+                    step.warnings = [...(step.warnings || []), 'governance_context is not a string'];
+                }
+                else if (governanceContext.length > 4096) {
+                    step.warnings = [
+                        ...(step.warnings || []),
+                        `governance_context exceeds 4096 chars (${governanceContext.length})`,
+                    ];
+                }
+            }
         }
         else if (result && !result.success) {
             step.passed = false;
@@ -756,27 +772,25 @@ async function testCampaignGovernance(agentUrl, options) {
         }
         steps.push(step);
     }
-    // Step 3: report_plan_outcome (completed)
+    // Step 3: report_plan_outcome (completed) — thread governance_context
     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', {
+        const outcomeRequest = {
             plan_id: testPlanId,
             check_id: checkId,
-            buyer_campaign_ref: testCampaignRef,
             outcome: 'completed',
+            governance_context: governanceContext || '',
             seller_response: {
-                media_buy_id: `test-mb-${Date.now()}`,
-                buyer_ref: `e2e-test-${Date.now()}`,
+                media_buy_id: testMediaBuyId,
                 packages: [
                     {
-                        package_id: 'test-pkg-1',
-                        name: 'E2E Test Package',
-                        budget: { total: 1000, currency: 'USD' },
+                        budget: 1000,
                     },
                 ],
             },
-        }));
+        };
+        const { result, step } = await (0, client_1.runStep)('Report plan outcome (completed)', 'report_plan_outcome', async () => client.executeTask('report_plan_outcome', outcomeRequest));
         if (result?.success && result?.data) {
-            step.details = 'Outcome reported to governance agent';
+            step.details = `Outcome reported with governance_context=${governanceContext ? 'present' : 'absent'}`;
             step.response_preview = JSON.stringify(result.data, null, 2);
         }
         else if (result && !result.success) {
@@ -785,11 +799,11 @@ async function testCampaignGovernance(agentUrl, options) {
         }
         steps.push(step);
     }
-    // Step 4: get_plan_audit_logs
+    // Step 4: get_plan_audit_logs — query by media_buy_id
     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,
+            media_buy_id: testMediaBuyId,
             include_entries: true,
         }));
         if (result?.success && result?.data) {
@@ -818,8 +832,8 @@ async function testCampaignGovernance(agentUrl, options) {
  */
 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);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
     steps.push(profileStep);
     if (!profileStep.passed) {
         return { steps, profile };
@@ -835,7 +849,6 @@ async function testCampaignGovernanceDenied(agentUrl, options) {
     }
     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);
@@ -870,12 +883,10 @@ async function testCampaignGovernanceDenied(agentUrl, options) {
     // 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: {
@@ -885,8 +896,10 @@ async function testCampaignGovernanceDenied(agentUrl, options) {
             countries: ['US'],
         },
     }));
+    let overBudgetGovernanceContext;
     if (overBudgetResult?.success && overBudgetResult?.data) {
         const data = overBudgetResult.data;
+        overBudgetGovernanceContext = data.governance_context;
         overBudgetStep.details = `Over-budget check: status=${data.status}, explanation: ${data.explanation}`;
         overBudgetStep.response_preview = JSON.stringify({
             status: data.status,
@@ -897,6 +910,7 @@ async function testCampaignGovernanceDenied(agentUrl, options) {
                 explanation: f.explanation,
             })),
             conditions: data.conditions,
+            governance_context: data.governance_context ? '(present)' : '(absent)',
         }, null, 2);
         if (data.status === 'approved' && data.mode !== 'advisory' && data.mode !== 'audit') {
             overBudgetStep.passed = false;
@@ -917,12 +931,10 @@ async function testCampaignGovernanceDenied(agentUrl, options) {
     // 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: {
@@ -954,13 +966,13 @@ async function testCampaignGovernanceDenied(agentUrl, options) {
         geoStep.error = geoResult.error || 'check_governance failed';
     }
     steps.push(geoStep);
-    // Report failed outcome
+    // Report failed outcome — thread governance_context
     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',
+            governance_context: overBudgetGovernanceContext || '',
             error: {
                 code: 'governance_denied',
                 message: 'Action blocked by governance check',
@@ -978,8 +990,8 @@ async function testCampaignGovernanceDenied(agentUrl, options) {
  */
 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);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
     steps.push(profileStep);
     if (!profileStep.passed) {
         return { steps, profile };
@@ -995,7 +1007,6 @@ async function testCampaignGovernanceConditions(agentUrl, options) {
     }
     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);
@@ -1035,12 +1046,10 @@ async function testCampaignGovernanceConditions(agentUrl, options) {
     // 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: {
@@ -1052,6 +1061,7 @@ async function testCampaignGovernanceConditions(agentUrl, options) {
     }));
     if (checkResult?.success && checkResult?.data) {
         const data = checkResult.data;
+        const initialGovernanceContext = data.governance_context;
         checkStep.details = `Initial check: status=${data.status}`;
         checkStep.response_preview = JSON.stringify({
             check_id: data.check_id,
@@ -1062,8 +1072,9 @@ async function testCampaignGovernanceConditions(agentUrl, options) {
                 category_id: f.category_id,
                 explanation: f.explanation,
             })),
+            governance_context: initialGovernanceContext ? '(present)' : '(absent)',
         }, null, 2);
-        // If we got conditions, apply them and re-check
+        // If we got conditions, apply them and re-check with governance_context round-trip
         if (data.status === 'conditions' && data.conditions?.length > 0) {
             const conditions = data.conditions;
             const appliedConditions = conditions
@@ -1072,7 +1083,6 @@ async function testCampaignGovernanceConditions(agentUrl, options) {
             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: {
@@ -1086,14 +1096,14 @@ async function testCampaignGovernanceConditions(agentUrl, options) {
                     (0, GovernanceMiddleware_1.setAtPath)(adjustedPayload, condition.field, condition.required_value);
                 }
             }
-            // Re-check with adjusted parameters
+            // Re-check with adjusted parameters — thread governance_context from initial check
             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,
+                governance_context: initialGovernanceContext,
             }));
             if (recheckResult?.success && recheckResult?.data) {
                 const recheckData = recheckResult.data;
@@ -1102,6 +1112,7 @@ async function testCampaignGovernanceConditions(agentUrl, options) {
                     check_id: recheckData.check_id,
                     status: recheckData.status,
                     explanation: recheckData.explanation,
+                    governance_context: recheckData.governance_context ? '(present)' : '(absent)',
                 }, null, 2);
             }
             else if (recheckResult && !recheckResult.success) {
@@ -1126,8 +1137,8 @@ async function testCampaignGovernanceConditions(agentUrl, options) {
  */
 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);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
     steps.push(profileStep);
     if (!profileStep.passed) {
         return { steps, profile };
@@ -1143,7 +1154,7 @@ async function testCampaignGovernanceDelivery(agentUrl, options) {
     }
     profile.supports_governance = true;
     const testPlanId = `test-delivery-plan-${Date.now()}`;
-    const testCampaignRef = `test-delivery-campaign-${Date.now()}`;
+    const testMediaBuyId = `test-mb-${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);
@@ -1178,10 +1189,9 @@ async function testCampaignGovernanceDelivery(agentUrl, options) {
     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()}`,
+        media_buy_id: testMediaBuyId,
         phase: 'delivery',
         planned_delivery: {
             total_budget: 3000,
@@ -1203,8 +1213,10 @@ async function testCampaignGovernanceDelivery(agentUrl, options) {
             pacing: 'on_track',
         },
     }));
+    let deliveryGovernanceContext;
     if (deliveryResult?.success && deliveryResult?.data) {
         const data = deliveryResult.data;
+        deliveryGovernanceContext = data.governance_context;
         deliveryStep.details = `Delivery check: status=${data.status}, next_check=${data.next_check || 'not specified'}`;
         deliveryStep.response_preview = JSON.stringify({
             check_id: data.check_id,
@@ -1217,6 +1229,7 @@ async function testCampaignGovernanceDelivery(agentUrl, options) {
                 explanation: f.explanation,
             })),
             next_check: data.next_check,
+            governance_context: data.governance_context ? '(present)' : '(absent)',
         }, null, 2);
     }
     else if (deliveryResult && !deliveryResult.success) {
@@ -1224,14 +1237,14 @@ async function testCampaignGovernanceDelivery(agentUrl, options) {
         deliveryStep.error = deliveryResult.error || 'Delivery-phase check_governance failed';
     }
     steps.push(deliveryStep);
-    // Delivery-phase check with drift (overspend)
+    // Delivery-phase check with drift (overspend) — thread governance_context from first check
     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()}`,
+        media_buy_id: testMediaBuyId,
         phase: 'delivery',
+        governance_context: deliveryGovernanceContext,
         planned_delivery: {
             total_budget: 3000,
             currency: 'USD',
@@ -1273,6 +1286,330 @@ async function testCampaignGovernanceDelivery(agentUrl, options) {
     steps.push(driftStep);
     return { steps, profile };
 }
+/**
+ * Test: Seller Governance Context Round-Trip
+ *
+ * Two-tier test:
+ * 1. (Active) If seller supports register_governance: starts a stub governance
+ *    agent, registers it with the seller, creates a media buy, and verifies
+ *    the seller called check_governance on the stub with the correct
+ *    governance_context.
+ * 2. (Passive) Verifies the seller persists governance_context from
+ *    create_media_buy and returns it on get_media_buys.
+ */
+async function testSellerGovernanceContext(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
+    steps.push(profileStep);
+    if (!profileStep.passed) {
+        return { steps, profile };
+    }
+    // This scenario requires create_media_buy + get_media_buys (seller tools)
+    if (!profile.tools.includes('create_media_buy') || !profile.tools.includes('get_media_buys')) {
+        steps.push({
+            step: 'Seller governance_context support check',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent requires create_media_buy + get_media_buys for governance_context persistence testing',
+        });
+        return { steps, profile };
+    }
+    // Need get_products to create a valid media buy
+    if (!profile.tools.includes('get_products')) {
+        steps.push({
+            step: 'Seller governance_context support check',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent requires get_products for governance_context persistence testing',
+        });
+        return { steps, profile };
+    }
+    // Step 1: Get products
+    const { result: productsResult, step: productsStep } = await (0, client_1.runStep)('Fetch products for governance context test', 'get_products', async () => client.executeTask('get_products', {
+        buying_mode: 'brief',
+        brief: options.brief || 'display advertising',
+        brand: options.brand || { domain: 'test.example.com' },
+    }));
+    steps.push(productsStep);
+    const products = productsResult?.data?.products;
+    if (!products?.length) {
+        return { steps, profile };
+    }
+    // Pick first product with pricing
+    const product = products[0];
+    const pricingOptions = product.pricing_options;
+    const pricing = pricingOptions?.[0];
+    if (!pricing) {
+        steps.push({
+            step: 'Select product for governance context test',
+            passed: false,
+            duration_ms: 0,
+            error: 'No products with pricing options available',
+        });
+        return { steps, profile };
+    }
+    // Step 2: Resolve an account to use for the test
+    const account = await resolveTestAccount(client, profile, options);
+    // Step 3: If seller supports register_governance, start stub and register it
+    let stub = null;
+    let stubUrl = null;
+    let governanceContext = null;
+    const planId = `plan-comply-gc-${Date.now()}`;
+    // register_governance is from AdCP PR #1644 — merged but schemas not yet deployed.
+    // Once deployed and synced, sellers that implement it will get the active stub test.
+    const hasRegisterGovernance = profile.tools.includes('register_governance');
+    if (hasRegisterGovernance) {
+        stub = new stubs_1.GovernanceAgentStub();
+        try {
+            const info = await stub.startHttps();
+            stubUrl = info.url;
+        }
+        catch {
+            // HTTPS generation failed (no openssl?) — fall back to HTTP
+            try {
+                const info = await stub.start();
+                stubUrl = info.url;
+            }
+            catch (err) {
+                steps.push({
+                    step: 'Start governance agent stub',
+                    passed: false,
+                    duration_ms: 0,
+                    error: `Failed to start governance agent stub: ${err.message}`,
+                });
+                return { steps, profile };
+            }
+        }
+        steps.push({
+            step: 'Start governance agent stub',
+            passed: true,
+            duration_ms: 0,
+            details: `Stub running at ${stubUrl}`,
+        });
+        // Register the stub with the seller
+        const { result: registerResult, step: registerStep } = await (0, client_1.runStep)('Register governance agent with seller', 'register_governance', async () => client.executeTask('register_governance', {
+            accounts: [
+                {
+                    account,
+                    governance_agents: [
+                        {
+                            url: stubUrl,
+                            authentication: {
+                                schemes: ['Bearer'],
+                                credentials: stub.authToken,
+                            },
+                        },
+                    ],
+                },
+            ],
+        }));
+        steps.push(registerStep);
+        if (!registerResult?.success) {
+            // Registration failed — fall through to passive test
+            steps.push({
+                step: 'Governance agent registration',
+                passed: true,
+                duration_ms: 0,
+                details: 'register_governance failed — falling back to passive governance_context persistence test',
+                warnings: ['Cannot verify seller calls governance agent — register_governance returned an error'],
+            });
+        }
+        else {
+            // Get governance_context from the stub (simulate buyer's proposed check)
+            try {
+                const checkResult = await (0, mcp_1.callMCPTool)(stubUrl, 'check_governance', {
+                    plan_id: planId,
+                    binding: 'proposed',
+                    caller: 'buyer',
+                    tool: 'create_media_buy',
+                    payload: {},
+                });
+                const parsed = JSON.parse(checkResult.content[0].text);
+                governanceContext = parsed.governance_context;
+                steps.push({
+                    step: 'Obtain governance_context from stub (proposed check)',
+                    passed: true,
+                    duration_ms: 0,
+                    details: `governance_context received (${governanceContext?.length ?? 0} chars)`,
+                });
+            }
+            catch (err) {
+                steps.push({
+                    step: 'Obtain governance_context from stub (proposed check)',
+                    passed: false,
+                    duration_ms: 0,
+                    error: `Failed to call check_governance on stub: ${err.message}`,
+                });
+            }
+        }
+    }
+    else {
+        steps.push({
+            step: 'Check register_governance support',
+            passed: true,
+            duration_ms: 0,
+            details: 'Seller does not support register_governance — running passive governance_context persistence test only',
+            warnings: ['Cannot verify seller calls governance agent — register_governance not supported'],
+        });
+    }
+    // Step 4: Create media buy WITH governance_context
+    const testGovernanceContext = governanceContext || `test-gc-comply-${Date.now()}`;
+    const flightStart = new Date();
+    const flightEnd = new Date(flightStart.getTime() + 30 * 24 * 60 * 60 * 1000);
+    const { result: createResult, step: createStep } = await (0, client_1.runStep)('Create media buy with governance_context', 'create_media_buy', async () => client.executeTask('create_media_buy', {
+        account,
+        brand: options.brand || { domain: 'test.example.com' },
+        start_time: flightStart.toISOString(),
+        end_time: flightEnd.toISOString(),
+        plan_id: governanceContext ? planId : undefined,
+        packages: [
+            {
+                product_id: product.product_id,
+                pricing_option_id: pricing.pricing_option_id,
+                budget: pricing.min_spend_per_package || 500,
+                bid_price: (pricing.floor_price || pricing.fixed_price || 10) + 1,
+                name: 'Governance context test package',
+            },
+        ],
+        governance_context: testGovernanceContext,
+    }));
+    if (!createResult?.success || !createResult?.data) {
+        createStep.passed = false;
+        createStep.error = createResult?.error || 'create_media_buy failed';
+        steps.push(createStep);
+        await stopStub(stub);
+        return { steps, profile };
+    }
+    const mediaBuyId = createResult.data.media_buy_id;
+    createStep.details = `Created media buy ${mediaBuyId} with governance_context`;
+    steps.push(createStep);
+    // Step 5: If stub is active, verify seller called check_governance(committed)
+    if (stub && governanceContext && stubUrl) {
+        // Poll the stub's call log for the committed check (100ms interval, 5s timeout)
+        const pollStart = Date.now();
+        const pollTimeout = 5000;
+        const pollInterval = 100;
+        while (Date.now() - pollStart < pollTimeout) {
+            const calls = stub.getCallsForTool('check_governance');
+            if (calls.some(c => c.params.binding === 'committed'))
+                break;
+            await new Promise(r => setTimeout(r, pollInterval));
+        }
+        const committedCalls = stub.getCallsForTool('check_governance').filter(c => c.params.binding === 'committed');
+        const { step: callbackStep } = await (0, client_1.runStep)('Verify seller called check_governance(committed) on governance agent', 'check_governance (callback)', async () => {
+            if (committedCalls.length === 0) {
+                throw new Error('Seller did not call check_governance(committed) on the registered governance agent. ' +
+                    'Sellers MUST call check_governance with binding="committed" before executing a media buy.');
+            }
+            const callWithContext = committedCalls.find(c => c.params.governance_context === governanceContext);
+            if (!callWithContext) {
+                throw new Error(`Seller called check_governance(committed) but with wrong governance_context. ` +
+                    `Expected "${governanceContext}", got: ${committedCalls.map(c => JSON.stringify(c.params.governance_context)).join(', ')}`);
+            }
+        });
+        if (committedCalls.length > 0) {
+            callbackStep.response_preview = JSON.stringify(committedCalls[0].params, null, 2);
+        }
+        steps.push(callbackStep);
+    }
+    // Step 6: Retrieve the media buy and check for governance_context persistence
+    const { result: getResult, step: getStep } = await (0, client_1.runStep)('Verify governance_context persisted on get_media_buys', 'get_media_buys', async () => client.executeTask('get_media_buys', {
+        media_buy_ids: [mediaBuyId],
+    }));
+    if (getResult?.success && getResult?.data) {
+        const buys = getResult.data.media_buys || [];
+        const buy = buys.find((b) => b.media_buy_id === mediaBuyId) ||
+            (buys.length === 1 ? buys[0] : undefined);
+        if (buy) {
+            const returnedGC = buy.governance_context;
+            if (returnedGC === testGovernanceContext) {
+                getStep.details = 'governance_context persisted and returned correctly';
+            }
+            else if (returnedGC) {
+                getStep.passed = false;
+                getStep.error = `governance_context returned but value changed: expected "${testGovernanceContext}", got "${returnedGC}"`;
+            }
+            else {
+                getStep.passed = false;
+                getStep.error =
+                    'Seller did not return governance_context on get_media_buys. ' +
+                        'Sellers MUST persist governance_context from create_media_buy and include it on all subsequent responses.';
+            }
+            getStep.response_preview = JSON.stringify({
+                media_buy_id: buy.media_buy_id,
+                governance_context: returnedGC ? `(present, ${returnedGC.length} chars)` : '(absent)',
+                status: buy.status,
+            }, null, 2);
+        }
+        else if (buys.length === 0) {
+            getStep.details =
+                'get_media_buys returned 0 buys — agent may be stateless (test agent). Cannot verify governance_context persistence.';
+            getStep.warnings = [
+                'governance_context persistence could not be verified — agent does not persist media buys across requests',
+            ];
+        }
+        else {
+            getStep.passed = false;
+            getStep.error = `Media buy ${mediaBuyId} not found among ${buys.length} returned buys`;
+        }
+    }
+    else if (getResult && !getResult.success) {
+        getStep.passed = false;
+        getStep.error = getResult.error || 'get_media_buys failed';
+    }
+    steps.push(getStep);
+    await stopStub(stub);
+    return { steps, profile };
+}
+/**
+ * Resolve a test account from the seller. Tries list_accounts first,
+ * then sync_accounts, then falls back to a static account reference.
+ */
+async function resolveTestAccount(client, profile, options) {
+    if (profile.tools.includes('list_accounts')) {
+        try {
+            const result = (await client.executeTask('list_accounts', {}));
+            const accounts = result?.data?.accounts;
+            if (accounts?.length && accounts[0]) {
+                return { account_id: accounts[0].account_id };
+            }
+        }
+        catch {
+            // Fall through
+        }
+    }
+    if (profile.tools.includes('sync_accounts')) {
+        try {
+            const result = (await client.executeTask('sync_accounts', {
+                accounts: [
+                    {
+                        brand: options.brand || { domain: 'test.example.com' },
+                        operator: 'comply-test',
+                        billing: 'operator',
+                        sandbox: true,
+                    },
+                ],
+            }));
+            const accounts = result?.data?.accounts;
+            if (accounts?.length && accounts[0] && accounts[0].account_id) {
+                return { account_id: accounts[0].account_id };
+            }
+        }
+        catch {
+            // Fall through
+        }
+    }
+    return { account_id: 'test-gc-acct' };
+}
+async function stopStub(stub) {
+    if (stub) {
+        try {
+            await stub.stop();
+        }
+        catch { }
+    }
+}
 /**
  * Check if agent has any governance protocol tools
  */