@adcp/sdk 14.0.0-rc.37 → 14.0.0-rc.39

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

@@ -20,7 +20,10 @@ var runner_exports = {};
 __export(runner_exports, {
   __defaultAuthHeadersForRawProbeForTest: () => __defaultAuthHeadersForRawProbeForTest,
   __filterResponseHeadersForTest: () => __filterResponseHeadersForTest,
+  __protectedToolCandidatesForTest: () => __protectedToolCandidatesForTest,
   __redactSecretsForTest: () => __redactSecretsForTest,
+  __selectProtectedToolTargetForTest: () => __selectProtectedToolTargetForTest,
+  __sessionControlCredentialsForTest: () => __sessionControlCredentialsForTest,
   applyAdcpVersionRunOptions: () => applyAdcpVersionRunOptions,
   applyBrandInvariant: () => applyBrandInvariant,
   applyDisableSandboxHint: () => applyDisableSandboxHint,
@@ -34,6 +37,9 @@ __export(runner_exports, {
   resolveCapabilityPath: () => resolveCapabilityPath,
   runStoryboard: () => runStoryboard,
   runStoryboardStep: () => runStoryboardStep,
+  signingCoverage: () => signingCoverage,
+  signingCoverageUnverified: () => signingCoverageUnverified,
+  storyboardCapabilityPredicates: () => storyboardCapabilityPredicates,
   summarizeStrictValidation: () => summarizeStrictValidation
 });
 module.exports = __toCommonJS(runner_exports);
@@ -68,13 +74,18 @@ var import_probes = require('./probes.js');
 var import_capabilities_types = require('../../signing/agent-resolver/capabilities-types.js');
 var import_select_agent = require('../../signing/agent-resolver/select-agent.js');
 var import_test_kit = require('./test-kit.js');
+var import_idempotency2 = require('../../utils/idempotency.js');
+var import_tool_request_schemas = require('../../utils/tool-request-schemas.js');
+var import_capabilities = require('../../utils/capabilities.js');
 var import_loader = require('./loader.js');
 var import_phase_condition = require('./phase-condition.js');
 var import_provenance = require('./provenance.js');
 var import_probe_dispatch = require('./request-signing/probe-dispatch.js');
+var import_synthesize = require('./request-signing/synthesize.js');
 var import_webhook_receiver = require('./webhook-receiver.js');
 var import_webhook_assertions = require('./webhook-assertions.js');
 var import_seeding = require('./seeding.js');
+var import_test_controller2 = require('../test-controller.js');
 var import_fixture_resolution = require('./fixture-resolution.js');
 var import_compliance = require('./compliance.js');
 var import_client3 = require('../../signing/client.js');
@@ -115,7 +126,7 @@ function applyStoryboardVersionOptions(storyboard, options) {
 function applyReusableProfileOptions(options) {
   const profile = options.profile ?? options._profile;
   if (!profile) return options;
-  const profileTools = options.agents === void 0 ? normalizeAgentToolNames(profile.tools) ?? [] : void 0;
+  const profileTools = options.agents === void 0 ? (0, import_agent_routing.normalizeAgentToolNames)(profile.tools) ?? [] : void 0;
   return {
     ...options,
     _profile: profile,
@@ -157,11 +168,26 @@ const DETAILED_SKIP_DETAILS = {
   rate_abuse_opt_out: "Rate-abuse vector was excluded by request_signing.skipRateAbuse.",
   capability_profile_mismatch: "Vector is outside the agent capability profile selected for this run.",
   transport_ungradable: "Vector cannot be graded faithfully by the selected transport.",
+  signing_transport_unavailable: "Request-signing vectors have no shape this run's protocol can carry, so no verifier behavior was graded.",
   rate_limit_not_triggered: "No RATE_LIMITED response was observed within the configured max_attempts."
 };
 const CANONICAL_SKIP_DETAILS = {
-  rate_limit_not_triggered: "rate_limit_not_triggered"
+  rate_limit_not_triggered: "rate_limit_not_triggered",
+  // Same shape as `rate_limit_not_triggered` above, which
+  // runner-output-contract.yaml registers under
+  // `canonical_detail_sub_reasons.not_applicable` with a test-kit
+  // `spec_source`: emit the sub-reason token *exactly* as `skip.detail`,
+  // with empty validations and no pass/fail counter movement. The
+  // operator-facing remedy travels on the probe result (`response.error`),
+  // which is where the renderers read it.
+  //
+  // Upstream ask, tracked as the remaining external blocker: register
+  // `not_applicable.signing_transport_unavailable` with
+  // `spec_source: test-kits/signed-requests-runner.yaml`. Emitting the
+  // registered *shape* now means that registration changes nothing here.
+  signing_transport_unavailable: "signing_transport_unavailable"
 };
+const MCP_SESSION_PROBE_REQUEST_TIMEOUT_MS = 5e3;
 const REPLAY_WEBHOOK_VECTOR_TASK = "replay_webhook_vector";
 const REPLAY_TRUSTED_MATCH_CONTEXT_VECTOR_TASK = "replay_trusted_match_context_vector";
 const WEBHOOK_REPLAY_DEFAULT_TIMEOUT_MS = 1e4;
@@ -504,6 +530,42 @@ function resetClientSessions(clients) {
     if (typeof reset === "function") reset.call(client);
   }
 }
+async function resetControllerState(client, storyboard, options) {
+  const controller = options._controllerCapabilities;
+  if (controller?.detected !== true || !controller.scenarios.includes("reset_state")) return void 0;
+  const outcome = await (0, import_client.runStep)(
+    "Reset test-controller state",
+    "comply_test_controller",
+    () => (0, import_test_controller2.callControllerRaw)(
+      client,
+      {
+        scenario: "reset_state",
+        context: { correlation_id: `${storyboard.id}--__reset_state__` }
+      },
+      options
+    )
+  );
+  if (!outcome.step.passed) return outcome.step;
+  const raw = outcome.result;
+  const data = raw?.data;
+  if (raw?.success && data?.success === true) return void 0;
+  if (raw?.success && data?.success === false && data.error === "UNKNOWN_SCENARIO") return void 0;
+  return {
+    ...outcome.step,
+    passed: false,
+    error: data?.error_detail ?? data?.error ?? raw?.error ?? "comply_test_controller reset_state failed"
+  };
+}
+async function resetControllerStates(targets, storyboard) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    if (seen.has(target.client)) continue;
+    seen.add(target.client);
+    const failure = await resetControllerState(target.client, storyboard, target.options);
+    if (failure) return failure;
+  }
+  return void 0;
+}
 function isPollEligibleEnvelope(data) {
   if (data == null || typeof data !== "object") return false;
   const obj = data;
@@ -623,6 +685,15 @@ function __redactSecretsForTest(value) {
 function __filterResponseHeadersForTest(headers) {
   return filterResponseHeaders(headers);
 }
+function __selectProtectedToolTargetForTest(tools) {
+  return selectProtectedToolTarget(tools);
+}
+function __protectedToolCandidatesForTest(tools) {
+  return protectedToolCandidates(tools);
+}
+function __sessionControlCredentialsForTest(mechanism, options, client, agentUrl) {
+  return sessionControlCredentials(mechanism, options, client, agentUrl);
+}
 function __defaultAuthHeadersForRawProbeForTest(options) {
   return defaultAuthHeadersForRawProbe(options);
 }
@@ -689,7 +760,7 @@ async function runStoryboardBody(agentUrlOrUrls, storyboard, options) {
     );
   }
   const hasCapabilityGate = storyboardCapabilityPredicates(storyboard).length > 0;
-  const deferCapabilityAndRequires = hasCapabilityGate && options._profile === void 0;
+  const deferCapabilityAndRequires = options.agents !== void 0 || hasCapabilityGate && options._profile === void 0;
   if (hasCapabilityGate && !deferCapabilityAndRequires) {
     const unmetDetail = evaluateStoryboardCapabilityGates(
       storyboard,
@@ -706,8 +777,25 @@ async function runStoryboardBody(agentUrlOrUrls, storyboard, options) {
     }
   }
   const allRequires = resolveStoryboardRequires(storyboard, options);
-  if (allRequires.length && !deferCapabilityAndRequires) {
-    const requirementCheck = await checkRequires(allRequires, storyboard, options, options._profile);
+  const preflightDefersRequirement = (requirement) => {
+    switch (requirement) {
+      case "controller":
+        return options.agents !== void 0 || !options.agentTools;
+      case "request_signer":
+        return options.agents !== void 0 || !options._profile?.raw_capabilities;
+      default:
+        return false;
+    }
+  };
+  const firstDeferred = allRequires.findIndex(preflightDefersRequirement);
+  const earlyRequires = hasCapabilityGate ? [] : allRequires.slice(0, firstDeferred < 0 ? void 0 : firstDeferred);
+  if (earlyRequires.length && (!deferCapabilityAndRequires || options.agents && !hasCapabilityGate)) {
+    const requirementCheck = await checkRequires(
+      earlyRequires,
+      storyboard,
+      options,
+      options.agents ? void 0 : options._profile
+    );
     if ("requirement" in requirementCheck) {
       const resultAgentUrls = options.agents ? Object.values(options.agents).map((e) => e.url) : agentUrls;
       return {
@@ -976,20 +1064,7 @@ function buildRequiredAnyOfToolsMissingResult(agentUrls, storyboard, detail) {
     notices: []
   };
 }
-function normalizeAgentToolNames(tools) {
-  if (!Array.isArray(tools)) return void 0;
-  const names = [];
-  for (const tool of tools) {
-    if (typeof tool === "string") {
-      names.push(tool);
-    } else if (tool && typeof tool === "object") {
-      const name = tool.name;
-      if (typeof name === "string") names.push(name);
-    }
-  }
-  return names.length > 0 ? names : void 0;
-}
-async function checkRequires(requires, storyboard, options, profile) {
+async function checkRequires(requires, storyboard, options, profile, precomputed) {
   let preparedPublisherAuthProbes = getPreparedTrustedMatchPublisherAuth(options);
   for (const requirement of requires) {
     if (!isKnownRequirement(requirement)) {
@@ -998,6 +1073,13 @@ async function checkRequires(requires, storyboard, options, profile) {
         detail: `Storyboard requires unknown runtime requirement '${requirement}'. This SDK does not know how to satisfy it, so the requirement is treated as unmet for forward compatibility.`
       };
     }
+    const established = precomputed?.get(requirement);
+    if (established) {
+      if (established.status === "unmet") {
+        return { requirement: established.requirement, detail: established.detail };
+      }
+      continue;
+    }
     switch (requirement) {
       case "controller": {
         if (!options.agentTools) continue;
@@ -1159,6 +1241,28 @@ function detectImplicitRequires(storyboard, options = {}) {
   if (needsSigner) requires.push("request_signer");
   return requires;
 }
+function probeResponseStatus(response) {
+  if (response === null || typeof response !== "object") return 0;
+  const status = response.status;
+  return typeof status === "number" ? status : 0;
+}
+function signingCoverage(steps) {
+  const probes = steps.filter((step) => step.task === import_synthesize.REQUEST_SIGNING_PROBE_TASK);
+  if (probes.length === 0) return "not_probed";
+  if (probes.some((step) => step.skipped !== true && probeResponseStatus(step.response) > 0 && !isProbeFault(step.response)))
+    return "graded";
+  if (probes.some((step) => isProbeFault(step.response))) return "probe_errored";
+  if (probes.some((step) => step.skip_reason === "signing_transport_unavailable")) return "transport_unverified";
+  if (probes.every((step) => step.skipped === true)) return "scope_excluded";
+  return "self_check_only";
+}
+function isProbeFault(response) {
+  return response !== null && typeof response === "object" && response.probe_error === true;
+}
+function signingCoverageUnverified(steps) {
+  const coverage = signingCoverage(steps);
+  return coverage !== "not_probed" && coverage !== "graded";
+}
 function buildDiscoveryFailedResult(agentUrls, storyboard, discoveryStep) {
   const detail = discoveryStep.error ?? "Discovery failed (no agent tools advertised).";
   const syntheticStep = {
@@ -1378,7 +1482,7 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
     try {
       routingContext = await (0, import_agent_routing.buildRoutingContext)(storyboard, options);
     } catch (err) {
-      const detail = err?.message ?? String(err);
+      const detail = (0, import_oauth_metadata_graph.redactOAuthUrlsInText)(err?.message ?? String(err));
       const failedStep = {
         step: err instanceof import_agent_routing.DiscoveryFailure ? `Discover agent capabilities (${err.agentKey})` : "Build agent routing index",
         passed: false,
@@ -1393,13 +1497,9 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
     profile = [...routingContext.profiles.values()][0];
     const unionedTools = /* @__PURE__ */ new Set();
     for (const p of routingContext.profiles.values()) {
-      for (const t of normalizeAgentToolNames(p.tools) ?? []) unionedTools.add(t);
-    }
-    if (!options.agentTools) {
-      options = { ...options, agentTools: [...unionedTools], _profile: profile };
-    } else if (profile && !options._profile) {
-      options = { ...options, _profile: profile };
+      for (const t of (0, import_agent_routing.normalizeAgentToolNames)(p.tools) ?? []) unionedTools.add(t);
     }
+    options = { ...options, agentTools: [...unionedTools], _profile: profile };
   } else {
     const clientResolutions = agentUrls.map((url) => (0, import_client.getOrCreateClientResolution)(url, options));
     clients = clientResolutions.map((r) => r.client);
@@ -1412,7 +1512,7 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         return buildDiscoveryFailedResult(agentUrls, storyboard, discovered.step);
       }
       profile = discovered.profile;
-      const profileTools = normalizeAgentToolNames(profile?.tools);
+      const profileTools = (0, import_agent_routing.normalizeAgentToolNames)(profile?.tools);
       if (!options.agentTools && profileTools) {
         options = { ...options, agentTools: profileTools, _profile: profile };
       } else if (profile && !options._profile) {
@@ -1420,7 +1520,7 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       }
     } else {
       profile = options._profile;
-      const profileTools = normalizeAgentToolNames(profile?.tools);
+      const profileTools = (0, import_agent_routing.normalizeAgentToolNames)(profile?.tools);
       if (!options.agentTools && profileTools) {
         options = { ...options, agentTools: profileTools, _profile: profile };
       } else if (!options.agentTools && typeof clients[0]?.getAgentInfo === "function") {
@@ -1429,7 +1529,7 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
           return buildDiscoveryFailedResult(agentUrls, storyboard, discovered.step);
         }
         profile = discovered.profile;
-        const discoveredTools = normalizeAgentToolNames(profile?.tools);
+        const discoveredTools = (0, import_agent_routing.normalizeAgentToolNames)(profile?.tools);
         if (discoveredTools) {
           options = { ...options, agentTools: discoveredTools, _profile: profile };
         } else if (profile && !options._profile) {
@@ -1438,9 +1538,126 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       }
     }
   }
+  if (preSeeded === void 0) {
+    const resetTargets = routingContext && options.agents ? [...routingContext.profiles.entries()].map(([key, profile2]) => ({
+      client: routingContext.clients.get(key),
+      options: (0, import_agent_routing.routedAgentOptions)(options.agents[key], options, profile2)
+    })) : clients.map((client) => ({ client, options }));
+    const resetFailure = await resetControllerStates(resetTargets, storyboard);
+    if (resetFailure) {
+      if (!callerOwnsClients) await (0, import_protocols.closeScopedConnections)(options.protocol);
+      return buildDiscoveryFailedResult(agentUrls, storyboard, resetFailure);
+    }
+  }
+  const allRequires = resolveStoryboardRequires(storyboard, options);
+  let dispatch = routingContext && options.agents ? createRoutingDispatcher(routingContext, options, options.agents) : createDispatcher(agentUrls, clients, "round-robin", dispatchOffset, profile);
+  const routedStepCapabilitySkips = /* @__PURE__ */ new Map();
+  const routedPhaseCapabilitySkips = /* @__PURE__ */ new Map();
+  const routedStepRequirements = /* @__PURE__ */ new Map();
+  const routedRootCapabilitySkips = [];
+  const routedRootRequirementSkips = [];
+  const routedControllerRoutes = /* @__PURE__ */ new Map();
+  const routedErrors = /* @__PURE__ */ new Map();
+  const reportedRoutingErrors = /* @__PURE__ */ new Set();
+  let context = { ...storyboard.context, ...options.context };
+  const routingFailedStep = (step, phaseId, err) => {
+    const detail = (0, import_oauth_metadata_graph.redactOAuthUrlsInText)(
+      err instanceof import_agent_routing.RoutingError ? err.message : err?.message ?? String(err)
+    );
+    const failedAgentKey = step.agent ?? options.default_agent;
+    const failedAgentUrl = failedAgentKey ? options.agents?.[failedAgentKey]?.url : void 0;
+    const failedAgentIndex = failedAgentKey ? Object.keys(options.agents ?? {}).indexOf(failedAgentKey) : -1;
+    return {
+      storyboard_id: storyboard.id,
+      step_id: step.id,
+      phase_id: phaseId,
+      title: step.title,
+      task: step.task,
+      passed: false,
+      duration_ms: 0,
+      validations: [],
+      context,
+      error: detail,
+      ...failedAgentUrl && { agent_url: (0, import_oauth_metadata_graph.redactOAuthUrlForOutput)(failedAgentUrl) },
+      ...failedAgentIndex >= 0 && { agent_index: failedAgentIndex + 1 },
+      extraction: { path: "none" }
+    };
+  };
+  if (routingContext) {
+    for (const phase of storyboard.phases) {
+      for (const step of phase.steps) {
+        if (step.task === import_loader.VALIDATION_ONLY_TASK) continue;
+        try {
+          const selected = dispatch.nextFor(step);
+          const selectedOptions = selected.options;
+          const rootDetail = evaluateStoryboardCapabilityGates(
+            storyboard,
+            selected.profile,
+            selectedOptions.agentTools,
+            options.adcpVersion
+          );
+          let requirementSkip;
+          if (rootDetail === null && allRequires.includes("request_signer")) {
+            const requirement = await checkRequires(["request_signer"], storyboard, selectedOptions, {
+              ...selected.profile,
+              // Routed discovery is authoritative. A legacy agent without a
+              // capabilities response did not opt into request signing.
+              raw_capabilities: selected.profile.raw_capabilities ?? {}
+            });
+            if ("requirement" in requirement) {
+              requirementSkip = requirement;
+              routedStepRequirements.set(step, requirement.requirement);
+            }
+          }
+          const phaseDetail = phase.requires_capability ? evaluateRequiresCapabilityGate(
+            phase.requires_capability,
+            selected.profile,
+            selectedOptions.agentTools,
+            options.adcpVersion
+          ) : null;
+          if (allRequires.includes("controller") && rootDetail === null && phaseDetail === null) {
+            const routeKey = selected.agentKey ?? selected.agentUrl;
+            const routeTools = selectedOptions.agentTools ?? [];
+            const resolvedTask = (0, import_agent_routing.resolveTaskName)(step, selectedOptions) ?? step.task;
+            const previous = routedControllerRoutes.get(routeKey);
+            routedControllerRoutes.set(routeKey, {
+              tools: routeTools,
+              // A `comply_test_controller` step is the back-channel itself,
+              // not the state under test, so it cannot vouch for the route it
+              // is dispatched to. One state-exercising step is enough to mark
+              // the route, whatever order the steps arrive in.
+              stateExercising: (previous?.stateExercising ?? false) || resolvedTask !== "comply_test_controller"
+            });
+          }
+          if (rootDetail !== null) routedRootCapabilitySkips.push(rootDetail);
+          else if (requirementSkip) routedRootRequirementSkips.push(requirementSkip);
+          const detail = rootDetail ?? requirementSkip?.detail ?? phaseDetail;
+          if (detail !== null) routedStepCapabilitySkips.set(step, detail);
+        } catch (error) {
+          routedErrors.set(step, error);
+        }
+      }
+      const callableSteps = phase.steps.filter((step) => step.task !== import_loader.VALIDATION_ONLY_TASK);
+      if (callableSteps.length && callableSteps.every((step) => routedStepCapabilitySkips.has(step))) {
+        routedPhaseCapabilitySkips.set(phase.id, routedStepCapabilitySkips.get(callableSteps[0]));
+      }
+    }
+  }
+  const routedPreflightAssignment = routingContext ? (step) => {
+    if (routedStepCapabilitySkips.has(step)) return void 0;
+    try {
+      return dispatch.nextFor(step);
+    } catch {
+      return void 0;
+    }
+  } : void 0;
   const preflightNotices = collectCapabilityNotices(storyboard, options._profile);
+  const callableStepCount = storyboard.phases.reduce(
+    (n, phase) => n + phase.steps.filter((step) => step.task !== import_loader.VALIDATION_ONLY_TASK).length,
+    0
+  );
   if (storyboardCapabilityPredicates(storyboard).length > 0) {
-    const unmetDetail = evaluateStoryboardCapabilityGates(storyboard, profile, options.agentTools, options.adcpVersion);
+    const unmetDetail = routingContext ? routedRootCapabilitySkips.length > 0 && routedRootCapabilitySkips.length === callableStepCount ? routedRootCapabilitySkips[0] : null : evaluateStoryboardCapabilityGates(storyboard, profile, options.agentTools, options.adcpVersion);
     if (unmetDetail !== null) {
       if (!callerOwnsClients) await (0, import_protocols.closeScopedConnections)(options.protocol);
       return {
@@ -1449,21 +1666,71 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       };
     }
   }
-  const allRequires = resolveStoryboardRequires(storyboard, options);
+  const establishedRequirements = /* @__PURE__ */ new Map();
+  if (routingContext && allRequires.includes("controller")) {
+    const decided = [...routedControllerRoutes].filter(([, route]) => route.stateExercising);
+    const routes = decided.length > 0 ? decided : [...routedControllerRoutes];
+    if (routedErrors.size > 0 || routes.length === 0) {
+      establishedRequirements.set("controller", { status: "unknown" });
+    } else if (routes.some(([, route]) => route.tools.includes("comply_test_controller"))) {
+      establishedRequirements.set("controller", { status: "met" });
+    } else {
+      const exercised = routes.map(([key]) => key);
+      const exercisedKeys = new Set(exercised);
+      const peersWithController = [...routingContext.profiles.entries()].filter(
+        ([key, peer]) => !exercisedKeys.has(key) && (0, import_agent_routing.normalizeAgentToolNames)(peer.tools)?.includes("comply_test_controller")
+      ).map(([key]) => key);
+      establishedRequirements.set("controller", {
+        status: "unmet",
+        requirement: "controller",
+        detail: `Storyboard requires 'controller'; no route serving this storyboard's steps advertises comply_test_controller. Route(s) exercised: [${exercised.join(", ")}]. ` + (peersWithController.length ? `Agent(s) [${peersWithController.join(", ")}] in this map do advertise it, but a peer route's controller cannot seed another route's state \u2014 a run-level tool union does not grant it. ` : "") + `Add comply_test_controller to the route that owns the state, or pin the seeding step to that route with 'agent:'.`
+      });
+    }
+  }
+  if (routingContext && allRequires.includes("request_signer")) {
+    establishedRequirements.set(
+      "request_signer",
+      routedErrors.size === 0 && routedRootRequirementSkips.length > 0 && routedRootRequirementSkips.length === callableStepCount ? { status: "unmet", ...routedRootRequirementSkips[0] } : { status: "unknown" }
+    );
+  }
   if (allRequires.length) {
-    const requirementCheck = await checkRequires(allRequires, storyboard, options, profile);
+    const requirementCheck = await checkRequires(
+      allRequires,
+      storyboard,
+      options,
+      routingContext ? void 0 : profile,
+      establishedRequirements
+    );
     if ("requirement" in requirementCheck) {
       if (!callerOwnsClients) await (0, import_protocols.closeScopedConnections)(options.protocol);
-      return {
-        ...buildRequirementUnmetResult(agentUrls, storyboard, requirementCheck.requirement, requirementCheck.detail),
-        notices: preflightNotices
-      };
+      const result2 = buildRequirementUnmetResult(
+        agentUrls,
+        storyboard,
+        requirementCheck.requirement,
+        requirementCheck.detail
+      );
+      for (const phase of storyboard.phases) {
+        const failures = phase.steps.filter((step) => routedErrors.has(step)).map((step) => routingFailedStep(step, phase.id, routedErrors.get(step)));
+        if (failures.length) {
+          result2.phases.push({
+            phase_id: phase.id,
+            phase_title: phase.title,
+            passed: false,
+            steps: failures,
+            duration_ms: 0
+          });
+          result2.failed_count += failures.length;
+          result2.overall_passed = false;
+        }
+      }
+      return { ...result2, notices: preflightNotices };
     }
     if (requirementCheck.preparedPublisherAuthProbes) {
       options = withPreparedTrustedMatchPublisherAuth(options, requirementCheck.preparedPublisherAuthProbes);
+      if (routingContext && options.agents) dispatch = createRoutingDispatcher(routingContext, options, options.agents);
     }
   }
-  if (storyboard.required_any_of_tools?.length && options.agentTools) {
+  if (storyboard.required_any_of_tools?.length && options.agentTools && !routingContext?.discoveryFailures.length && routedErrors.size === 0) {
     const agentTools = new Set(options.agentTools);
     const missing = storyboard.required_any_of_tools.find((family) => !family.tools.some((tool) => agentTools.has(tool)));
     if (missing) {
@@ -1475,8 +1742,8 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       };
     }
   }
-  if (storyboard.required_tools?.length && options.agentTools) {
-    const hasAnyRequired = storyboard.required_tools.some((t) => options.agentTools.includes(t));
+  if (storyboard.required_tools?.length && options.agentTools && !routingContext?.discoveryFailures.length && routedErrors.size === 0) {
+    const hasAnyRequired = (0, import_agent_routing.hasAnyRequiredTool)(storyboard.required_tools, options.agentTools);
     if (!hasAnyRequired) {
       if (!callerOwnsClients) await (0, import_protocols.closeScopedConnections)(options.protocol);
       return {
@@ -1489,18 +1756,26 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       };
     }
   }
-  let context = { ...storyboard.context, ...options.context };
   if (storyboard.context) (0, import_context.forwardAliasCache)(storyboard.context, context);
   if (options.context) (0, import_context.forwardAliasCache)(options.context, context);
   const contributions = /* @__PURE__ */ new Set();
   const contributionSources = /* @__PURE__ */ new Map();
   const priorStepResults = /* @__PURE__ */ new Map();
   const priorProbes = /* @__PURE__ */ new Map();
+  const routedPriorProbes = /* @__PURE__ */ new Map();
   const contextProvenance = /* @__PURE__ */ new Map();
   const priorA2aEnvelopes = /* @__PURE__ */ new Map();
   const stepRequestStarts = /* @__PURE__ */ new Map();
   const responseDerivedNotApplicableContextKeys = /* @__PURE__ */ new Map();
   const capabilityUnavailableContextKeysByPhase = /* @__PURE__ */ new Map();
+  const missingPrerequisiteContextKeysByPhase = /* @__PURE__ */ new Map();
+  const recordUnavailableOutputs = (phaseId, step, keysByPhase = capabilityUnavailableContextKeysByPhase) => {
+    const keys = keysByPhase.get(phaseId) ?? /* @__PURE__ */ new Set();
+    for (const output of step.context_outputs ?? []) {
+      if (output.key) keys.add(output.key);
+    }
+    keysByPhase.set(phaseId, keys);
+  };
   const phaseResults = [];
   let passedCount = 0;
   let failedCount = 0;
@@ -1511,28 +1786,31 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
   const branchSetsByPhaseId = resolveBranchSets(storyboard);
   const effectiveDependsOn = (phase, prior) => phase.depends_on ?? prior;
   const cascadeForPhase = (phase, prior) => {
-    if (phaseStatefulCascades.has(phase.id)) {
-      return { tripped: true, trigger: phaseStatefulCascades.get(phase.id) ?? null };
-    }
     const ownSpec = branchSetsByPhaseId.get(phase.id);
     const ownAnyOfBranchSet = ownSpec?.semantics === "any_of" ? ownSpec.id : void 0;
-    for (const depId of effectiveDependsOn(phase, prior)) {
-      if (ownAnyOfBranchSet !== void 0 && branchSetsByPhaseId.get(depId)?.id === ownAnyOfBranchSet) {
+    let capabilityTrigger;
+    let missingStateTrigger;
+    for (const depId of [phase.id, ...effectiveDependsOn(phase, prior)]) {
+      if (depId !== phase.id && ownAnyOfBranchSet !== void 0 && branchSetsByPhaseId.get(depId)?.id === ownAnyOfBranchSet) {
         continue;
       }
       if (phaseStatefulCascades.has(depId)) {
-        return { tripped: true, trigger: phaseStatefulCascades.get(depId) ?? null };
+        const trigger2 = phaseStatefulCascades.get(depId) ?? null;
+        if (trigger2 === null) return { tripped: true, trigger: null };
+        if (trigger2.capabilityUnavailable) capabilityTrigger ??= trigger2;
+        else missingStateTrigger ??= trigger2;
       }
     }
-    return { tripped: false };
+    const trigger = missingStateTrigger ?? capabilityTrigger;
+    return trigger ? { tripped: true, trigger } : { tripped: false };
   };
-  const capabilityUnavailableContextKeysForPhase = (phase, prior) => {
-    const keys = /* @__PURE__ */ new Set();
+  const unavailableContextKeysForPhase = (phase, prior, keysByPhase = capabilityUnavailableContextKeysByPhase) => {
+    const keys = new Set(keysByPhase.get(phase.id));
     const ownSpec = branchSetsByPhaseId.get(phase.id);
     const ownAnyOfBranchSet = ownSpec?.semantics === "any_of" ? ownSpec.id : void 0;
     for (const depId of effectiveDependsOn(phase, prior)) {
       if (ownAnyOfBranchSet !== void 0 && branchSetsByPhaseId.get(depId)?.id === ownAnyOfBranchSet) continue;
-      for (const key of capabilityUnavailableContextKeysByPhase.get(depId) ?? []) keys.add(key);
+      for (const key of keysByPhase.get(depId) ?? []) keys.add(key);
     }
     return keys;
   };
@@ -1550,7 +1828,6 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
   });
   if (webhookReceiver) (0, import_webhook_assertions.armWebhookAssertions)(storyboard, runnerVars, webhookReceiver);
   const allSteps = flattenSteps(storyboard);
-  const dispatch = routingContext && options.agents ? createRoutingDispatcher(routingContext, options, options.agents) : createDispatcher(agentUrls, clients, "round-robin", dispatchOffset, profile);
   const assertions = (0, import_assertions.resolveAssertions)(storyboard.invariants);
   (0, import_assertions.validateStepInvariants)(storyboard, assertions);
   const assertionContexts = /* @__PURE__ */ new Map();
@@ -1568,12 +1845,7 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
     if (spec.onStart) await spec.onStart(assertionContexts.get(spec.id));
   }
   const hasExecutableSteps = storyboard.phases.some((p) => p.steps.length > 0);
-  const phaseCapabilitySkipDetails = collectPhaseCapabilitySkipDetails(
-    storyboard,
-    profile,
-    options.agentTools,
-    options.adcpVersion
-  );
+  const phaseCapabilitySkipDetails = routingContext ? routedPhaseCapabilitySkips : collectPhaseCapabilitySkipDetails(storyboard, profile, options.agentTools, options.adcpVersion);
   const skipControllerSeedingForPhaseGates = allExecutablePhasesCapabilitySkipped(
     storyboard,
     phaseCapabilitySkipDetails
@@ -1604,7 +1876,8 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       storyboardRequiresRequestSigner: allRequires.includes("request_signer"),
       storyboardRequiresPublisherAuthRunner: storyboard.requires?.includes("trusted_match_publisher_auth_runner") === true
     },
-    preflightExcludedPhaseIds
+    preflightExcludedPhaseIds,
+    routedPreflightAssignment
   );
   let creativeAssetFixtureGapRecorded = false;
   if (!hasExecutableSteps) {
@@ -1649,22 +1922,36 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
   let fixtureResolutionRecords;
   let fixtureCoverageGap;
   {
-    let fixtureSeedClient = clients[0];
-    let fixtureDiscoveryClient = clients[0];
-    if (routingContext && options.agents) {
-      const fixtureStep = (task) => ({
-        id: `__fixture_resolution_${task}__`,
-        title: `Fixture resolution via ${task}`,
-        task
+    let seeding;
+    try {
+      seeding = creativeAssetFixtureGap || skipControllerSeedingForPhaseGates ? null : preSeeded !== void 0 ? preSeeded.result : await (0, import_seeding.runControllerSeeding)(
+        clients[0],
+        storyboard,
+        options,
+        context,
+        clients[0],
+        routingContext ? (task) => {
+          if (!options.agentTools?.includes(task))
+            return { client: clients[0], options: { ...options, agentTools: [] } };
+          const selected = dispatch.nextFor({
+            id: `__fixture_resolution_${task}__`,
+            title: `Fixture resolution via ${task}`,
+            task
+          });
+          return { client: selected.client, options: selected.options };
+        } : void 0
+      );
+    } catch (error) {
+      if (webhookReceiver) await webhookReceiver.close();
+      if (!(error instanceof import_agent_routing.RoutingError)) throw error;
+      if (!callerOwnsClients) await (0, import_protocols.closeScopedConnections)(options.protocol);
+      return buildDiscoveryFailedResult(agentUrls, storyboard, {
+        step: "Resolve fixture agent routes",
+        passed: false,
+        duration_ms: 0,
+        error: (0, import_oauth_metadata_graph.redactOAuthUrlsInText)(error.message)
       });
-      if (options.agentTools?.includes("comply_test_controller")) {
-        fixtureSeedClient = dispatch.nextFor(fixtureStep("comply_test_controller")).client;
-      }
-      if (options.agentTools?.includes("get_products")) {
-        fixtureDiscoveryClient = dispatch.nextFor(fixtureStep("get_products")).client;
-      }
     }
-    const seeding = creativeAssetFixtureGap ? null : skipControllerSeedingForPhaseGates ? null : preSeeded !== void 0 ? preSeeded.result : await (0, import_seeding.runControllerSeeding)(fixtureSeedClient, storyboard, options, context, fixtureDiscoveryClient);
     if (seeding) {
       const attach = preSeeded === void 0 || preSeeded.attach;
       if (attach) {
@@ -1736,7 +2023,8 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       context,
       options,
       buildExecutionState(),
-      preflightExcludedPhaseIds
+      preflightExcludedPhaseIds,
+      routedPreflightAssignment
     );
   }
   for (const phase of storyboard.phases) {
@@ -1781,7 +2069,25 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
     }
     const phaseCapabilitySkipDetail = phaseCapabilitySkipDetails.get(phase.id);
     if (phaseCapabilitySkipDetail !== void 0) {
-      const skippedSteps = buildPhaseCapabilitySkippedSteps(storyboard, phase, phaseCapabilitySkipDetail, context);
+      const skippedSteps = routingContext ? phase.steps.map((step) => {
+        const selected = step.task === import_loader.VALIDATION_ONLY_TASK ? void 0 : dispatch.nextFor(step);
+        const skipped = buildPhaseCapabilitySkippedSteps(
+          storyboard,
+          { ...phase, steps: [step] },
+          routedStepCapabilitySkips.get(step) ?? phaseCapabilitySkipDetail,
+          context
+        )[0];
+        return {
+          ...skipped,
+          ...routedStepRequirements.has(step) && {
+            skip: { ...skipped.skip, requirement: routedStepRequirements.get(step) }
+          },
+          ...selected && {
+            agent_url: (0, import_oauth_metadata_graph.redactOAuthUrlForOutput)(selected.agentUrl),
+            agent_index: selected.instanceIndex + 1
+          }
+        };
+      }) : buildPhaseCapabilitySkippedSteps(storyboard, phase, phaseCapabilitySkipDetail, context);
       phaseResults.push({
         phase_id: phase.id,
         phase_title: phase.title,
@@ -1791,13 +2097,9 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       });
       skippedCount += skippedSteps.length;
       phaseCapabilitySkippedIds.add(phase.id);
-      const unavailableKeys = /* @__PURE__ */ new Set();
       for (const step of phase.steps) {
-        for (const output of step.context_outputs ?? []) {
-          if (output.key) unavailableKeys.add(output.key);
-        }
+        recordUnavailableOutputs(phase.id, step);
       }
-      capabilityUnavailableContextKeysByPhase.set(phase.id, unavailableKeys);
       if (phase.steps.some((s) => s.stateful)) {
         phaseStatefulCascades.set(phase.id, {
           stepId: phase.steps.find((s) => s.stateful).id,
@@ -1811,6 +2113,7 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
     const stepResults = [];
     let phasePassed = true;
     let phasePendingNotApplicable = null;
+    let phaseInheritedCapabilityTrigger;
     let phaseEstablishedStatefulState = false;
     const phaseSubstitutes = /* @__PURE__ */ new Map();
     for (const declaringStep of phase.steps) {
@@ -1823,13 +2126,27 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         phaseSubstitutes.set(target, arr);
       }
     }
-    let phasePendingMissingTool = null;
+    const phasePendingMissingTool = { trigger: null };
     const phaseRescuedTargets = /* @__PURE__ */ new Set();
     const phaseRescueSource = /* @__PURE__ */ new Map();
     const phaseStatefulStepIds = phase.steps.filter((s) => s.stateful).map((s) => s.id);
     let phaseAbsent = false;
+    const routedOauthAbsent = /* @__PURE__ */ new Set();
     let presenceDetected = false;
+    const routedOauthPresent = /* @__PURE__ */ new Set();
     if (shouldSkipPhase(phase, options, context)) {
+      const skippedRoutingFailures = routingContext ? phase.steps.filter((step) => routedErrors.has(step)) : [];
+      const skippedCapabilitySteps = routingContext ? phase.steps.filter((step) => routedStepCapabilitySkips.has(step)) : [];
+      for (const step of skippedCapabilitySteps) recordUnavailableOutputs(phase.id, step);
+      if (skippedRoutingFailures.length > 0) {
+        for (const step of skippedRoutingFailures) {
+          recordUnavailableOutputs(phase.id, step, missingPrerequisiteContextKeysByPhase);
+        }
+        if (skippedRoutingFailures.some((step) => step.stateful)) phaseStatefulCascades.set(phase.id, null);
+      }
+      if (skippedRoutingFailures.length > 0 || skippedCapabilitySteps.length > 0) {
+        priorPhaseIds.push(phase.id);
+      }
       phaseResults.push({
         phase_id: phase.id,
         phase_title: phase.title,
@@ -1849,7 +2166,8 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         context,
         options,
         buildExecutionState(),
-        preflightExcludedPhaseIds
+        preflightExcludedPhaseIds,
+        routedPreflightAssignment
       );
       if (creativeAssetFixtureGap?.target.phaseId === phase.id) {
         const gapStep = buildCreativeAssetFixtureUnavailableStep(
@@ -1875,7 +2193,7 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         continue;
       }
     }
-    if (!phaseAbsent && phaseContainsOauthMetadataProbe(phase) && !agentAdvertisesOauth(profile)) {
+    if (!routingContext && phaseContainsOauthMetadataProbe(phase) && !agentAdvertisesOauth(profile)) {
       phaseAbsent = true;
     }
     context = { ...context };
@@ -1917,9 +2235,66 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       skippedCount += cascadeSteps.length;
       continue;
     }
+    const recordHardPrerequisiteFailure = (step, realFailure = false) => {
+      if (realFailure) {
+        phaseStatefulCascades.set(phase.id, null);
+      } else if (!phaseStatefulCascades.has(phase.id) || phaseStatefulCascades.get(phase.id)?.capabilityUnavailable === true) {
+        phaseStatefulCascades.set(phase.id, { stepId: step.id, reason: "prerequisite_failed" });
+      }
+    };
+    const recordHardMissingState = (step, result2) => {
+      const substitutes = phaseSubstitutes.get(step.id);
+      if (substitutes && substitutes.length > 0) {
+        if (phasePendingMissingTool.trigger === null) {
+          phasePendingMissingTool.trigger = {
+            stepId: step.id,
+            reason: result2.skip_reason ?? "missing_tool",
+            substitutes
+          };
+        }
+      } else {
+        const hasStatefulPeers = phaseStatefulStepIds.length > 1;
+        if (hasStatefulPeers && !phaseStatefulCascades.has(phase.id)) {
+          phaseStatefulCascades.set(phase.id, {
+            stepId: step.id,
+            reason: result2.skip_reason ?? "missing_tool"
+          });
+        } else if (!hasStatefulPeers && result2.skip) {
+          result2.skip = {
+            ...result2.skip,
+            detail: result2.skip.detail + soleStatefulExemptionDetail(phase.id)
+          };
+        }
+      }
+    };
     for (const step of phase.steps) {
       options.signal?.throwIfAborted();
-      if (phaseAbsent) {
+      if (routingContext && step.task === import_loader.VALIDATION_ONLY_TASK) {
+        const result3 = validationOnlyCoverageGap(step, phase.id, context, allSteps, runnerVars, storyboard.id);
+        stepResults.push(result3);
+        priorStepResults.set(step.id, result3);
+        skippedCount++;
+        continue;
+      }
+      let assignment;
+      try {
+        if (routingContext) assignment = dispatch.nextFor(step);
+      } catch (err) {
+        const failed = routingFailedStep(step, phase.id, err);
+        reportedRoutingErrors.add(step);
+        stepResults.push(failed);
+        countedAsFailed.add(failed);
+        priorStepResults.set(step.id, failed);
+        failedCount++;
+        phasePassed = false;
+        recordUnavailableOutputs(phase.id, step, missingPrerequisiteContextKeysByPhase);
+        if (step.stateful) phaseStatefulCascades.set(phase.id, null);
+        continue;
+      }
+      if (routingContext && assignment && phaseContainsOauthMetadataProbe(phase) && !agentAdvertisesOauth(assignment.profile)) {
+        routedOauthAbsent.add(assignment.instanceIndex);
+      }
+      if ((phaseAbsent || assignment && routedOauthAbsent.has(assignment.instanceIndex)) && !routedStepCapabilitySkips.has(step)) {
         const cascadeResult = {
           storyboard_id: storyboard.id,
           step_id: step.id,
@@ -1940,21 +2315,25 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         skippedCount++;
         continue;
       }
+      const selectedOptions = assignment?.options ?? options;
+      const routedCapabilityDetail = routedStepCapabilitySkips.get(step);
       const cascade = step.stateful ? cascadeForPhase(phase, priorPhaseIds) : { tripped: false };
-      if (cascade.tripped && step.stateful) {
-        const resolvedTask = resolveTaskName(step, options);
-        if (options.agentTools && resolvedTask && !options.agentTools.includes(resolvedTask)) {
-          const toolDetail = `Agent did not advertise tool "${resolvedTask}"; agent tools: [${options.agentTools.join(", ")}].`;
+      if (cascade.tripped && step.stateful && routedCapabilityDetail === void 0) {
+        const resolvedTask = (0, import_agent_routing.resolveTaskName)(step, selectedOptions);
+        const missingTool = selectedOptions.agentTools && (routingContext && step.requires_tool && !selectedOptions.agentTools.includes(step.requires_tool) ? step.requires_tool : resolvedTask && resolvedTask !== import_types.MCP_SESSION_PROBE_TASK && !selectedOptions.agentTools.includes(resolvedTask) ? resolvedTask : void 0);
+        if (missingTool) {
+          const missingReason = routingContext && missingTool === "comply_test_controller" ? "missing_test_controller" : "missing_tool";
+          const toolDetail = `Agent did not advertise tool "${missingTool}"; agent tools: [${selectedOptions.agentTools.join(", ")}].`;
           const missingToolResult = {
             storyboard_id: storyboard.id,
             step_id: step.id,
             phase_id: phase.id,
             title: step.title,
-            task: resolvedTask,
+            task: resolvedTask ?? step.task,
             passed: true,
             skipped: true,
-            skip_reason: "missing_tool",
-            skip: buildSkip("missing_tool", toolDetail),
+            skip_reason: missingReason,
+            skip: buildSkip(missingReason, toolDetail),
             duration_ms: 0,
             validations: [],
             context,
@@ -1962,12 +2341,42 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
           };
           stepResults.push(missingToolResult);
           priorStepResults.set(step.id, missingToolResult);
+          if (routingContext) {
+            recordUnavailableOutputs(phase.id, step, missingPrerequisiteContextKeysByPhase);
+            recordHardMissingState(step, missingToolResult);
+          }
           skippedCount++;
           continue;
         }
         const trigger = cascade.trigger;
-        const detail = trigger ? trigger.substitution_chain ? `Skipped: prior stateful step "${trigger.stepId}" skipped (${trigger.reason}); ${trigger.substitution_chain}; state never materialized.` : `Skipped: prior stateful step "${trigger.stepId}" skipped (${trigger.reason}); state never materialized.` : "Skipped: prior stateful step failed.";
-        const capabilityUnavailable = trigger?.capabilityUnavailable === true;
+        let detail = trigger ? trigger.substitution_chain ? `Skipped: prior stateful step "${trigger.stepId}" skipped (${trigger.reason}); ${trigger.substitution_chain}; state never materialized.` : `Skipped: prior stateful step "${trigger.stepId}" skipped (${trigger.reason}); state never materialized.` : "Skipped: prior stateful step failed.";
+        let capabilityUnavailable = trigger?.capabilityUnavailable === true;
+        if (capabilityUnavailable && routingContext && !import_trusted_match_publisher_auth.TRUSTED_MATCH_PUBLISHER_AUTH_TASKS.has(step.task) && !import_probes.PROBE_TASKS.has(step.task) && !import_webhook_assertions.WEBHOOK_ASSERTION_TASKS.has(step.task) && step.task !== REPLAY_WEBHOOK_VECTOR_TASK && (!step.requires_contract || (selectedOptions.contracts ?? []).includes(step.requires_contract))) {
+          const hardKeys = unavailableContextKeysForPhase(phase, priorPhaseIds, missingPrerequisiteContextKeysByPhase);
+          if (hardKeys.size > 0) {
+            const effectiveRequest = buildEffectiveStepRequest(
+              { ...step, task: resolvedTask ?? step.task },
+              context,
+              selectedOptions,
+              buildExecutionState(assignment?.agentUrl, assignment?.profile)
+            );
+            const missingKeys = /* @__PURE__ */ new Set([
+              ...(effectiveRequest.ok ? findUnresolvedContextVars(effectiveRequest.request) : []).filter((v) => hardKeys.has(v.key)).map((v) => v.key),
+              ...(step.context_inputs ?? []).filter((input) => !(input.key in context) && hardKeys.has(input.key)).map((input) => input.key)
+            ]);
+            if (missingKeys.size > 0) {
+              capabilityUnavailable = false;
+              detail = `Skipped: context required from a failed or unavailable prerequisite is missing: ${[...missingKeys].join(", ")}.`;
+            }
+          }
+        }
+        if (capabilityUnavailable) {
+          recordUnavailableOutputs(phase.id, step);
+          if (routingContext) phaseInheritedCapabilityTrigger ??= trigger ?? void 0;
+        } else if (routingContext) {
+          recordUnavailableOutputs(phase.id, step, missingPrerequisiteContextKeysByPhase);
+          recordHardPrerequisiteFailure(step, trigger === null);
+        }
         stepResults.push({
           storyboard_id: storyboard.id,
           step_id: step.id,
@@ -1995,46 +2404,47 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         skippedCount++;
         continue;
       }
-      let assignment;
-      try {
-        assignment = dispatch.nextFor(step);
-      } catch (err) {
-        const detail = err instanceof import_agent_routing.RoutingError ? err.message : err?.message ?? String(err);
-        const failed = {
-          storyboard_id: storyboard.id,
-          step_id: step.id,
-          phase_id: phase.id,
-          title: step.title,
-          task: step.task,
-          passed: false,
-          duration_ms: 0,
-          validations: [],
-          context,
-          error: detail,
-          extraction: { path: "none" }
-        };
-        stepResults.push(failed);
-        priorStepResults.set(step.id, failed);
-        failedCount++;
-        phasePassed = false;
-        continue;
-      }
+      assignment ??= dispatch.nextFor(step);
       const stepExecutionState = buildExecutionState(assignment.agentUrl, assignment.profile);
-      stepExecutionState.capabilityUnavailableContextKeys = capabilityUnavailableContextKeysForPhase(
-        phase,
-        priorPhaseIds
-      );
-      const rawResult = await executeStep(
+      if (routingContext) {
+        let probes = routedPriorProbes.get(assignment.instanceIndex);
+        if (!probes) {
+          probes = /* @__PURE__ */ new Map();
+          routedPriorProbes.set(assignment.instanceIndex, probes);
+        }
+        stepExecutionState.priorProbes = probes;
+        stepExecutionState.allowPriorProbeFallback = false;
+      }
+      stepExecutionState.capabilityUnavailableContextKeys = unavailableContextKeysForPhase(phase, priorPhaseIds);
+      if (routingContext) {
+        stepExecutionState.missingPrerequisiteContextKeys = unavailableContextKeysForPhase(
+          phase,
+          priorPhaseIds,
+          missingPrerequisiteContextKeysByPhase
+        );
+      }
+      const rawResult = routedCapabilityDetail !== void 0 ? buildPhaseCapabilitySkippedSteps(
+        storyboard,
+        { ...phase, steps: [step] },
+        routedCapabilityDetail,
+        context
+      )[0] : await executeStep(
         assignment.client,
         step,
         storyboard.id,
         phase.id,
         context,
         allSteps,
-        options,
+        assignment.options ?? options,
         stepExecutionState
       );
       const result2 = { ...rawResult, storyboard_id: storyboard.id };
+      if (routedCapabilityDetail !== void 0 || result2.skip_reason === "capability_prerequisite_unavailable") {
+        recordUnavailableOutputs(phase.id, step);
+      }
+      if (routedCapabilityDetail !== void 0 && routedStepRequirements.has(step)) {
+        result2.skip = { ...result2.skip, requirement: routedStepRequirements.get(step) };
+      }
       if (isMultiInstance || useRouting) {
         result2.agent_url = (0, import_oauth_metadata_graph.redactOAuthUrlForOutput)(assignment.agentUrl);
         result2.agent_index = assignment.instanceIndex + 1;
@@ -2080,11 +2490,13 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       }
       if (step.task === "protected_resource_metadata") {
         if (result2.skipped && result2.skip_reason === "oauth_not_advertised") {
-          phaseAbsent = true;
+          if (routingContext) routedOauthAbsent.add(assignment.instanceIndex);
+          else phaseAbsent = true;
         } else {
           const status = result2.response?.status;
           if (typeof status === "number" && status >= 200 && status < 300) {
-            presenceDetected = true;
+            if (routingContext) routedOauthPresent.add(assignment.instanceIndex);
+            else presenceDetected = true;
           }
         }
       }
@@ -2100,34 +2512,26 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
       if (result2.skipped) {
         skippedCount++;
         context = result2.context;
+        const hardPrerequisite = isHardMissingStateSkipReason(result2.skip_reason) || result2.skip_reason === "prerequisite_failed";
+        if (result2.skip_reason === "prerequisite_failed" && !result2.passed) phasePassed = false;
+        if (routingContext && hardPrerequisite) {
+          recordUnavailableOutputs(phase.id, step, missingPrerequisiteContextKeysByPhase);
+          if (!result2.passed) {
+            phasePassed = false;
+            if (step.stateful) recordHardPrerequisiteFailure(step);
+          }
+        }
         if (step.stateful) {
           if (isHardMissingStateSkipReason(result2.skip_reason)) {
-            const substitutes = phaseSubstitutes.get(step.id);
-            if (substitutes && substitutes.length > 0) {
-              if (phasePendingMissingTool === null) {
-                phasePendingMissingTool = {
-                  stepId: step.id,
-                  reason: result2.skip_reason ?? "missing_tool",
-                  substitutes
-                };
-              }
-            } else {
-              const hasStatefulPeers = phaseStatefulStepIds.length > 1;
-              if (hasStatefulPeers && !phaseStatefulCascades.has(phase.id)) {
-                phaseStatefulCascades.set(phase.id, {
-                  stepId: step.id,
-                  reason: result2.skip_reason ?? "missing_tool"
-                });
-              } else if (!hasStatefulPeers && result2.skip) {
-                result2.skip = {
-                  ...result2.skip,
-                  detail: result2.skip.detail + soleStatefulExemptionDetail(phase.id)
-                };
-              }
-            }
-          } else if (result2.skip_reason === "not_applicable") {
-            if (phasePendingNotApplicable === null) {
-              phasePendingNotApplicable = { stepId: step.id, reason: "not_applicable" };
+            recordHardMissingState(step, result2);
+          } else if (result2.skip_reason === "not_applicable" || result2.skip_reason === "capability_prerequisite_unavailable") {
+            const capabilityUnavailable = routedCapabilityDetail !== void 0 || result2.skip_reason === "capability_prerequisite_unavailable";
+            if (phasePendingNotApplicable === null || phasePendingNotApplicable.capabilityUnavailable === true && !capabilityUnavailable) {
+              phasePendingNotApplicable = {
+                stepId: step.id,
+                reason: result2.skip_reason,
+                ...capabilityUnavailable ? { capabilityUnavailable: true } : {}
+              };
             }
           }
         }
@@ -2149,7 +2553,7 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         }
       } else {
         phasePassed = false;
-        if (!phase.optional || presenceDetected) {
+        if (!phase.optional || (routingContext ? routedOauthPresent.has(assignment.instanceIndex) : presenceDetected)) {
           failedCount++;
           countedAsFailed.add(result2);
         }
@@ -2171,7 +2575,8 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
             context,
             options,
             stepExecutionState,
-            preflightExcludedPhaseIds
+            preflightExcludedPhaseIds,
+            routedPreflightAssignment
           );
         }
         if (creativeAssetFixtureGap) {
@@ -2194,6 +2599,15 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         }
       }
     }
+    if (phasePendingMissingTool.trigger && !phaseRescuedTargets.has(phasePendingMissingTool.trigger.stepId) && !phaseStatefulCascades.has(phase.id)) {
+      const subs = phasePendingMissingTool.trigger.substitutes;
+      const subsList = subs.length === 1 ? `"${subs[0]}"` : subs.map((s) => `"${s}"`).join(", ");
+      phaseStatefulCascades.set(phase.id, {
+        stepId: phasePendingMissingTool.trigger.stepId,
+        reason: phasePendingMissingTool.trigger.reason,
+        substitution_chain: `declared substitute ${subsList} did not pass`
+      });
+    }
     if (phasePendingNotApplicable && !phaseEstablishedStatefulState && !phaseStatefulCascades.has(phase.id)) {
       const hadStatefulPeers = phaseStatefulStepIds.some((id) => id !== phasePendingNotApplicable.stepId);
       if (hadStatefulPeers) {
@@ -2208,14 +2622,8 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         }
       }
     }
-    if (phasePendingMissingTool && !phaseRescuedTargets.has(phasePendingMissingTool.stepId) && !phaseStatefulCascades.has(phase.id)) {
-      const subs = phasePendingMissingTool.substitutes;
-      const subsList = subs.length === 1 ? `"${subs[0]}"` : subs.map((s) => `"${s}"`).join(", ");
-      phaseStatefulCascades.set(phase.id, {
-        stepId: phasePendingMissingTool.stepId,
-        reason: phasePendingMissingTool.reason,
-        substitution_chain: `declared substitute ${subsList} did not pass`
-      });
+    if (phaseInheritedCapabilityTrigger && !phaseStatefulCascades.has(phase.id)) {
+      phaseStatefulCascades.set(phase.id, phaseInheritedCapabilityTrigger);
     }
     for (const target of phaseRescuedTargets) {
       const sourceId = phaseRescueSource.get(target);
@@ -2236,6 +2644,27 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
     });
     priorPhaseIds.push(phase.id);
   }
+  for (const phase of storyboard.phases) {
+    const result2 = phaseResults.find((p) => p.phase_id === phase.id);
+    for (const step of phase.steps) {
+      if (!routedErrors.has(step) || reportedRoutingErrors.has(step)) continue;
+      const failed = routingFailedStep(step, phase.id, routedErrors.get(step));
+      const existingIndex = result2.steps.findIndex((row) => row.step_id === step.id);
+      if (existingIndex >= 0) {
+        const existing = result2.steps[existingIndex];
+        if (existing.skipped) skippedCount--;
+        if (countedAsFailed.delete(existing)) failedCount--;
+        result2.steps[existingIndex] = failed;
+      } else {
+        result2.steps.push(failed);
+      }
+      reportedRoutingErrors.add(step);
+      countedAsFailed.add(failed);
+      result2.passed = false;
+      priorStepResults.set(step.id, failed);
+      failedCount++;
+    }
+  }
   const branchSetDelta = creativeAssetFixtureGap ? { skippedDelta: 0 } : applyBranchSetGrading(
     storyboard.phases,
     phaseResults,
@@ -2272,8 +2701,9 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
     const phaseResult = phaseResults.find((p) => p.phase_id === phaseDef.id);
     return !!phaseResult && phaseResult.passed && phaseResult.steps.some((s) => !s.skipped && s.passed);
   });
-  const requiredPhasesPassed = !hasExecutableSteps || requiredPhaseHasExecutedPass || requiredPhasesNonFailingSkipped || failedCount === 0 && requiredPhasesCoveredByCapabilityGates;
+  const requiredPhasesPassed = !hasExecutableSteps || requiredPhaseDefs.every((phaseDef) => phaseResults.find((p) => p.phase_id === phaseDef.id)?.passed === true) && (requiredPhaseHasExecutedPass || requiredPhasesNonFailingSkipped || failedCount === 0 && requiredPhasesCoveredByCapabilityGates);
   const storyboardWideFixtureUnavailable = (seedingUnsupported || fixtureUnsatisfied || creativeAssetFixtureGap !== void 0) && failedCount === 0;
+  const hasUnverifiedCoverage = signingCoverageUnverified(phaseResults.flatMap((phase) => phase.steps));
   if (seedingPhaseResult) phaseResults.unshift(seedingPhaseResult);
   const schemasUsed = collectSchemasUsed(phaseResults);
   const strictSummary = summarizeStrictValidation(phaseResults);
@@ -2297,7 +2727,7 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         Object.entries(routingContext.agentMap).map(([specialism, url]) => [specialism, (0, import_oauth_metadata_graph.redactOAuthUrlForOutput)(url)])
       )
     },
-    overall_passed: failedCount === 0 && (requiredPhasesPassed || storyboardWideFixtureUnavailable) && !assertionsFailed,
+    overall_passed: failedCount === 0 && (requiredPhasesPassed || storyboardWideFixtureUnavailable) && !assertionsFailed && !hasUnverifiedCoverage,
     phases: phaseResults,
     context,
     total_duration_ms: Date.now() - start,
@@ -2347,9 +2777,17 @@ async function runMultiPass(agentUrls, storyboard, options) {
     options = {
       ...options,
       _profile: preSeedProfile,
-      ...options.agentTools ? {} : { agentTools: normalizeAgentToolNames(preSeedProfile.tools) }
+      ...options.agentTools ? {} : { agentTools: (0, import_agent_routing.normalizeAgentToolNames)(preSeedProfile.tools) }
     };
   }
+  const resetFailure = await resetControllerStates(
+    preSeedClients.map((client) => ({ client, options })),
+    storyboard
+  );
+  if (resetFailure) {
+    await (0, import_protocols.closeScopedConnections)(options.protocol);
+    return buildDiscoveryFailedResult(agentUrls, storyboard, resetFailure);
+  }
   if (storyboardCapabilityPredicates(storyboard).length > 0) {
     const unmetDetail = evaluateStoryboardCapabilityGates(
       storyboard,
@@ -2594,7 +3032,7 @@ async function runStoryboardStepBody(agentUrl, storyboard, stepId, options) {
       options = {
         ...options,
         ...!options._profile && { _profile: profile },
-        ...!options.agentTools && { agentTools: normalizeAgentToolNames(profile.tools) }
+        ...!options.agentTools && { agentTools: (0, import_agent_routing.normalizeAgentToolNames)(profile.tools) }
       };
     }
   } else {
@@ -2682,6 +3120,38 @@ async function runStoryboardStepBody(agentUrl, storyboard, stepId, options) {
   if (ownsWebhookReceiver && webhookReceiver) await webhookReceiver.close();
   return { ...result, contributions: Array.from(contributions) };
 }
+function unresolvedStepContextVars(step, request, context, runState) {
+  const unavailableInputs = (step.context_inputs ?? []).filter(
+    (input) => !(input.key in context) && (runState.capabilityUnavailableContextKeys?.has(input.key) === true || runState.missingPrerequisiteContextKeys?.has(input.key) === true)
+  );
+  return [
+    ...findUnresolvedContextVars(request),
+    ...unavailableInputs.map((input) => ({ key: input.key, token: `$context.${input.key}` }))
+  ];
+}
+function buildStepRequest(step, effectiveStep, context, options, runnerVars) {
+  let request;
+  if (options.request) {
+    request = (0, import_context.injectContext)({ ...options.request }, context, runnerVars);
+  } else if (step.expect_error && step.sample_request) {
+    request = (0, import_context.injectContext)({ ...step.sample_request }, context, runnerVars);
+  } else if ((0, import_request_builder.hasRequestEnricher)(effectiveStep.task)) {
+    request = (0, import_request_builder.enrichRequest)(effectiveStep, context, options, runnerVars);
+  } else if (step.sample_request) {
+    request = (0, import_context.injectContext)({ ...step.sample_request }, context, runnerVars);
+  } else {
+    request = {};
+  }
+  if (step.context_inputs?.length) {
+    request = (0, import_context.applyContextInputs)(request, step.context_inputs, context);
+  }
+  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);
+  return request;
+}
 async function executeStep(client, step, storyboardId, phaseId, context, allSteps, options, state) {
   const runState = state ?? {
     contributions: /* @__PURE__ */ new Set(),
@@ -2731,7 +3201,7 @@ async function executeStep(client, step, storyboardId, phaseId, context, allStep
       extraction: { path: "none", note: "test-kit contract not configured" }
     };
   }
-  const resolvedTask = resolveTaskName(step, options);
+  const resolvedTask = (0, import_agent_routing.resolveTaskName)(step, options);
   if (!resolvedTask) {
     if (step.task === "$test_kit.auth.probe_task" && options.agentTools) {
       const detail = `Agent does not advertise an auth-required, read-only tool that accepts an empty request body; security auth probes are not applicable to tools [${options.agentTools.join(", ")}].`;
@@ -2785,6 +3255,9 @@ async function executeStep(client, step, storyboardId, phaseId, context, allStep
       extraction: { path: "none" }
     };
   }
+  if (effectiveStep.task === import_types.MCP_SESSION_PROBE_TASK) {
+    return executeProbeStep(client, effectiveStep, phaseId, context, allSteps, options, runState);
+  }
   if (effectiveStep.task === "sync_accounts") {
     const rawCaps = options._profile?.raw_capabilities;
     if (rawCaps !== void 0) {
@@ -2830,47 +3303,7 @@ async function executeStep(client, step, storyboardId, phaseId, context, allStep
       extraction: { path: "none" }
     };
   }
-  let request;
-  if (options.request) {
-    request = (0, import_context.injectContext)({ ...options.request }, context, runState.runnerVars);
-  } else if (step.expect_error && step.sample_request) {
-    request = (0, import_context.injectContext)({ ...step.sample_request }, context, runState.runnerVars);
-  } else if ((0, import_request_builder.hasRequestEnricher)(effectiveStep.task)) {
-    request = (0, import_request_builder.enrichRequest)(effectiveStep, context, options, runState.runnerVars);
-  } else if (step.sample_request) {
-    request = (0, import_context.injectContext)({ ...step.sample_request }, context, runState.runnerVars);
-  } else {
-    request = {};
-  }
-  if (step.context_inputs?.length) {
-    request = (0, import_context.applyContextInputs)(request, step.context_inputs, context);
-  }
-  const unavailableContextInputs = (step.context_inputs ?? []).filter(
-    (input) => !(input.key in context) && runState.capabilityUnavailableContextKeys?.has(input.key) === true
-  );
-  if (unavailableContextInputs.length > 0) {
-    const detail = "Skipped: context required by a capability-gated phase is unavailable: " + unavailableContextInputs.map((input) => input.key).join(", ") + ".";
-    return {
-      step_id: step.id,
-      phase_id: phaseId,
-      title: step.title,
-      task: step.task,
-      passed: true,
-      skipped: true,
-      skip_reason: "capability_prerequisite_unavailable",
-      skip: buildSkip("not_applicable", detail),
-      duration_ms: 0,
-      validations: [],
-      context,
-      next: getNextStepPreview(step.id, allSteps, context, runState.runnerVars),
-      extraction: { path: "none" }
-    };
-  }
-  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);
+  let request = buildStepRequest(step, effectiveStep, context, options, runState.runnerVars);
   const fixtureBinding = applyFixtureBindingsSafely(request, effectiveStep.task, options, runState);
   if (!fixtureBinding.ok) {
     const next2 = getNextStepPreview(step.id, allSteps, context, runState.runnerVars);
@@ -2913,7 +3346,7 @@ async function executeStep(client, step, storyboardId, phaseId, context, allStep
       effectiveStep.task
     );
   }
-  const unresolvedContextVars = findUnresolvedContextVars(request);
+  const unresolvedContextVars = unresolvedStepContextVars(step, request, context, runState);
   const unresolvedAssetDirectives = (0, import_creative_assets.findUnresolvedCreativeAssetDirectives)(request).map((path) => ({
     key: path,
     token: import_creative_assets.BUILD_ASSETS_FROM_FORMAT_DIRECTIVE
@@ -2922,11 +3355,14 @@ async function executeStep(client, step, storyboardId, phaseId, context, allStep
   const hasCapabilityUnavailableContext = unresolvedContextVars.some(
     (v) => runState.capabilityUnavailableContextKeys?.has(v.key) === true
   );
-  if (unresolvedAssetDirectives.length > 0 || unresolvedContextVars.length > 0 && (!step.expect_error || hasCapabilityUnavailableContext)) {
+  const hasMissingToolUnavailableContext = unresolvedContextVars.some(
+    (v) => runState.missingPrerequisiteContextKeys?.has(v.key) === true
+  );
+  if (unresolvedAssetDirectives.length > 0 || unresolvedContextVars.length > 0 && (!step.expect_error || hasCapabilityUnavailableContext || hasMissingToolUnavailableContext)) {
     const next2 = getNextStepPreview(step.id, allSteps, context, runState.runnerVars);
     const responseDerivedDetails = unresolvedVars.map((v) => runState.responseDerivedNotApplicableContextKeys?.get(v.key)).filter((d) => typeof d === "string");
-    const allResponseDerived = responseDerivedDetails.length === unresolvedVars.length && responseDerivedDetails.length > 0;
-    const allCapabilityUnavailable = unresolvedContextVars.length === unresolvedVars.length && unresolvedContextVars.length > 0 && unresolvedContextVars.every((v) => runState.capabilityUnavailableContextKeys?.has(v.key) === true);
+    const allResponseDerived = !hasMissingToolUnavailableContext && responseDerivedDetails.length === unresolvedVars.length && responseDerivedDetails.length > 0;
+    const allCapabilityUnavailable = !hasMissingToolUnavailableContext && unresolvedContextVars.length === unresolvedVars.length && unresolvedContextVars.length > 0 && unresolvedContextVars.every((v) => runState.capabilityUnavailableContextKeys?.has(v.key) === true);
     const detail = allResponseDerived ? [...new Set(responseDerivedDetails)].join("; ") : allCapabilityUnavailable ? `Skipped: context required by a capability-gated phase is unavailable: ${unresolvedVars.map((v) => v.key).join(", ")}.` : `Skipped: unresolved context variables from prior steps: ${unresolvedVars.map((v) => v.key).join(", ")}.`;
     const synthesized = [];
     if (!allResponseDerived && !allCapabilityUnavailable) {
@@ -3792,6 +4228,9 @@ async function executeProbeStep(client, step, phaseId, context, allSteps, option
     fetchFn: options.transport?.trustedFetchFn
   };
   let requestRecordOverride;
+  let sessionProbeStage;
+  let sessionProbeDetail;
+  let sessionProbeTool;
   const contractsInScope = new Set(options.contracts ?? []);
   if (step.requires_contract) {
     if (!contractsInScope.has(step.requires_contract)) {
@@ -3873,10 +4312,48 @@ async function executeProbeStep(client, step, phaseId, context, allSteps, option
       httpResult.skip_reason = "oauth_not_advertised";
     }
   } else if (step.task === "oauth_auth_server_metadata") {
-    const prior = runState.priorProbes.get("protected_resource_metadata") ?? findPriorProbe(runState.priorStepResults);
+    const prior = runState.priorProbes.get("protected_resource_metadata") ?? (runState.allowPriorProbeFallback !== false ? findPriorProbe(runState.priorStepResults) : void 0);
     httpResult = await (0, import_probes.probeOauthAuthServerMetadata)(prior, probeOpts);
   } else if (step.task === "assert_contribution") {
     httpResult = void 0;
+  } else if (step.task === import_types.MCP_SESSION_PROBE_TASK) {
+    const plan = planMcpSessionSentinel(step, options, client, runState.agentUrl);
+    if (plan.kind === "error") {
+      httpResult = { url: runState.agentUrl, status: 0, headers: {}, body: null, error: plan.error };
+    } else if (plan.kind === "skip") {
+      httpResult = {
+        url: runState.agentUrl,
+        status: 0,
+        headers: {},
+        body: null,
+        skipped: true,
+        skip_reason: plan.reason,
+        error: plan.detail
+      };
+    } else {
+      const probe = await (0, import_probes.rawMcpSessionProbe)({
+        agentUrl: runState.agentUrl,
+        headers: plan.headers,
+        toolName: plan.toolNames,
+        control: plan.control,
+        // Values the probe withholds but the run's ordinary steps do send, so
+        // a stateful agent's echo cannot land them in this step's evidence.
+        redactValues: runCredentialValues(options),
+        allowPrivateIp: options.allow_http === true,
+        // Honour run cancellation and cap each request well under the shared
+        // 10 s `ssrfSafeFetch` default. The probe additionally bounds the
+        // whole step — candidate walk included — with one shared request /
+        // byte / wall-clock budget, so a tarpitting agent cannot multiply this
+        // per-request cap by the length of its own tool list.
+        ...options.signal && { signal: options.signal },
+        timeoutMs: MCP_SESSION_PROBE_REQUEST_TIMEOUT_MS,
+        ...options.transport?.trustedFetchFn && { fetchFn: options.transport.trustedFetchFn }
+      });
+      httpResult = probe.httpResult;
+      sessionProbeStage = probe.stage;
+      sessionProbeDetail = probe.detail;
+      sessionProbeTool = probe.gradedTool;
+    }
   } else if (step.task === "request_signing_probe") {
     httpResult = await (0, import_probe_dispatch.probeRequestSigningVector)(step.id, runState.agentUrl, options);
   } else if (step.task === "fetch_brand_jwks") {
@@ -3953,30 +4430,35 @@ async function executeProbeStep(client, step, phaseId, context, allSteps, option
         };
       }
       const resolvedTargetRequest = targetRequestResult.request;
-      const unresolvedContextVars = findUnresolvedContextVars(resolvedTargetRequest);
+      const advertisedTools = resolveAdvertisedTools(options);
+      const routedPrerequisites = runState.missingPrerequisiteContextKeys !== void 0 && (!advertisedTools || advertisedTools.includes(rateLimitTrip.trip_target_task));
+      const unresolvedContextVars = routedPrerequisites ? unresolvedStepContextVars(targetStep, resolvedTargetRequest, context, runState) : findUnresolvedContextVars(resolvedTargetRequest);
       const unresolvedAssetDirectives = (0, import_creative_assets.findUnresolvedCreativeAssetDirectives)(resolvedTargetRequest).map((path) => ({
         key: path,
         token: import_creative_assets.BUILD_ASSETS_FROM_FORMAT_DIRECTIVE
       }));
       const unresolvedVars = [...unresolvedContextVars, ...unresolvedAssetDirectives];
-      if (unresolvedAssetDirectives.length > 0 || unresolvedContextVars.length > 0 && !targetStep.expect_error) {
+      const hardUnavailable = routedPrerequisites && unresolvedContextVars.some((v) => runState.missingPrerequisiteContextKeys?.has(v.key));
+      const capabilityUnavailable = routedPrerequisites && unresolvedContextVars.some((v) => runState.capabilityUnavailableContextKeys?.has(v.key));
+      if (unresolvedAssetDirectives.length > 0 || unresolvedContextVars.length > 0 && (!targetStep.expect_error || hardUnavailable || capabilityUnavailable)) {
         const next = getNextStepPreview(step.id, allSteps, context, runState.runnerVars);
-        const detail = `Skipped: unresolved context variables from rate_limit_trip.trip_target_sample_request: ${unresolvedVars.map((v) => v.key).join(", ")}.`;
+        const allCapabilityUnavailable = capabilityUnavailable && !hardUnavailable && unresolvedAssetDirectives.length === 0 && unresolvedContextVars.every((v) => runState.capabilityUnavailableContextKeys?.has(v.key));
+        const detail = allCapabilityUnavailable ? `Skipped: context required by a capability-gated phase is unavailable: ${unresolvedVars.map((v) => v.key).join(", ")}.` : `Skipped: unresolved context variables from rate_limit_trip.trip_target_sample_request: ${unresolvedVars.map((v) => v.key).join(", ")}.`;
         return {
           step_id: step.id,
           phase_id: phaseId,
           title: step.title,
           task: step.task,
-          passed: false,
+          passed: allCapabilityUnavailable,
           skipped: true,
-          skip_reason: "prerequisite_failed",
-          skip: buildSkip("prerequisite_failed", detail),
+          skip_reason: allCapabilityUnavailable ? "capability_prerequisite_unavailable" : "prerequisite_failed",
+          skip: buildSkip(allCapabilityUnavailable ? "not_applicable" : "prerequisite_failed", detail),
           duration_ms: Date.now() - start,
           validations: [],
           context,
           next,
           extraction: { path: "none" },
-          error: detail
+          ...!allCapabilityUnavailable && { error: detail }
         };
       }
       const unresolvedRunnerTokens = findUnresolvedRunnerTokens(resolvedTargetRequest);
@@ -4002,7 +4484,6 @@ async function executeProbeStep(client, step, phaseId, context, allSteps, option
           ...isPrerequisiteFailure ? { error: detail } : {}
         };
       }
-      const advertisedTools = resolveAdvertisedTools(options);
       if (advertisedTools && !advertisedTools.includes(rateLimitTrip.trip_target_task)) {
         const next = getNextStepPreview(step.id, allSteps, context, runState.runnerVars);
         const detail = `Agent did not advertise tool "${rateLimitTrip.trip_target_task}"; agent tools: [${advertisedTools.join(", ")}].`;
@@ -4098,7 +4579,7 @@ async function executeProbeStep(client, step, phaseId, context, allSteps, option
   if (httpResult?.skipped) {
     const detailedReason = httpResult.skip_reason ?? "probe_skipped";
     const canonicalReason = import_types.DETAILED_SKIP_TO_CANONICAL[detailedReason] ?? "not_applicable";
-    const detail = CANONICAL_SKIP_DETAILS[detailedReason] ?? httpResult.error ?? DETAILED_SKIP_DETAILS[detailedReason] ?? SKIP_DETAILS[canonicalReason];
+    const detail = CANONICAL_SKIP_DETAILS[detailedReason] ?? redactedHttpResult?.error ?? DETAILED_SKIP_DETAILS[detailedReason] ?? SKIP_DETAILS[canonicalReason];
     const selectionResult = selectionForProbeSkip(detailedReason, detail);
     return {
       step_id: step.id,
@@ -4145,7 +4626,8 @@ async function executeProbeStep(client, step, phaseId, context, allSteps, option
   const allValidationsPassed = validations.every((v) => !(0, import_validations.validationFailsStep)(v));
   const fetchOk = httpResult ? !httpResult.error : true;
   const passed = fetchOk && allValidationsPassed;
-  const extraction = httpResult ? httpResult.error ? { path: "error" } : { path: "structured_content", note: "http-probe body parsed as JSON" } : { path: "none" };
+  const probeNote = sessionProbeStage !== void 0 ? `MCP session probe graded ${sessionProbeTool ?? "unknown tool"} at ${sessionProbeStage} (${sessionProbeDetail ?? "no detail"})` : "http-probe body parsed as JSON";
+  const extraction = httpResult ? httpResult.error ? { path: "error" } : { path: "structured_content", note: probeNote } : { path: "none" };
   return {
     step_id: step.id,
     phase_id: phaseId,
@@ -4156,7 +4638,9 @@ async function executeProbeStep(client, step, phaseId, context, allSteps, option
     response: redactedHttpResult ?? void 0,
     validations,
     context,
-    error: httpResult?.error ?? (passed ? void 0 : "Probe validations failed."),
+    // Redacted copy on both branches: the sibling skip branch reads the same
+    // seam, and a probe error can carry an agent URL with OAuth params.
+    error: redactedHttpResult?.error ?? (passed ? void 0 : "Probe validations failed."),
     next: getNextStepPreview(step.id, allSteps, context, runState.runnerVars),
     request: requestRecord,
     ...responseRecord && { response_record: responseRecord },
@@ -4179,26 +4663,7 @@ function applyFixtureBindingsSafely(request, task, options, runState) {
   }
 }
 function buildEffectiveStepRequest(step, context, options, runState) {
-  let request;
-  if (options.request) {
-    request = (0, import_context.injectContext)({ ...options.request }, context, runState.runnerVars);
-  } else if (step.expect_error && step.sample_request) {
-    request = (0, import_context.injectContext)({ ...step.sample_request }, context, runState.runnerVars);
-  } else if ((0, import_request_builder.hasRequestEnricher)(step.task)) {
-    request = (0, import_request_builder.enrichRequest)(step, context, options, runState.runnerVars);
-  } else if (step.sample_request) {
-    request = (0, import_context.injectContext)({ ...step.sample_request }, context, runState.runnerVars);
-  } else {
-    request = {};
-  }
-  if (step.context_inputs?.length) {
-    request = (0, import_context.applyContextInputs)(request, step.context_inputs, context);
-  }
-  request = applyBrandInvariant(request, options, step.task, { omit_account: step.omit_account });
-  if (options.disable_sandbox === true) {
-    request = applyDisableSandboxHint(request, step.task);
-  }
-  request = applyIdempotencyInvariant(request, step.task, step);
+  const request = buildStepRequest(step, step, context, options, runState.runnerVars);
   const fixtureBinding = applyFixtureBindingsSafely(request, step.task, options, runState);
   if (!fixtureBinding.ok) return fixtureBinding;
   const creativeAssetExpansion = (0, import_creative_assets.expandCreativeAssetDirectivesWithDiagnostics)(
@@ -4214,23 +4679,32 @@ function buildEffectiveStepRequest(step, context, options, runState) {
     request: creativeAssetExpansion.value
   };
 }
-function preflightRemainingCreativeAssetDirectives(allSteps, afterGlobalIndex, context, options, runState, excludedPhaseIds = /* @__PURE__ */ new Set()) {
+function preflightRemainingCreativeAssetDirectives(allSteps, afterGlobalIndex, context, options, runState, excludedPhaseIds = /* @__PURE__ */ new Set(), resolveAssignment) {
   const contractsInScope = new Set(options.contracts ?? []);
   for (const target of allSteps) {
     if (target.globalIndex <= afterGlobalIndex) continue;
     if (excludedPhaseIds.has(target.phaseId)) continue;
-    const resolvedTask = resolveTaskName(target.step, options);
+    const assignment = resolveAssignment?.(target.step);
+    if (resolveAssignment && !assignment) continue;
+    const selectedOptions = assignment?.options ?? options;
+    const selectedState = assignment ? {
+      ...runState,
+      agentUrl: assignment.agentUrl,
+      agentProfile: assignment.profile,
+      agentLibraryVersion: assignment.profile?.library_version
+    } : runState;
+    const resolvedTask = (0, import_agent_routing.resolveTaskName)(target.step, selectedOptions);
     if (!resolvedTask) continue;
-    if (target.step.requires_tool && options.agentTools && !options.agentTools.includes(target.step.requires_tool)) {
+    if (target.step.requires_tool && selectedOptions.agentTools && !selectedOptions.agentTools.includes(target.step.requires_tool)) {
       continue;
     }
     if (target.step.requires_contract && !contractsInScope.has(target.step.requires_contract)) {
       continue;
     }
-    if (target.step.task === "expect_rate_limit_not_replayed" && (!contractsInScope.has(import_rate_limit_trip.RATE_LIMIT_TRIP_CONTRACT) || options.allowLiveSideEffects !== true)) {
+    if (target.step.task === "expect_rate_limit_not_replayed" && (!contractsInScope.has(import_rate_limit_trip.RATE_LIMIT_TRIP_CONTRACT) || selectedOptions.allowLiveSideEffects !== true)) {
       continue;
     }
-    if (!import_probes.PROBE_TASKS.has(target.step.task) && options.agentTools && !options.agentTools.includes(resolvedTask)) {
+    if (!import_probes.PROBE_TASKS.has(target.step.task) && selectedOptions.agentTools && !selectedOptions.agentTools.includes(resolvedTask)) {
       continue;
     }
     let requestStep = resolvedTask === target.step.task ? target.step : { ...target.step, task: resolvedTask };
@@ -4244,7 +4718,7 @@ function preflightRemainingCreativeAssetDirectives(allSteps, afterGlobalIndex, c
         omit_idempotency_key: true
       };
     }
-    const request = buildEffectiveStepRequest(requestStep, context, options, runState);
+    const request = buildEffectiveStepRequest(requestStep, context, selectedOptions, selectedState);
     if (!request.ok && "creativeAssetFailure" in request) {
       return { target, failure: request.creativeAssetFailure };
     }
@@ -4679,7 +5153,7 @@ function lowerCaseHeaders(headers) {
   return out;
 }
 function resolveAdvertisedTools(options) {
-  return options.agentTools ?? normalizeAgentToolNames(options._profile?.tools);
+  return options.agentTools ?? (0, import_agent_routing.normalizeAgentToolNames)(options._profile?.tools);
 }
 function rateLimitTripObservationToProbeResult(agentUrl, observation) {
   if (observation.status === "not_applicable") {
@@ -4912,23 +5386,6 @@ function phaseUsesRuntimeContext(phase) {
   const expr = phase.skip_if?.trim();
   return expr ? (0, import_phase_condition.phaseConditionUsesContext)(expr) : false;
 }
-function resolveTaskName(step, options) {
-  if (!step.task.startsWith("$test_kit.")) return step.task;
-  const path = step.task.slice("$test_kit.".length).split(".");
-  let value = options.test_kit;
-  for (const segment of path) {
-    if (value == null || typeof value !== "object") {
-      value = void 0;
-      break;
-    }
-    value = value[segment];
-  }
-  const configured = typeof value === "string" && value.length > 0 ? value : step.task_default;
-  if (step.task === "$test_kit.auth.probe_task") {
-    return (0, import_test_kit.selectProbeTask)(configured, options.agentTools);
-  }
-  return configured;
-}
 function defaultAuthHeadersForRawProbe(options) {
   const headers = {};
   if (options.auth) {
@@ -4952,6 +5409,354 @@ function defaultAuthHeadersForRawProbe(options) {
   }
   return headers;
 }
+function sessionProbeRoutingHeaders(options) {
+  const headers = {};
+  for (const [name, value] of Object.entries(options.headers ?? {})) {
+    if (!SESSION_PROBE_ROUTING_HEADERS.has(name.toLowerCase())) continue;
+    try {
+      assertSafeAuthHeaderPart(value, `options.headers.${name}`);
+    } catch {
+      continue;
+    }
+    headers[name] = value;
+  }
+  setHeaderIfAbsent(headers, "X-Test-Session-ID", options.test_session_id, "options.test_session_id");
+  setHeaderIfAbsent(headers, "User-Agent", options.userAgent, "options.userAgent");
+  return headers;
+}
+function setHeaderIfAbsent(headers, name, value, label) {
+  if (!value) return;
+  const lower = name.toLowerCase();
+  if (Object.keys(headers).some((existing) => existing.toLowerCase() === lower)) return;
+  try {
+    assertSafeAuthHeaderPart(value, label);
+  } catch {
+    return;
+  }
+  headers[name] = value;
+}
+function runCredentialValues(options) {
+  const values = [];
+  const auth = options.auth;
+  if (auth?.type === "bearer" && typeof auth.token === "string") values.push(auth.token);
+  if (auth?.type === "basic") {
+    if (typeof auth.password === "string") values.push(auth.password);
+    if (typeof auth.username === "string" && typeof auth.password === "string") {
+      values.push(`${auth.username}:${auth.password}`);
+    }
+  }
+  if (auth?.type === "oauth" || auth?.type === "oauth_client_credentials") {
+    const token = auth.tokens?.access_token;
+    if (typeof token === "string") values.push(token);
+  }
+  const kit = options.test_kit?.auth;
+  if (typeof kit?.api_key === "string") values.push(kit.api_key);
+  const basic = kit?.basic;
+  if (typeof basic?.password === "string") values.push(basic.password);
+  if (typeof basic?.username === "string" && typeof basic?.password === "string") {
+    values.push(`${basic.username}:${basic.password}`);
+  }
+  if (typeof basic?.credentials === "string") values.push(basic.credentials);
+  for (const [name, value] of Object.entries(options.headers ?? {})) {
+    if (typeof value !== "string" || value.length === 0) continue;
+    if (AUTH_OVERRIDE_HEADER_NAMES.has(name.toLowerCase()) || isCredentialHeaderName(name)) values.push(value);
+  }
+  return values.filter((value) => value.trim().length > 0);
+}
+const SESSION_PROBE_ROUTING_HEADERS = /* @__PURE__ */ new Set([
+  "x-tenant-id",
+  "x-tenant",
+  "x-account",
+  "x-account-id",
+  "x-routing-key",
+  "x-partition-key",
+  "x-region",
+  "x-environment",
+  "x-request-id",
+  "x-correlation-id",
+  "x-idempotency-key",
+  "x-test-session-id",
+  "user-agent",
+  "accept-language"
+]);
+function unroutableProbeHeader(options) {
+  const runSecrets = runCredentialValues(options);
+  for (const [name, value] of Object.entries(options.headers ?? {})) {
+    const lower = name.toLowerCase();
+    if (SESSION_PROBE_ROUTING_HEADERS.has(lower)) {
+      try {
+        assertSafeAuthHeaderPart(value, `options.headers.${name}`);
+      } catch {
+        return name;
+      }
+      continue;
+    }
+    if (AUTH_OVERRIDE_HEADER_NAMES.has(lower)) continue;
+    if (runSecrets.some((secret) => value.includes(secret))) continue;
+    return name;
+  }
+  return void 0;
+}
+function effectiveOAuthAccessToken(client, options, agentUrl) {
+  const live = liveAgentOAuthAccessToken(client, agentUrl);
+  if (live !== void 0) return live;
+  const auth = options.auth;
+  if (auth?.type !== "oauth" && auth?.type !== "oauth_client_credentials") return void 0;
+  const configured = auth.tokens?.access_token;
+  return typeof configured === "string" && configured.length > 0 ? configured : void 0;
+}
+function liveAgentOAuthAccessToken(client, agentUrl) {
+  try {
+    const resolved = client?.getAgent?.(TEST_CLIENT_AGENT_ID);
+    if (resolved == null) return void 0;
+    const candidates = [resolved];
+    if (typeof resolved.getAgent === "function") candidates.push(resolved.getAgent());
+    for (const candidate of candidates) {
+      const token = candidate?.oauth_tokens?.access_token;
+      if (typeof token !== "string" || token.length === 0) continue;
+      const configuredUri = candidate?.agent_uri;
+      if (agentUrl !== void 0 && typeof configuredUri === "string" && configuredUri !== agentUrl) continue;
+      if (agentUrl !== void 0 && typeof configuredUri !== "string") continue;
+      return token;
+    }
+  } catch {
+  }
+  return void 0;
+}
+const TEST_CLIENT_AGENT_ID = "test";
+function withMcpBearerParity(headers) {
+  const authorization = headers.authorization;
+  if (authorization === void 0 || !authorization.startsWith("Bearer ")) return headers;
+  const token = authorization.slice("Bearer ".length);
+  if (token.length === 0) return headers;
+  return { ...headers, "x-adcp-auth": token };
+}
+function oauthAccessTokenHeaders(options, client, agentUrl) {
+  const token = effectiveOAuthAccessToken(client, options, agentUrl);
+  if (token === void 0) return void 0;
+  try {
+    assertSafeAuthHeaderPart(token, "options.auth.tokens.access_token");
+  } catch {
+    return void 0;
+  }
+  return { authorization: `Bearer ${token}` };
+}
+function staticCredentialHeaders(directive, options) {
+  try {
+    const headers = authHeadersForStep(directive, options);
+    return headers.authorization !== void 0 ? { authorization: headers.authorization } : void 0;
+  } catch {
+  }
+  return void 0;
+}
+function sessionControlCredentials(mechanism, options, client, agentUrl) {
+  const oauth = oauthAccessTokenHeaders(options, client, agentUrl);
+  const bearer = options.auth?.type === "bearer" ? staticCredentialHeaders({ type: "api_key", value: options.auth.token }, options) : void 0;
+  const basicFromOptions = options.auth?.type === "basic" ? staticCredentialHeaders(
+    { type: "basic", username: options.auth.username, password: options.auth.password },
+    options
+  ) : void 0;
+  const kitApiKey = typeof options.test_kit?.auth?.api_key === "string" && options.test_kit.auth.api_key.length > 0 ? staticCredentialHeaders({ type: "api_key", from_test_kit: true }, options) : void 0;
+  const kitBasic = options.test_kit?.auth?.basic !== void 0 ? staticCredentialHeaders({ type: "basic", from_test_kit: true }, options) : void 0;
+  switch (mechanism) {
+    case "oauth_bearer": {
+      if (oauth) return { headers: oauth };
+      return {
+        unavailable: {
+          reason: `this run holds no OAuth access token, and a static API key or Basic credential is not evidence about the OAuth path at all \u2014 accepting a shared secret says nothing about whether tokens from the issuer advertised in your protected-resource metadata are what gates this resource`,
+          remedy: `Run the storyboard with OAuth so the runner holds a token minted by that issuer (\`adcp --save-auth <alias> <url> --oauth\`, or pass \`--oauth\` to \`storyboard run\`).`
+        }
+      };
+    }
+    case "api_key": {
+      const headers = bearer ?? kitApiKey;
+      if (headers) return { headers };
+      return {
+        unavailable: {
+          reason: `this run holds no valid API key to prove the endpoint accepts one`,
+          remedy: "Declare `auth.api_key` in the test kit, or pass a bearer `options.auth` (CLI: `--auth`)."
+        }
+      };
+    }
+    case "basic": {
+      const headers = basicFromOptions ?? kitBasic;
+      if (headers) return { headers };
+      return {
+        unavailable: {
+          reason: `this run holds no valid Basic credential to prove the endpoint accepts one`,
+          remedy: "Declare `auth.basic` in the test kit, or pass a basic `options.auth`."
+        }
+      };
+    }
+    case "any": {
+      const headers = oauth ?? bearer ?? basicFromOptions ?? kitApiKey ?? kitBasic;
+      if (headers) return { headers };
+      return {
+        unavailable: {
+          reason: `this run holds no valid credential, so a rejection cannot be told apart from an endpoint that refuses every request`,
+          remedy: "Declare `auth.api_key` or `auth.basic` in the test kit, pass `options.auth`, or run with `--oauth`."
+        }
+      };
+    }
+  }
+}
+function summarizeAdvertisedTools(tools) {
+  const names = (tools ?? []).slice(0, 20).map((name) => escapeControlChars(name.slice(0, 64)));
+  const overflow = (tools?.length ?? 0) - names.length;
+  return overflow > 0 ? `${names.join(", ")}, \u2026${overflow} more` : names.join(", ");
+}
+function escapeControlChars(value) {
+  return value.replace(
+    /[\u0000-\u001f\u007f-\u009f]/g,
+    (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`
+  );
+}
+const SESSION_PROBE_PUBLIC_TIER = /* @__PURE__ */ new Set([
+  "get_adcp_capabilities",
+  "get_products",
+  "list_products",
+  "list_creative_formats"
+]);
+const CANONICAL_ADCP_TOOLS = /* @__PURE__ */ new Set([
+  ...import_capabilities.MEDIA_BUY_TOOLS,
+  ...import_capabilities.CREATIVE_TOOLS,
+  ...import_capabilities.SIGNALS_TOOLS,
+  ...import_capabilities.GOVERNANCE_TOOLS,
+  ...import_capabilities.ACCOUNT_TOOLS,
+  ...import_capabilities.BRAND_RIGHTS_TOOLS,
+  ...import_capabilities.PROTOCOL_TOOLS,
+  ...import_capabilities.EVENT_TRACKING_TOOLS
+]);
+const PREFERRED_PROBE_TARGET = "get_principal";
+function hasNoRequiredRequestFields(tool) {
+  const schema = import_tool_request_schemas.TOOL_REQUEST_SCHEMAS[tool];
+  const shape = schema?.shape;
+  if (!shape) return false;
+  return !Object.values(shape).some((field) => {
+    const candidate = field;
+    if (typeof candidate?.safeParse !== "function") return false;
+    return !candidate.safeParse(void 0).success;
+  });
+}
+function protectedToolCandidates(tools) {
+  if (!tools) return [];
+  const advertised = new Set(tools);
+  const eligible = (tool) => advertised.has(tool) && !SESSION_PROBE_PUBLIC_TIER.has(tool) && !import_idempotency2.MUTATING_TASKS.has(tool);
+  const allowlisted = import_test_kit.PROBE_TASK_ALLOWLIST.filter(eligible);
+  const canonicalReads = [...CANONICAL_ADCP_TOOLS].filter((tool) => /^(list|get)_/.test(tool)).filter((tool) => !allowlisted.includes(tool)).filter(eligible).filter(hasNoRequiredRequestFields).sort((a, b) => {
+    if (a === PREFERRED_PROBE_TARGET) return -1;
+    if (b === PREFERRED_PROBE_TARGET) return 1;
+    return a.localeCompare(b);
+  });
+  return [...allowlisted, ...canonicalReads];
+}
+function signatureBoundTools(options) {
+  if (options.functional_request_signing === void 0) return /* @__PURE__ */ new Set();
+  const raw = options._profile?.raw_capabilities;
+  if (raw === null || typeof raw !== "object") return "unparseable";
+  const advertised = raw.request_signing;
+  if (advertised === void 0) return /* @__PURE__ */ new Set();
+  if (advertised === null || typeof advertised !== "object") return "unparseable";
+  const buckets = advertised;
+  const bound = /* @__PURE__ */ new Set();
+  for (const bucket of [buckets.required_for, buckets.supported_for]) {
+    if (bucket === void 0) continue;
+    if (!Array.isArray(bucket) || bucket.some((entry) => typeof entry !== "string")) return "unparseable";
+    for (const entry of bucket) bound.add(entry);
+  }
+  return bound;
+}
+function selectProtectedToolTarget(tools) {
+  return protectedToolCandidates(tools)[0];
+}
+function sessionControlMechanismFor(auth) {
+  if (auth === "none") return "any";
+  switch (auth.type) {
+    case "oauth_bearer":
+      return "oauth_bearer";
+    case "basic":
+      return "basic";
+    case "api_key":
+      return "api_key";
+  }
+}
+function planMcpSessionSentinel(step, options, client, agentUrl) {
+  if (options.protocol !== "mcp") {
+    const declared = options.protocol === void 0 ? "no transport" : `"${options.protocol}"`;
+    return {
+      kind: "error",
+      error: `"${import_types.MCP_SESSION_PROBE_TASK}" is an MCP session probe and requires an explicit \`protocol: 'mcp'\` on the run; this run declared ${declared}. A2A has no equivalent parameter-free protected operation, so the runner refuses to substitute one.`
+    };
+  }
+  if (step.auth === void 0) {
+    return {
+      kind: "skip",
+      reason: "session_probe_ungradable",
+      detail: (0, import_oauth_metadata_graph.redactOAuthUrlsInText)(
+        `Agent advertises no auth-required, read-only AdCP tool that accepts an empty request body, so the runner fell back to the MCP "${import_types.MCP_SESSION_PROBE_TASK}" session probe. That probe cannot grade a positive static-credential step: its validations assert an AdCP task response body, which no MCP protocol operation produces, so this mechanism's branch cannot contribute auth_mechanism_verified. Remedy: advertise one allowlisted read tool (${import_test_kit.PROBE_TASK_ALLOWLIST_SUMMARY}), or serve RFC 9728 metadata and run with OAuth so the OAuth branch can be verified instead. Advertised tools: [${summarizeAdvertisedTools(options.agentTools)}].`
+      )
+    };
+  }
+  const signatureBound = signatureBoundTools(options);
+  const candidates = protectedToolCandidates(options.agentTools);
+  if (signatureBound === "unparseable") {
+    return {
+      kind: "skip",
+      reason: "session_probe_ungradable",
+      detail: `This run signs functional dispatch (RFC 9421), but the runner could not read which operations your \`request_signing\` capability covers, so it cannot tell whether the session probe's unsigned call would be refused for the signature rather than the credential. Refusing to grade instead of guessing. Remedy: advertise \`request_signing.required_for\` / \`supported_for\` as string arrays, or advertise one allowlisted read tool (${import_test_kit.PROBE_TASK_ALLOWLIST_SUMMARY}) so the probe has a protocol-vouched target.`
+    };
+  }
+  const toolNames = candidates.filter((tool) => !signatureBound.has(tool));
+  if (toolNames.length === 0 && candidates.length > 0) {
+    return {
+      kind: "skip",
+      reason: "session_probe_ungradable",
+      detail: (0, import_oauth_metadata_graph.redactOAuthUrlsInText)(
+        `Every protected read the probe could call (${candidates.join(", ")}) is covered by this agent's \`request_signing\` advertisement, and the session probe mints no RFC 9421 signatures. An unsigned call would be refused for the missing signature, which is not evidence about the credential, so the runner refuses to grade it. Remedy: advertise one allowlisted read tool (${import_test_kit.PROBE_TASK_ALLOWLIST_SUMMARY}) outside \`request_signing.required_for\`/\`supported_for\`, or run with OAuth against RFC 9728 metadata so the OAuth branch can be verified instead.`
+      )
+    };
+  }
+  if (toolNames.length === 0) {
+    return {
+      kind: "skip",
+      reason: "session_probe_ungradable",
+      detail: (0, import_oauth_metadata_graph.redactOAuthUrlsInText)(
+        `Agent advertises no auth-required, read-only AdCP tool the probe can call with an empty request body, so there is no protected operation to grade. MCP discovery (\`tools/list\`) is not a protected task and public-tier tools (${[...SESSION_PROBE_PUBLIC_TIER].join(", ")}) are served unauthenticated by design. Remedy: advertise one allowlisted read tool (${import_test_kit.PROBE_TASK_ALLOWLIST_SUMMARY}). Advertised tools: [${summarizeAdvertisedTools(options.agentTools)}].`
+      )
+    };
+  }
+  const unroutable = unroutableProbeHeader(options);
+  if (unroutable !== void 0) {
+    return {
+      kind: "skip",
+      reason: "session_probe_ungradable",
+      detail: `The runner cannot classify run header "${escapeControlChars(unroutable.slice(0, 64))}", and both answers are unsafe \u2014 forwarding it could make the unauthenticated probe authenticated, dropping it could send the probe to a different tenant than the rest of this run. Nothing was graded, and this is a property of the run, not of the agent. Three ways forward: rename it to a recognised routing header (${[...SESSION_PROBE_ROUTING_HEADERS].join(", ")}); drop it from this run if the probe does not need it; or, if it carries a credential, move that into \`options.auth\` / \`test_kit.auth\` where the runner owns it.`
+    };
+  }
+  const routing = sessionProbeRoutingHeaders(options);
+  let headers;
+  try {
+    headers = { ...routing, ...withMcpBearerParity(authHeadersForStep(step.auth, options)) };
+  } catch (err) {
+    return {
+      kind: "error",
+      error: `Step auth configuration error: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const control = sessionControlCredentials(sessionControlMechanismFor(step.auth), options, client, agentUrl);
+  if ("unavailable" in control) {
+    return { kind: "probe", headers, toolNames, control: { kind: "unavailable", ...control.unavailable } };
+  }
+  if (headers.authorization !== void 0 && control.headers.authorization === headers.authorization) {
+    return { kind: "probe", headers, toolNames, control: { kind: "probe_is_valid_credential" } };
+  }
+  return {
+    kind: "probe",
+    headers,
+    toolNames,
+    control: { kind: "credential", headers: { ...routing, ...withMcpBearerParity(control.headers) } }
+  };
+}
 function authHeadersForStep(directive, options) {
   if (directive === "none") return {};
   if (directive.type === "basic") return basicAuthHeadersForStep(directive, options);
@@ -5359,7 +6164,8 @@ function createRoutingDispatcher(ctx, options, agents) {
   const keyToIndex = new Map(keyOrder.map((k, i) => [k, i]));
   return {
     nextFor(step) {
-      const key = (0, import_agent_routing.resolveAgentForStep)(step, options, ctx);
+      const task = (0, import_agent_routing.resolveTaskName)(step, { ...options, agentTools: void 0 });
+      const key = (0, import_agent_routing.resolveAgentForStep)(task ? { ...step, task } : step, options, ctx);
       const client = ctx.clients.get(key);
       const profile = ctx.profiles.get(key);
       const url = agents[key]?.url;
@@ -5370,11 +6176,21 @@ function createRoutingDispatcher(ctx, options, agents) {
           `key ${key} unbound`
         );
       }
+      if (!profile) {
+        const failure = ctx.discoveryFailures.find((failure2) => failure2.agentKey === key);
+        throw new import_agent_routing.RoutingError(
+          `Agent "${key}" has no discovered profile; its task contract cannot be established.` + (failure ? ` Discovery failed: ${failure.underlying}. Fix the agent or select a healthy route.` : ""),
+          step.task,
+          `agent "${key}" failed discovery`
+        );
+      }
       return {
         client,
         agentUrl: url,
+        agentKey: key,
         instanceIndex: keyToIndex.get(key) ?? 0,
-        profile
+        profile,
+        options: (0, import_agent_routing.routedAgentOptions)(agents[key], options, profile)
       };
     }
   };
@@ -5455,7 +6271,10 @@ function getFirstStepPreview(storyboard, context = {}) {
 0 && (module.exports = {
   __defaultAuthHeadersForRawProbeForTest,
   __filterResponseHeadersForTest,
+  __protectedToolCandidatesForTest,
   __redactSecretsForTest,
+  __selectProtectedToolTargetForTest,
+  __sessionControlCredentialsForTest,
   applyAdcpVersionRunOptions,
   applyBrandInvariant,
   applyDisableSandboxHint,
@@ -5469,5 +6288,8 @@ function getFirstStepPreview(storyboard, context = {}) {
   resolveCapabilityPath,
   runStoryboard,
   runStoryboardStep,
+  signingCoverage,
+  signingCoverageUnverified,
+  storyboardCapabilityPredicates,
   summarizeStrictValidation
 });