@adcp/sdk 14.0.0-rc.49 → 14.0.0-rc.51

package/dist/lib/testing/storyboard/runner.mjs

@@ -7,7 +7,11 @@ import {
   getOrDiscoverProfile,
   runStep
 } from "../client.mjs";
-import { closeScopedConnections, withMCPConnectionScope } from "../../protocols/index.mjs";
+import {
+  closeScopedConnections,
+  prepareProtocolToolCall,
+  withMCPConnectionScope
+} from "../../protocols/index.mjs";
 import { getCapturesFromError, withRawResponseCapture } from "../../protocols/rawResponseCapture.mjs";
 import { defaultStoryboardResponseProjection, executeStoryboardTask } from "./task-map.mjs";
 import { applyFunctionalRequestSigning } from "./request-signing/functional-dispatch.mjs";
@@ -49,6 +53,7 @@ import {
 } from "./creative-assets.mjs";
 import { resolveAccount, resolveBrand } from "../client.mjs";
 import { requestUsesIdempotency, generateIdempotencyKey } from "../../utils/idempotency.mjs";
+import { isAdcpVersionAtLeast } from "../../utils/adcp-version-config.mjs";
 import {
   getSchemaDefaultByPath,
   getSchemaValidatorByRef,
@@ -286,7 +291,7 @@ function evaluateCapabilityPredicate(predicate, actual) {
     if (!Array.isArray(actual)) {
       return `Capability predicate \`${predicate.path}\` must contain ${JSON.stringify(predicate.contains)}: agent declared ${actual === void 0 ? "no value" : JSON.stringify(actual)}.`;
     }
-    if (!actual.some((value) => capabilityValuesEqual(value, predicate.contains))) {
+    if (!actual.some((value) => capabilityContainsValue(predicate.path, value, predicate.contains))) {
       return `Capability predicate \`${predicate.path}\` must contain ${JSON.stringify(predicate.contains)}: agent declared ${JSON.stringify(actual)}.`;
     }
     return null;
@@ -295,7 +300,7 @@ function evaluateCapabilityPredicate(predicate, actual) {
     if (!Array.isArray(actual)) {
       return `Capability predicate \`${predicate.path}\` must not contain ${JSON.stringify(predicate.not_contains)}: agent declared ${actual === void 0 ? "no value" : JSON.stringify(actual)}.`;
     }
-    if (actual.some((value) => capabilityValuesEqual(value, predicate.not_contains))) {
+    if (actual.some((value) => capabilityContainsValue(predicate.path, value, predicate.not_contains))) {
       return `Capability predicate \`${predicate.path}\` must not contain ${JSON.stringify(predicate.not_contains)}: agent declared ${JSON.stringify(actual)}.`;
     }
     return null;
@@ -308,6 +313,20 @@ function evaluateCapabilityPredicate(predicate, actual) {
   }
   return null;
 }
+function capabilityContainsValue(path, actual, expected) {
+  if (path !== "adcp.governance_enforcement.tasks") return capabilityValuesEqual(actual, expected);
+  if (!actual || !expected || typeof actual !== "object" || typeof expected !== "object") {
+    return capabilityValuesEqual(actual, expected);
+  }
+  const actualTask = actual;
+  const expectedTask = expected;
+  if (typeof expectedTask.task !== "string" || !Array.isArray(expectedTask.modes) || expectedTask.modes.length === 0 || Object.keys(expectedTask).some((key) => key !== "task" && key !== "modes")) {
+    return capabilityValuesEqual(actual, expected);
+  }
+  const actualModes = actualTask.modes;
+  if (!Array.isArray(actualModes)) return false;
+  return actualTask.task === expectedTask.task && expectedTask.modes.every((mode) => actualModes.some((actualMode) => capabilityValuesEqual(actualMode, mode)));
+}
 function capabilityValuesEqual(a, b) {
   if (a === b) return true;
   if (typeof a !== typeof b || a === null || b === null || typeof a !== "object") return false;
@@ -902,11 +921,6 @@ function validateAgentsMap(agentUrlOrUrls, storyboard, options) {
       "runStoryboard: `agents` is incompatible with `_client` override. A single client cannot serve multiple agents; per-agent clients are constructed from the map."
     );
   }
-  if (storyboard.prerequisites?.controller_seeding === true && options.skip_controller_seeding !== true) {
-    throw new Error(
-      "runStoryboard: `agents` + `prerequisites.controller_seeding: true` is not yet supported. Controller seeding currently targets a single tenant; cross-tenant seed routing is a follow-up. Pre-seed each tenant out-of-band and pass `skip_controller_seeding: true` to opt out of the runner-side seeding loop."
-    );
-  }
   const firstArgEmpty = agentUrlOrUrls === "" || Array.isArray(agentUrlOrUrls) && agentUrlOrUrls.length === 0;
   if (!firstArgEmpty) {
     throw new Error(
@@ -914,6 +928,24 @@ function validateAgentsMap(agentUrlOrUrls, storyboard, options) {
     );
   }
 }
+function fixtureOwnerTask(scenario) {
+  switch (scenario) {
+    case "seed_account":
+    case "seed_buyer_agent":
+      return "sync_accounts";
+    case "seed_product":
+    case "seed_pricing_option":
+      return "get_products";
+    case "seed_creative_format":
+      return "list_creative_formats";
+    case "seed_creative":
+      return "sync_creatives";
+    case "seed_plan":
+      return "sync_plans";
+    case "seed_media_buy":
+      return "get_media_buys";
+  }
+}
 function buildCapabilityUnsupportedResult(agentUrls, storyboard, detail) {
   const syntheticStep = {
     storyboard_id: storyboard.id,
@@ -1586,6 +1618,20 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
   }
   const allRequires = resolveStoryboardRequires(storyboard, options);
   let dispatch = routingContext && options.agents ? createRoutingDispatcher(routingContext, options, options.agents) : createDispatcher(agentUrls, clients, "round-robin", dispatchOffset, profile);
+  const routedRootCapabilityDetail = (() => {
+    if (!routingContext || !options.default_agent || storyboardCapabilityPredicates(storyboard).length === 0)
+      return null;
+    const profile2 = routingContext.profiles.get(options.default_agent);
+    if (!profile2) {
+      return evaluateStoryboardCapabilityGates(storyboard, void 0, void 0, options.adcpVersion) ?? "Capability predicates could not be evaluated: no discovered agent profile.";
+    }
+    return evaluateStoryboardCapabilityGates(
+      storyboard,
+      profile2,
+      normalizeAgentToolNames(profile2.tools),
+      options.adcpVersion
+    );
+  })();
   const routedStepCapabilitySkips = /* @__PURE__ */ new Map();
   const routedPhaseCapabilitySkips = /* @__PURE__ */ new Map();
   const routedStepRequirements = /* @__PURE__ */ new Map();
@@ -1625,7 +1671,7 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         try {
           const selected = dispatch.nextFor(step);
           const selectedOptions = selected.options;
-          const rootDetail = evaluateStoryboardCapabilityGates(
+          const rootDetail = options.default_agent ? routedRootCapabilityDetail : evaluateStoryboardCapabilityGates(
             storyboard,
             selected.profile,
             selectedOptions.agentTools,
@@ -1966,13 +2012,35 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         options,
         context,
         clients[0],
-        routingContext ? (task) => {
-          if (!options.agentTools?.includes(task))
-            return { client: clients[0], options: { ...options, agentTools: [] } };
+        routingContext ? (task, call) => {
+          if (storyboard.prerequisites?.controller_seeding !== true) {
+            if (!options.agentTools?.includes(task)) {
+              return { client: clients[0], options: { ...options, agentTools: [] } };
+            }
+            const selected2 = dispatch.nextFor({
+              id: `__fixture_resolution_${task}__`,
+              title: `Fixture resolution via ${task}`,
+              task
+            });
+            return { client: selected2.client, options: selected2.options };
+          }
+          const ownerTask = call ? fixtureOwnerTask(call.scenario) : task;
+          const matching = storyboard.phases.flatMap(
+            (phase) => phase.steps.filter((step) => step.task === ownerTask && step.agent !== void 0)
+          );
+          const keys = [...new Set(matching.map((step) => step.agent))];
+          if (keys.length > 1) {
+            throw new RoutingError(
+              `Fixture ${call?.step_id ?? task} has multiple owner routes [${keys.join(", ")}]. Disambiguate the storyboard topology before seeding (adcp-client#3047).`,
+              ownerTask,
+              "ambiguous fixture owner"
+            );
+          }
           const selected = dispatch.nextFor({
-            id: `__fixture_resolution_${task}__`,
-            title: `Fixture resolution via ${task}`,
-            task
+            id: `__fixture_resolution_${call?.step_id ?? task}__`,
+            title: `Fixture resolution via ${ownerTask}`,
+            task: ownerTask,
+            ...keys.length === 1 && { agent: keys[0] }
           });
           return { client: selected.client, options: selected.options };
         } : void 0
@@ -3223,10 +3291,16 @@ function unresolvedStepContextVars(step, request, context, runState) {
 }
 function buildStepRequest(step, effectiveStep, context, options, runnerVars) {
   let request;
+  const governedSource = options.request ?? step.sample_request;
+  const payloadBoundGovernance = isAdcpVersionAtLeast(options.adcpVersion ?? ADCP_VERSION, "3.2.0-beta.1");
+  const contextGovernance = step.context_inputs?.length && Object.prototype.hasOwnProperty.call(applyContextInputs({}, step.context_inputs, context), "governance_context");
+  const governedFixture = payloadBoundGovernance && effectiveStep.task !== "check_governance" && effectiveStep.task !== "report_plan_outcome" && (governedSource !== void 0 && Object.prototype.hasOwnProperty.call(governedSource, "governance_context") || contextGovernance);
   if (options.request) {
     request = injectContext({ ...options.request }, context, runnerVars);
   } else if (step.expect_error && step.sample_request) {
     request = injectContext({ ...step.sample_request }, context, runnerVars);
+  } else if (governedFixture) {
+    request = injectContext({ ...step.sample_request ?? {} }, context, runnerVars);
   } else if (hasRequestEnricher(effectiveStep.task)) {
     request = enrichRequest(effectiveStep, context, options, runnerVars);
   } else if (step.sample_request) {
@@ -3237,13 +3311,48 @@ function buildStepRequest(step, effectiveStep, context, options, runnerVars) {
   if (step.context_inputs?.length) {
     request = applyContextInputs(request, step.context_inputs, context);
   }
+  if (governedFixture) {
+    request = applyBrandInvariant(request, options, effectiveStep.task, { omit_account: true });
+    return options.disable_sandbox === true ? applyDisableSandboxHint(request, effectiveStep.task) : request;
+  }
   request = applyBrandInvariant(request, options, effectiveStep.task, { omit_account: step.omit_account });
   if (options.disable_sandbox === true) {
     request = applyDisableSandboxHint(request, effectiveStep.task);
   }
   request = applyIdempotencyInvariant(request, effectiveStep.task, step);
+  if (payloadBoundGovernance && effectiveStep.task === "check_governance" && request.phase !== "delivery" && request.payload !== null && typeof request.payload === "object" && !Array.isArray(request.payload)) {
+    const toolName = typeof request.tool === "string" ? request.tool : void 0;
+    const brandedPayload = applyBrandInvariant(request.payload, options, toolName, {
+      omit_account: true
+    });
+    let payload = prepareGovernedStoryboardWireArgs(
+      brandedPayload,
+      toolName,
+      typeof request.target_agent === "string" ? request.target_agent : "",
+      options
+    );
+    if (options.disable_sandbox === true) {
+      payload = applyDisableSandboxHint(payload, toolName);
+    }
+    request = {
+      ...request,
+      payload
+    };
+  }
   return request;
 }
+function prepareGovernedStoryboardWireArgs(request, toolName, agentUri, options) {
+  return prepareProtocolToolCall(
+    { id: "governed-target", name: "governed-target", agent_uri: agentUri, protocol: "mcp" },
+    request,
+    {
+      toolName,
+      adcpVersion: options.adcpVersion,
+      wireAdcpVersion: options.wireAdcpVersion,
+      versionEnvelope: options.versionEnvelope
+    }
+  ).args;
+}
 async function executeStep(client, step, storyboardId, phaseId, context, allSteps, options, state) {
   const runState = state ?? {
     contributions: /* @__PURE__ */ new Set(),
@@ -3525,8 +3634,43 @@ async function executeStep(client, step, storyboardId, phaseId, context, allStep
       extraction: { path: "none" }
     };
   }
-  const testsIdempotencyKeyOmission = step.omit_idempotency_key === true && requestUsesIdempotency(effectiveStep.task, request);
-  const testsMissingAccount = step.omit_account === true && effectiveStep.task === "create_media_buy";
+  const governedRequest = isAdcpVersionAtLeast(options.adcpVersion ?? ADCP_VERSION, "3.2.0-beta.1") && effectiveStep.task !== "check_governance" && effectiveStep.task !== "report_plan_outcome" && Object.prototype.hasOwnProperty.call(request, "governance_context");
+  const responseProjection = governedRequest ? "raw" : effectiveStep.response_projection ?? defaultStoryboardResponseProjection(effectiveStep.task, effectiveStep.comply_scenario);
+  if (governedRequest && !step.expect_error && step.omit_idempotency_key !== true && requestUsesIdempotency(effectiveStep.task, request) && (typeof request.idempotency_key !== "string" || request.idempotency_key.length === 0)) {
+    const detail = `Governed ${effectiveStep.task} must author the idempotency_key approved by check_governance; the runner cannot mint one after approval.`;
+    return {
+      step_id: step.id,
+      phase_id: phaseId,
+      title: step.title,
+      task: effectiveStep.task,
+      passed: false,
+      duration_ms: 0,
+      validations: [
+        {
+          check: "governed_payload",
+          passed: false,
+          description: detail,
+          json_pointer: "/idempotency_key",
+          expected: "the key authorized by check_governance",
+          actual: request.idempotency_key ?? null,
+          schema_id: null,
+          schema_url: null
+        }
+      ],
+      context,
+      error: detail,
+      next: getNextStepPreview(step.id, allSteps, context, runState.runnerVars),
+      request: {
+        transport: options.protocol === "a2a" ? "a2a" : "mcp",
+        operation: effectiveStep.task,
+        payload: redactSecrets(request),
+        ...runState.agentUrl ? { url: redactOAuthUrlForOutput(runState.agentUrl) } : {}
+      },
+      extraction: { path: "none" }
+    };
+  }
+  const testsIdempotencyKeyOmission = (step.omit_idempotency_key === true || governedRequest && (typeof request.idempotency_key !== "string" || request.idempotency_key.length === 0)) && requestUsesIdempotency(effectiveStep.task, request);
+  const testsMissingAccount = effectiveStep.task === "create_media_buy" && (step.omit_account === true || governedRequest && !Object.prototype.hasOwnProperty.call(request, "account"));
   const testsSchemaInvalidRequest = step.expect_error === true && step.negative_path !== "payload_well_formed";
   let rawProbeHeaders;
   try {
@@ -3638,7 +3782,8 @@ async function executeStep(client, step, storyboardId, phaseId, context, allStep
               skipIdempotencyAutoInject: testsIdempotencyKeyOmission,
               skipAccountValidation: testsMissingAccount,
               skipRequestValidation: testsSchemaInvalidRequest,
-              responseProjection: effectiveStep.response_projection ?? defaultStoryboardResponseProjection(effectiveStep.task, effectiveStep.comply_scenario),
+              preserveGovernedPayload: governedRequest,
+              responseProjection,
               mediaBuyLifecycleCompatibility: options.mediaBuyLifecycleCompatibility,
               signal: options.signal
             })
@@ -3688,7 +3833,7 @@ async function executeStep(client, step, storyboardId, phaseId, context, allStep
         const probe = await rawMcpProbe({
           agentUrl: runState.agentUrl,
           toolName: effectiveStep.task,
-          args: request,
+          args: governedRequest ? prepareGovernedStoryboardWireArgs(request, effectiveStep.task, runState.agentUrl, options) : request,
           headers: rawProbeHeaders,
           allowPrivateIp: options.allow_http === true,
           fetchFn: options.transport?.trustedFetchFn
@@ -3731,7 +3876,8 @@ async function executeStep(client, step, storyboardId, phaseId, context, allStep
           skipIdempotencyAutoInject: testsIdempotencyKeyOmission,
           skipAccountValidation: testsMissingAccount,
           skipRequestValidation: testsSchemaInvalidRequest,
-          responseProjection: effectiveStep.response_projection ?? defaultStoryboardResponseProjection(effectiveStep.task, effectiveStep.comply_scenario),
+          preserveGovernedPayload: governedRequest,
+          responseProjection,
           mediaBuyLifecycleCompatibility: options.mediaBuyLifecycleCompatibility,
           signal: options.signal
         }
@@ -3763,7 +3909,8 @@ async function executeStep(client, step, storyboardId, phaseId, context, allStep
         skipIdempotencyAutoInject: testsIdempotencyKeyOmission,
         skipAccountValidation: testsMissingAccount,
         skipRequestValidation: testsSchemaInvalidRequest,
-        responseProjection: effectiveStep.response_projection ?? defaultStoryboardResponseProjection(effectiveStep.task, effectiveStep.comply_scenario),
+        preserveGovernedPayload: governedRequest,
+        responseProjection,
         mediaBuyLifecycleCompatibility: options.mediaBuyLifecycleCompatibility,
         signal: options.signal
       });
@@ -4777,14 +4924,29 @@ async function executeProbeStep(client, step, phaseId, context, allSteps, option
 }
 function applyFixtureBindingsSafely(request, task, options, runState) {
   try {
+    const boundRequest = applyFixtureBindingsToRequest(
+      request,
+      task,
+      runState.fixtureBindings,
+      options.adcpVersion ?? ADCP_VERSION
+    );
+    if (task === "check_governance" && boundRequest.phase !== "delivery" && typeof boundRequest.tool === "string" && boundRequest.payload !== null && typeof boundRequest.payload === "object" && !Array.isArray(boundRequest.payload)) {
+      return {
+        ok: true,
+        request: {
+          ...boundRequest,
+          payload: applyFixtureBindingsToRequest(
+            boundRequest.payload,
+            boundRequest.tool,
+            runState.fixtureBindings,
+            options.adcpVersion ?? ADCP_VERSION
+          )
+        }
+      };
+    }
     return {
       ok: true,
-      request: applyFixtureBindingsToRequest(
-        request,
-        task,
-        runState.fixtureBindings,
-        options.adcpVersion ?? ADCP_VERSION
-      )
+      request: boundRequest
     };
   } catch (error) {
     return { ok: false, error: error instanceof Error ? error.message : String(error) };
@@ -6418,13 +6580,16 @@ export {
   applyAdcpVersionRunOptions,
   applyBrandInvariant,
   applyDisableSandboxHint,
+  applyFixtureBindingsSafely,
   applyIdempotencyInvariant,
   applyStoryboardVersionOptions,
   buildDiscoveryFailedResult,
+  buildStepRequest,
   describeStoryboardCapabilityGates,
   evaluateCapabilityPredicate,
   getFirstStepPreview,
   listStrictOnlyFailures,
+  prepareGovernedStoryboardWireArgs,
   resolveCapabilityPath,
   runStoryboard,
   runStoryboardStep,

package/dist/lib/testing/storyboard/seeding.d.mts

@@ -30,7 +30,7 @@ export declare const CONTROLLER_SEEDING_PHASE_ID = "__controller_seeding__";
  * importing it here would cross the testing ⇄ server module boundary. */
 type SeedScenario = 'seed_account' | 'seed_product' | 'seed_pricing_option' | 'seed_creative_format' | 'seed_creative' | 'seed_plan' | 'seed_media_buy';
 type BuyerAgentSeedScenario = 'seed_buyer_agent';
-interface SeedCall {
+export interface SeedCall {
     step_id: string;
     title: string;
     scenario: SeedScenario | BuyerAgentSeedScenario;
@@ -81,7 +81,7 @@ export interface ControllerSeedingResult {
  * not applicable (opt-out, no declaration, empty fixtures) so the runner can
  * treat a no-op identically to a non-seeding storyboard.
  */
-export declare function runControllerSeeding(client: TestClient, storyboard: Storyboard, options: StoryboardRunOptions, context: StoryboardContext, discoveryClient?: TestClient, resolveFixtureAgent?: (task: 'comply_test_controller' | 'get_products') => {
+export declare function runControllerSeeding(client: TestClient, storyboard: Storyboard, options: StoryboardRunOptions, context: StoryboardContext, discoveryClient?: TestClient, resolveFixtureAgent?: (task: 'comply_test_controller' | 'get_products', call?: SeedCall) => {
     client: TestClient;
     options: StoryboardRunOptions;
 }): Promise<ControllerSeedingResult | null>;

package/dist/lib/testing/storyboard/seeding.d.ts

@@ -30,7 +30,7 @@ export declare const CONTROLLER_SEEDING_PHASE_ID = "__controller_seeding__";
  * importing it here would cross the testing ⇄ server module boundary. */
 type SeedScenario = 'seed_account' | 'seed_product' | 'seed_pricing_option' | 'seed_creative_format' | 'seed_creative' | 'seed_plan' | 'seed_media_buy';
 type BuyerAgentSeedScenario = 'seed_buyer_agent';
-interface SeedCall {
+export interface SeedCall {
     step_id: string;
     title: string;
     scenario: SeedScenario | BuyerAgentSeedScenario;
@@ -81,7 +81,7 @@ export interface ControllerSeedingResult {
  * not applicable (opt-out, no declaration, empty fixtures) so the runner can
  * treat a no-op identically to a non-seeding storyboard.
  */
-export declare function runControllerSeeding(client: TestClient, storyboard: Storyboard, options: StoryboardRunOptions, context: StoryboardContext, discoveryClient?: TestClient, resolveFixtureAgent?: (task: 'comply_test_controller' | 'get_products') => {
+export declare function runControllerSeeding(client: TestClient, storyboard: Storyboard, options: StoryboardRunOptions, context: StoryboardContext, discoveryClient?: TestClient, resolveFixtureAgent?: (task: 'comply_test_controller' | 'get_products', call?: SeedCall) => {
     client: TestClient;
     options: StoryboardRunOptions;
 }): Promise<ControllerSeedingResult | null>;

package/dist/lib/testing/storyboard/seeding.js

@@ -223,7 +223,10 @@ async function runControllerSeeding(client, storyboard, options, context, discov
     );
   }
   if (storyboard.prerequisites?.controller_seeding !== true) return null;
-  const controllerRouteTools = resolveFixtureAgent ? resolveFixtureAgent("comply_test_controller").options.agentTools : options.agentTools;
+  if (resolveFixtureAgent) {
+    return runRoutedControllerSeeding(storyboard, calls, context, resolveFixtureAgent);
+  }
+  const controllerRouteTools = options.agentTools;
   if (controllerRouteTools && !controllerRouteTools.includes("comply_test_controller")) {
     return buildMissingControllerResult(storyboard, calls, context);
   }
@@ -304,6 +307,78 @@ async function runControllerSeeding(client, storyboard, options, context, discov
     failedCount
   };
 }
+async function runRoutedControllerSeeding(storyboard, calls, context, resolveFixtureAgent) {
+  const start = Date.now();
+  const authoringError = buildAuthoringErrorResult(storyboard, calls, context, start);
+  if (authoringError) return authoringError;
+  const seedContext = { correlation_id: `${storyboardCorrelationPrefix(storyboard)}--__seeding__` };
+  const selected = calls.map((call) => ({ call, route: resolveFixtureAgent("comply_test_controller", call) }));
+  const missing = selected.find(({ route }) => route.options.agentTools?.includes("comply_test_controller") === false);
+  if (missing) {
+    return buildMissingControllerResult(storyboard, calls, context);
+  }
+  const scenarios = /* @__PURE__ */ new Map();
+  for (const { call, route } of selected) {
+    if (!scenarios.has(route.client)) {
+      scenarios.set(
+        route.client,
+        controllerScenarioSetFromOptions(route.options) ?? await fetchControllerScenarioSet(route.client, route.options, seedContext)
+      );
+    }
+    if (scenarios.get(route.client)?.has(call.scenario) === false) {
+      return buildUnsupportedSeedResult(
+        storyboard,
+        calls,
+        context,
+        call.scenario,
+        `The selected route did not advertise ${call.scenario}.`
+      );
+    }
+  }
+  const steps = [];
+  let passedCount = 0;
+  let failedCount = 0;
+  for (const [index, { call, route }] of selected.entries()) {
+    const result = await executeLegacySeedCall(route.client, storyboard, call, route.options, context, seedContext);
+    if (result.step.skip_reason === "fixture_unsatisfied") {
+      const unsupported = buildUnsupportedSeedResult(
+        storyboard,
+        selected.slice(index).map((item) => item.call),
+        context,
+        call.scenario,
+        result.step.skip?.detail
+      );
+      return {
+        ...unsupported,
+        phase: {
+          ...unsupported.phase,
+          passed: failedCount === 0,
+          steps: [...steps, ...unsupported.phase.steps],
+          duration_ms: Date.now() - start
+        },
+        allPassed: failedCount === 0,
+        passedCount,
+        failedCount,
+        seedUnsupported: failedCount === 0
+      };
+    }
+    steps.push(result.step);
+    if (result.step.passed) passedCount++;
+    else failedCount++;
+  }
+  return {
+    phase: {
+      phase_id: CONTROLLER_SEEDING_PHASE_ID,
+      phase_title: "Controller seeding (pre-flight)",
+      passed: failedCount === 0,
+      steps,
+      duration_ms: Date.now() - start
+    },
+    allPassed: failedCount === 0,
+    passedCount,
+    failedCount
+  };
+}
 async function runDeclaredFixtureResolution(seedClient, discoveryClient, storyboard, options, context, calls, resolveFixtureAgent) {
   const start = Date.now();
   const authoringErrorResult = buildAuthoringErrorResult(storyboard, calls, context, start);
@@ -338,9 +413,9 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
   let seedPrepared = false;
   let discoveryPrepared = false;
   const controller = { missing: false, scenarios: null };
-  const prepareSeedAgent = async () => {
-    if (seedPrepared) return;
-    const selected = resolveFixtureAgent?.("comply_test_controller");
+  const prepareSeedAgent = async (call) => {
+    if (seedPrepared && !resolveFixtureAgent) return;
+    const selected = resolveFixtureAgent?.("comply_test_controller", call);
     if (selected) {
       seedClient = selected.client;
       seedOptions = selected.options;
@@ -352,9 +427,9 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
     }
     seedPrepared = true;
   };
-  const prepareDiscoveryAgent = () => {
-    if (discoveryPrepared) return;
-    const selected = resolveFixtureAgent?.("get_products");
+  const prepareDiscoveryAgent = (call) => {
+    if (discoveryPrepared && !resolveFixtureAgent) return;
+    const selected = resolveFixtureAgent?.("get_products", call);
     if (selected) {
       discoveryClient = selected.client;
       discoveryOptions = selected.options;
@@ -362,7 +437,7 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
     discoveryPrepared = true;
   };
   const legacyCalls = calls.filter((call) => resolutionSpecForCall(call, specByKey) === void 0);
-  if (legacyCalls.length > 0) {
+  if (legacyCalls.length > 0 && !resolveFixtureAgent) {
     await prepareSeedAgent();
     if (controller.missing) return buildMissingControllerResult(storyboard, legacyCalls, context);
     if (controller.scenarios) {
@@ -383,14 +458,34 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
     return !spec || spec.strategies.includes("seed");
   });
   if (!resolveFixtureAgent && needsSeedStrategy && !seedPrepared) await prepareSeedAgent();
-  let catalogPromise;
-  const catalog = () => catalogPromise ??= discoverProductCatalog(discoveryClient, discoveryOptions, context);
+  const catalogs = /* @__PURE__ */ new Map();
+  const catalog = () => {
+    let promise = catalogs.get(discoveryClient);
+    if (!promise) {
+      promise = discoverProductCatalog(discoveryClient, discoveryOptions, context);
+      catalogs.set(discoveryClient, promise);
+    }
+    return promise;
+  };
   let passedCount = 0;
   let failedCount = 0;
   let fixtureUnsatisfied = false;
   for (const call of orderedCalls) {
     const spec = resolutionSpecForCall(call, specByKey);
     if (!spec) {
+      if (resolveFixtureAgent) {
+        await prepareSeedAgent(call);
+        if (controller.missing) return buildMissingControllerResult(storyboard, legacyCalls, context);
+        if (controller.scenarios && !controller.scenarios.has(call.scenario)) {
+          return buildUnsupportedSeedResult(
+            storyboard,
+            legacyCalls,
+            context,
+            call.scenario,
+            `The selected route did not advertise ${call.scenario}.`
+          );
+        }
+      }
       const legacy = await executeLegacySeedCall(seedClient, storyboard, call, seedOptions, context, seedContext);
       if (legacy.step.skip_reason === "fixture_unsatisfied") {
         return buildUnsupportedSeedResult(storyboard, legacyCalls, context, call.scenario, legacy.step.skip?.detail);
@@ -415,7 +510,7 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
     }
     for (const strategy of parentUnavailable ? [] : spec.strategies) {
       if (strategy === "seed") {
-        await prepareSeedAgent();
+        await prepareSeedAgent(call);
         const advertised = controller.scenarios?.has(call.scenario);
         if (controller.missing || advertised === false) {
           attempts.push({
@@ -479,7 +574,7 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
         }
       }
       if (strategy === "discover") {
-        prepareDiscoveryAgent();
+        prepareDiscoveryAgent(call);
         if (discoveryOptions.agentTools && !discoveryOptions.agentTools.includes("get_products")) {
           attempts.push({
             strategy,