From 4729071818482fd7826969b89a0264310a1eacc0 Mon Sep 17 00:00:00 2001 From: Synaeve Date: Thu, 12 Nov 2026 13:20:03 +0100 Subject: [PATCH] fix(compliance): stop optional-tool skips failing dependent steps provenance_audit_observation - declare sync_creatives on both audit reads, as adcp-client#3524 expects - run each audit read in its own phase after the sync create_media_buy_async_lifecycle - run each optional get_task_status/list_tasks read in its own phase - keep the force_task_completion gate on the completed-task reads governance_agent_binding_acceptance - isolate the optional controller read from the recovery sync tests - runner regressions for sellers with and without each optional tool - provenance audit reads name the tool whose state they read --- ...onal-tool-skips-stop-failing-dependents.md | 9 + .../create_media_buy_async_lifecycle.yaml | 65 ++++- .../governance_agent_binding_acceptance.yaml | 14 +- .../provenance_audit_observation.yaml | 31 ++- tests/provenance-tool-gates.test.cjs | 29 ++- tests/sdk-runner-capability-gates.test.cjs | 226 ++++++++++++++++++ 6 files changed, 348 insertions(+), 26 deletions(-) create mode 100644 .changeset/optional-tool-skips-stop-failing-dependents.md diff --git a/.changeset/optional-tool-skips-stop-failing-dependents.md b/.changeset/optional-tool-skips-stop-failing-dependents.md new file mode 100644 index 00000000000..7eae2e99661 --- /dev/null +++ b/.changeset/optional-tool-skips-stop-failing-dependents.md @@ -0,0 +1,9 @@ +--- +"adcontextprotocol": patch +--- + +In three storyboards, a skipped optional tool no longer causes the stateful steps after it to fail. + +- `provenance_audit_observation` (1.1.0): both audit-observation reads declare `sync_creatives`, the tool whose state they read, and each runs in its own phase after the sync. Sellers without `sync_creatives` skip the sync and both reads instead of failing them, and their verifier discovery is still graded. +- `create_media_buy_async_lifecycle` (1.1.0): each optional `get_task_status` and `list_tasks` read runs in its own phase, after the submit or completion phase it depends on. The completed-task reads keep the `force_task_completion` gate. A missing read no longer blocks the other read or the controller completion. +- `governance_agent_binding_acceptance` (1.1.0): the optional `comply_test_controller` read and the recovery `sync_governance` each run in their own phase after account setup. Sellers without the controller still have their recovery graded. diff --git a/static/compliance/source/protocols/media-buy/scenarios/create_media_buy_async_lifecycle.yaml b/static/compliance/source/protocols/media-buy/scenarios/create_media_buy_async_lifecycle.yaml index 47bd8fd352c..8af16a6329d 100644 --- a/static/compliance/source/protocols/media-buy/scenarios/create_media_buy_async_lifecycle.yaml +++ b/static/compliance/source/protocols/media-buy/scenarios/create_media_buy_async_lifecycle.yaml @@ -1,5 +1,5 @@ id: media_buy_seller/create_media_buy_async_lifecycle -version: "1.0.0" +version: "1.1.0" introduced_in: "3.2" title: "Seller exposes create_media_buy tasks through read and list lifecycle tools" category: media_buy_seller @@ -35,7 +35,9 @@ narrative: | get_task_status and list_tasks are optional AdCP task-reconciliation tools. Their steps use requires_tool so a baseline media-buy seller that does not advertise either surface is not failed for omitting it. When advertised, - each surface is graded. + each surface is graded. Each read runs in its own phase and depends only on + the phases that created or completed the task, so an absent surface never + blocks the other surface or the controller completion. agent: interaction_model: media_buy_seller @@ -53,9 +55,10 @@ caller: prerequisites: description: | Seller exposes comply_test_controller in sandbox mode and advertises - force_create_media_buy_arm. The terminal phase also requires the seller to - advertise force_task_completion. Task read/list steps run only when the - corresponding optional tools are advertised. + force_create_media_buy_arm. The completion phase and the completed-task + reads also require the seller to advertise force_task_completion. Task + read/list steps run only when the corresponding optional tools are + advertised. test_kit: "test-kits/acme-outdoor.yaml" controller_seeding: true @@ -187,11 +190,16 @@ phases: path: "packages" description: "Packages are issued only on terminal completion" - - id: reconcile_submitted_task - title: "Read the submitted task consistently" + # A missing_tool skip cascades prerequisite_failed onto stateful peers in the + # same phase and onto phases that depend on it. Keeping each optional read + # as the only stateful step of a phase, with explicit depends_on, keeps an + # absent surface not applicable instead of failing the steps after it. + - id: poll_submitted_task + title: "Poll the submitted task" + depends_on: [submit_async_media_buy] narrative: | - Optional task-reconciliation surfaces must resolve the task identity from - create_media_buy and agree that it is still submitted. + get_task_status, when advertised, must resolve the task identity from + create_media_buy and report that it is still submitted. steps: - id: get_submitted_media_buy_task @@ -234,6 +242,14 @@ phases: value: "submitted" description: "Task remains submitted before controller completion" + - id: list_submitted_task + title: "Discover the submitted task" + depends_on: [submit_async_media_buy] + narrative: | + list_tasks, when advertised, must discover the same task and report + that it is still submitted. + + steps: - id: list_submitted_media_buy_task title: "Discover the submitted task through list_tasks" task: list_tasks @@ -283,14 +299,15 @@ phases: value: "submitted" description: "List and read surfaces agree on submitted status" - - id: complete_and_reconcile_task - title: "Complete the task and observe its terminal result" + - id: complete_task + title: "Complete the submitted task" + depends_on: [submit_async_media_buy] requires_capability: path: compliance_testing.scenarios contains: force_task_completion narrative: | - Resolve the submitted task with a valid media-buy response, then verify - get_task_status and list_tasks converge on the same completed identity. + Resolve the submitted task with a valid media-buy response so the read + surfaces can observe its terminal result. steps: - id: complete_async_media_buy_task @@ -342,6 +359,17 @@ phases: value: "completed" description: "Controller reports the terminal task state" + - id: poll_completed_task + title: "Poll the completed task with its result" + depends_on: [submit_async_media_buy, complete_task] + requires_capability: + path: compliance_testing.scenarios + contains: force_task_completion + narrative: | + get_task_status, when advertised, must return the completed task with + the controller-supplied media-buy result. + + steps: - id: get_completed_media_buy_task title: "Poll the completed task with its result" task: get_task_status @@ -391,6 +419,17 @@ phases: value: "create_media_buy_async_lifecycle--terminal_result" description: "Controller-supplied terminal context round-trips unchanged" + - id: list_completed_task + title: "Discover the completed task" + depends_on: [submit_async_media_buy, complete_task] + requires_capability: + path: compliance_testing.scenarios + contains: force_task_completion + narrative: | + list_tasks, when advertised, must report that the task completed under + the same identity. + + steps: - id: list_completed_media_buy_task title: "Discover the completed task through list_tasks" task: list_tasks diff --git a/static/compliance/source/protocols/media-buy/scenarios/governance_agent_binding_acceptance.yaml b/static/compliance/source/protocols/media-buy/scenarios/governance_agent_binding_acceptance.yaml index 5e694267108..d537001b46e 100644 --- a/static/compliance/source/protocols/media-buy/scenarios/governance_agent_binding_acceptance.yaml +++ b/static/compliance/source/protocols/media-buy/scenarios/governance_agent_binding_acceptance.yaml @@ -1,5 +1,5 @@ id: media_buy_seller/governance_agent_binding_acceptance -version: "1.0.0" +version: "1.1.0" introduced_in: "3.2" title: "Seller rejects an unacceptable governance-agent binding" category: media_buy_seller @@ -132,6 +132,14 @@ phases: path: "accounts[0].governance_agents" description: "A failed response never represents the rejected endpoint as persisted" + # comply_test_controller is optional for this storyboard. A + # missing_test_controller skip cascades prerequisite_failed onto stateful + # peers in its phase, so the controller read and the recovery each run in + # their own phase that depends only on the account setup. + - id: verify_retained_binding + title: "Confirm the accepted binding survived the rejection" + depends_on: [create_account] + steps: - id: verify_prior_binding_retained title: "Read the binding after the rejected replacement" task: comply_test_controller @@ -157,6 +165,10 @@ phases: value: "$context.governance_agent_url" description: "The rejected replacement did not erase or replace the accepted binding" + - id: recover_accepted_binding + title: "Retry with the advertised endpoint" + depends_on: [create_account] + steps: - id: resync_accepted_governance_agent title: "Retry with the advertised endpoint" task: sync_governance diff --git a/static/compliance/source/protocols/media-buy/scenarios/provenance_audit_observation.yaml b/static/compliance/source/protocols/media-buy/scenarios/provenance_audit_observation.yaml index 97f47387424..67da2efaa1f 100644 --- a/static/compliance/source/protocols/media-buy/scenarios/provenance_audit_observation.yaml +++ b/static/compliance/source/protocols/media-buy/scenarios/provenance_audit_observation.yaml @@ -1,5 +1,5 @@ id: media_buy_seller/provenance_audit_observation -version: "1.0.1" +version: "1.1.0" title: "Seller accepts a provenance carve-out claim surfaced as an audit observation" category: media_buy_seller summary: "Buyer submits AI-assisted creatives with human_oversight directed/edited and disclosure.required false. Seller invokes an on-list verifier, records OVERSIGHT_DISCLOSURE_CARVEOUT_CLAIMED audit observations, and accepts the creatives rather than treating the observations as rejections." @@ -34,6 +34,10 @@ narrative: | observation; public seller responses do not have to expose the seller's internal audit log. + The audit queries read state that sync_creatives creates, so they declare + sync_creatives. A seller without sync_creatives skips the sync and both + queries, and its verifier discovery is still graded. + agent: interaction_model: stateful_push capabilities: @@ -309,10 +313,23 @@ phases: match: equals value: false + # Each audit read consumes the state the sync creates, so it declares + # sync_creatives (adcp-client#3524 honors that ahead of the cascade). Each + # also sits alone in its phase: a runner without that precedence applies the + # sole-stateful exemption to a missing_tool skip and then grades the next + # read on its own requires_tool, instead of cascading prerequisite_failed. + - id: observe_directed_audit + title: "Read the directed carve-out audit observation" + depends_on: [accept_carveout_claim] + narrative: | + The sandbox controller exposes the audit observation the seller recorded + while accepting the directed creative. + + steps: - id: query_directed_audit_observation title: "Assert directed carve-out audit observation" task: comply_test_controller - requires_tool: comply_test_controller + requires_tool: sync_creatives schema_ref: "compliance/comply-test-controller-request.json" response_schema_ref: "compliance/comply-test-controller-response.json" doc_ref: "/building/implementation/comply-test-controller" @@ -354,10 +371,18 @@ phases: value: false description: "Observation records the disclosure.required false claim" + - id: observe_edited_audit + title: "Read the edited carve-out audit observation" + depends_on: [accept_carveout_claim] + narrative: | + The sandbox controller exposes the audit observation the seller recorded + while accepting the edited creative. + + steps: - id: query_edited_audit_observation title: "Assert edited carve-out audit observation" task: comply_test_controller - requires_tool: comply_test_controller + requires_tool: sync_creatives schema_ref: "compliance/comply-test-controller-request.json" response_schema_ref: "compliance/comply-test-controller-response.json" doc_ref: "/building/implementation/comply-test-controller" diff --git a/tests/provenance-tool-gates.test.cjs b/tests/provenance-tool-gates.test.cjs index e9586f244da..881d6fb99e2 100644 --- a/tests/provenance-tool-gates.test.cjs +++ b/tests/provenance-tool-gates.test.cjs @@ -10,7 +10,7 @@ const SCENARIOS = [ 'provenance_audit_observation', ]; -test('provenance scenarios gate every optional-tool step by that tool', () => { +test('provenance scenarios gate every optional-tool step by the tool it depends on', () => { let creativeSteps = 0; let controllerSteps = 0; @@ -21,14 +21,25 @@ test('provenance scenarios gate every optional-tool step by that tool', () => { `${scenarioName}.yaml`, ); const scenario = YAML.parse(fs.readFileSync(scenarioPath, 'utf8')); - for (const step of scenario.phases.flatMap((phase) => phase.steps)) { - if (step.task === 'sync_creatives') { - creativeSteps++; - assert.equal(step.requires_tool, 'sync_creatives', `${scenario.id}/${step.id}`); - } - if (step.task === 'comply_test_controller') { - controllerSteps++; - assert.equal(step.requires_tool, 'comply_test_controller', `${scenario.id}/${step.id}`); + for (const phase of scenario.phases) { + for (const step of phase.steps) { + if (step.task === 'sync_creatives') { + creativeSteps++; + assert.equal(step.requires_tool, 'sync_creatives', `${scenario.id}/${step.id}`); + } + if (step.task === 'comply_test_controller') { + controllerSteps++; + // Audit reads consume the state sync_creatives creates, so they name + // that tool; the storyboard-level controller requirement covers the + // controller itself. A separate phase keeps a skipped sync from + // cascading onto them on runners that grade the cascade first. + assert.equal(step.requires_tool, 'sync_creatives', `${scenario.id}/${step.id}`); + assert.ok(scenario.requires.includes('controller'), scenario.id); + assert.ok( + !phase.steps.some(peer => peer.task === 'sync_creatives'), + `${scenario.id}/${step.id} shares a phase with the sync it depends on` + ); + } } } } diff --git a/tests/sdk-runner-capability-gates.test.cjs b/tests/sdk-runner-capability-gates.test.cjs index 4b48b5a727a..9d5a2849c70 100644 --- a/tests/sdk-runner-capability-gates.test.cjs +++ b/tests/sdk-runner-capability-gates.test.cjs @@ -43,6 +43,23 @@ const creativeScenariosPath = path.join( 'scenarios' ); +const PROVENANCE_AUDIT_SCENARIO = 'query_provenance_audit_observations'; +const PROVENANCE_CARVEOUT_CODE = 'OVERSIGHT_DISCLOSURE_CARVEOUT_CLAIMED'; +const PROVENANCE_DIRECTED_CREATIVE_ID = 'acme_provenance_audit_directed_001'; +const PROVENANCE_REJECTION_CODE = 'PROVENANCE_CLAIM_CONTRADICTED'; +const ASYNC_LIFECYCLE_TASK_ID = 'task_async_media_buy_lifecycle_q3'; +const FORCE_SUBMITTED_SCENARIO = 'force_create_media_buy_arm'; +const FORCE_COMPLETION_SCENARIO = 'force_task_completion'; +const GOVERNANCE_BINDING_CAPABILITIES = { + adcp: { + governance_enforcement: { + accepted_governance_agents: { + any_of: [{ kind: 'agent_url', agent_url: 'https://test-agent.adcontextprotocol.org/' }], + }, + }, + }, +}; + function loadMediaBuyStoryboard(name) { const candidates = [ path.join(mediaBuyScenariosPath, `${name}.yaml`), @@ -2010,3 +2027,212 @@ test('portfolio_routing_scope skips the product read for brief-only sellers', as assert.deepEqual(dispatched.filter(call => call.task === 'get_products'), []); assert.equal(result.failed_count, 0); }); + +function loadParsedMediaBuyStoryboard(name) { + return parseStoryboard(fs.readFileSync(path.join(mediaBuyScenariosPath, `${name}.yaml`), 'utf8')); +} + +// Response schemas are linted separately. These stubs return only the fields +// the authored checks read, so each run isolates how a missing optional tool +// is graded and what it blocks. +async function runOptionalToolSeller(storyboard, tools, rawCapabilities, respond) { + const executable = { + ...storyboard, + prerequisites: undefined, + fixtures: undefined, + phases: storyboard.phases.map(phase => ({ + ...phase, + steps: phase.steps.map(step => ({ + ...step, + validations: (step.validations ?? []).filter(validation => validation.check !== 'response_schema'), + })), + })), + }; + const agentTools = ['get_adcp_capabilities', ...tools]; + const dispatched = []; + const result = await runStoryboard('https://agent.example/mcp', executable, { + _profile: { tools: agentTools, raw_capabilities: rawCapabilities }, + agentTools, + _client: { + resetContext() {}, + async executeTask(task, request) { + dispatched.push(request.scenario ? `${task}:${request.scenario}` : task); + const data = { ...respond(task, request), context: request.context }; + return { success: true, status: data.status ?? 'completed', data }; + }, + }, + }); + return { result, dispatched }; +} + +function phaseSteps(result, phaseId) { + const phase = result.phases.find(candidate => candidate.phase_id === phaseId); + assert.ok(phase, `missing phase ${phaseId}`); + return phase.steps; +} + +function assertNoCascadeFailures(result) { + const cascaded = result.phases.flatMap(phase => phase.steps).filter(step => step.skip_reason === 'prerequisite_failed'); + assert.deepEqual(cascaded.map(step => step.step_id), []); + assert.equal(result.failed_count, 0, JSON.stringify(result.phases)); + assert.equal(result.overall_passed, true); +} + +test('provenance audit reads skip with a missing sync_creatives instead of failing', async () => { + const storyboard = loadParsedMediaBuyStoryboard('provenance_audit_observation'); + const [product] = storyboard.fixtures.products; + const respond = (task, request) => { + if (task === 'get_products') return { products: [product] }; + if (task === 'sync_creatives') { + return { creatives: request.creatives.map(creative => ({ creative_id: creative.creative_id, action: 'created' })) }; + } + const humanOversight = request.params.creative_id === PROVENANCE_DIRECTED_CREATIVE_ID ? 'directed' : 'edited'; + return { + success: true, + audit_observations: [{ + code: PROVENANCE_CARVEOUT_CODE, + details: { claimed_value: { human_oversight: humanOversight, disclosure_required: false } }, + }], + }; + }; + const optedIn = { creative: { supports_provenance: true }, compliance_testing: { scenarios: [PROVENANCE_AUDIT_SCENARIO] } }; + + const withoutSync = await runOptionalToolSeller(storyboard, ['get_products', 'comply_test_controller'], optedIn, respond); + assert.deepEqual(withoutSync.dispatched, ['get_products']); + assertNoCascadeFailures(withoutSync.result); + const skipped = ['accept_carveout_claim', 'observe_directed_audit', 'observe_edited_audit'] + .flatMap(phaseId => phaseSteps(withoutSync.result, phaseId)); + assert.equal(skipped.length, 3); + for (const step of skipped) { + assert.equal(step.skip_reason, 'missing_tool', step.step_id); + assert.match(step.skip.detail, /sync_creatives/, step.step_id); + } + + // Coverage follows the advertised tool, not a creative-library declaration. + const withSync = await runOptionalToolSeller( + storyboard, + ['get_products', 'sync_creatives', 'comply_test_controller'], + optedIn, + respond + ); + const auditQuery = `comply_test_controller:${PROVENANCE_AUDIT_SCENARIO}`; + assert.deepEqual(withSync.dispatched, ['get_products', 'sync_creatives', auditQuery, auditQuery]); + assertNoCascadeFailures(withSync.result); + + // The reads still depend on the sync: a rejected sync must block both. + const rejectSync = (task, request) => (task === 'sync_creatives' + ? { creatives: request.creatives.map(creative => ({ + creative_id: creative.creative_id, + action: 'failed', + errors: [{ code: PROVENANCE_REJECTION_CODE }], + })) } + : respond(task, request)); + const rejected = await runOptionalToolSeller( + storyboard, + ['get_products', 'sync_creatives', 'comply_test_controller'], + optedIn, + rejectSync + ); + assert.deepEqual(rejected.dispatched, ['get_products', 'sync_creatives']); + assert.equal(rejected.result.overall_passed, false); + for (const phaseId of ['observe_directed_audit', 'observe_edited_audit']) { + const [read] = phaseSteps(rejected.result, phaseId); + assert.equal(read.skip_reason, 'prerequisite_failed', read.step_id); + assert.equal(read.passed, false, read.step_id); + } +}); + +test('optional task reconciliation reads never block each other or the controller completion', async () => { + const storyboard = loadParsedMediaBuyStoryboard('create_media_buy_async_lifecycle'); + const respondWithLifecycle = () => { + let terminalResult; + return (task, request) => { + if (request.scenario === FORCE_SUBMITTED_SCENARIO) { + return { success: true, forced: { arm: 'submitted', task_id: ASYNC_LIFECYCLE_TASK_ID } }; + } + if (request.scenario === FORCE_COMPLETION_SCENARIO) { + terminalResult = request.params.result; + return { success: true, current_state: 'completed' }; + } + if (task === 'create_media_buy') return { status: 'submitted', task_id: ASYNC_LIFECYCLE_TASK_ID }; + const status = terminalResult ? 'completed' : 'submitted'; + const identity = { task_id: ASYNC_LIFECYCLE_TASK_ID, task_type: 'create_media_buy', status }; + if (task === 'get_task_status') return { ...identity, protocol: 'media-buy', ...(terminalResult && { result: terminalResult }) }; + return { query_summary: { total_matching: 1 }, tasks: [{ ...identity, domain: 'media-buy' }] }; + }; + }; + const bothScenarios = { compliance_testing: { scenarios: [FORCE_SUBMITTED_SCENARIO, FORCE_COMPLETION_SCENARIO] } }; + const forceSubmitted = `comply_test_controller:${FORCE_SUBMITTED_SCENARIO}`; + const forceCompletion = `comply_test_controller:${FORCE_COMPLETION_SCENARIO}`; + const runSeller = (tools, capabilities = bothScenarios) => + runOptionalToolSeller(storyboard, ['create_media_buy', ...tools, 'comply_test_controller'], capabilities, respondWithLifecycle()); + + const baseline = await runSeller([]); + assert.deepEqual(baseline.dispatched, [forceSubmitted, 'create_media_buy', forceCompletion]); + assertNoCascadeFailures(baseline.result); + + const listOnly = await runSeller(['list_tasks']); + assert.deepEqual(listOnly.dispatched, [forceSubmitted, 'create_media_buy', 'list_tasks', forceCompletion, 'list_tasks']); + assertNoCascadeFailures(listOnly.result); + assert.equal(phaseSteps(listOnly.result, 'poll_submitted_task')[0].skip_reason, 'missing_tool'); + + const bothReads = await runSeller(['get_task_status', 'list_tasks']); + assert.deepEqual(bothReads.dispatched, [ + forceSubmitted, 'create_media_buy', 'get_task_status', 'list_tasks', + forceCompletion, 'get_task_status', 'list_tasks', + ]); + assertNoCascadeFailures(bothReads.result); + assert.equal(bothReads.result.skipped_count, 0); + + // Without the completion hook, the completed-task reads have nothing to + // observe. They must carry the completion gate themselves rather than rely + // on a runner forwarding the skipped completion phase through depends_on. + const noCompletionHook = await runSeller( + ['get_task_status', 'list_tasks'], + { compliance_testing: { scenarios: [FORCE_SUBMITTED_SCENARIO] } } + ); + assert.deepEqual(noCompletionHook.dispatched, [forceSubmitted, 'create_media_buy', 'get_task_status', 'list_tasks']); + assertNoCascadeFailures(noCompletionHook.result); + for (const phaseId of ['complete_task', 'poll_completed_task', 'list_completed_task']) { + for (const step of phaseSteps(noCompletionHook.result, phaseId)) { + assert.equal(step.skip_reason, 'not_applicable', step.step_id); + assert.match(step.skip.detail, /force_task_completion/, step.step_id); + } + } +}); + +test('governance binding recovery is graded without the optional controller read', async () => { + const storyboard = loadParsedMediaBuyStoryboard('governance_agent_binding_acceptance'); + const acceptedUrl = storyboard.context.governance_agent_url; + const respond = (task, request) => { + if (task === 'sync_accounts') return { accounts: [{ account_id: 'acct_governance_binding' }] }; + if (task === 'comply_test_controller') return { success: true, simulated: { governance_agents: [{ url: acceptedUrl }] } }; + const url = request.accounts[0].governance_agents[0].url; + if (url !== acceptedUrl) return { accounts: [{ status: 'failed', errors: [{ code: 'GOVERNANCE_AGENT_NOT_ACCEPTED' }] }] }; + return { accounts: [{ status: 'synced', governance_agents: [{ url }] }] }; + }; + const setup = ['sync_accounts', 'sync_governance', 'sync_governance']; + + const withoutController = await runOptionalToolSeller( + storyboard, + ['sync_accounts', 'sync_governance'], + GOVERNANCE_BINDING_CAPABILITIES, + respond + ); + assert.deepEqual(withoutController.dispatched, [...setup, 'sync_governance']); + assertNoCascadeFailures(withoutController.result); + assert.equal(phaseSteps(withoutController.result, 'verify_retained_binding')[0].skip_reason, 'missing_test_controller'); + + const withController = await runOptionalToolSeller( + storyboard, + ['sync_accounts', 'sync_governance', 'comply_test_controller'], + GOVERNANCE_BINDING_CAPABILITIES, + respond + ); + assert.deepEqual(withController.dispatched, [ + ...setup, + 'comply_test_controller:query_account_governance_binding', + 'sync_governance', + ]); + assertNoCascadeFailures(withController.result); +});