@adcp/sdk 9.4.0 → 9.6.0

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

@@ -1920,6 +1920,10 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
     // default `depends_on` resolution ("all prior phases") doesn't re-scan
     // the storyboard. Phases push their own id at end-of-phase.
     const priorPhaseIds = [];
+    // Phase → branch-set membership, resolved once up front so the stateful
+    // cascade (and the post-loop branch-set re-grade) can consult it. Phases
+    // outside any branch set are absent from the map.
+    const branchSetsByPhaseId = resolveBranchSets(storyboard);
     // Helpers for per-phase cascade state.
     const effectiveDependsOn = (phase, prior) => phase.depends_on ?? prior;
     const cascadeForPhase = (phase, prior) => {
@@ -1928,7 +1932,26 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
         if (phaseStatefulCascades.has(phase.id)) {
             return { tripped: true, trigger: phaseStatefulCascades.get(phase.id) ?? null };
         }
+        // Branch-set peers under `any_of` are mutually-exclusive ALTERNATIVES, not
+        // a stateful dependency chain: a conformant seller satisfies exactly one
+        // peer, so the non-taken peer(s) fail by design (storyboard-schema.yaml,
+        // "Per-step grading in any_of branch patterns"). A peer's expected
+        // failure must NOT cascade-skip a sibling peer — doing so suppresses the
+        // only viable contribution and fails the any_of gate even though the
+        // seller behaved conformantly. Exclude same-branch-set peers from this
+        // phase's cascade dependencies. (adcontextprotocol/adcp-client#2305)
+        //
+        // Scoped to `any_of` deliberately: `BranchSetSpec.semantics` is typed
+        // `string` to leave room for future semantics (e.g. `all_of`/`one_of`)
+        // where peers legitimately DO depend on each other and must keep
+        // cascading. `all_of` is rejected at load time today, so this is
+        // forward-compat hardening rather than live behavior.
+        const ownSpec = branchSetsByPhaseId.get(phase.id);
+        const ownAnyOfBranchSet = ownSpec?.semantics === 'any_of' ? ownSpec.id : undefined;
         for (const depId of effectiveDependsOn(phase, prior)) {
+            if (ownAnyOfBranchSet !== undefined && branchSetsByPhaseId.get(depId)?.id === ownAnyOfBranchSet) {
+                continue;
+            }
             if (phaseStatefulCascades.has(depId)) {
                 return { tripped: true, trigger: phaseStatefulCascades.get(depId) ?? null };
             }
@@ -2775,8 +2798,9 @@ async function executeStoryboardPass(agentUrls, storyboard, options, dispatchOff
     // contribution status isn't knowable inside the per-phase loop. Runs
     // before storyboard-scoped assertions so `onEnd` hooks see the finalized
     // per-step grades (a moot peer's "failure" should not trip a cross-step
-    // invariant).
-    const branchSetsByPhaseId = resolveBranchSets(storyboard);
+    // invariant). `branchSetsByPhaseId` was resolved before the phase loop so
+    // the stateful cascade could consult it (branch-set peers don't cascade
+    // onto each other); reuse it here.
     const branchSetDelta = applyBranchSetGrading(storyboard.phases, phaseResults, branchSetsByPhaseId, contributions, contributionSources, countedAsFailed);
     skippedCount += branchSetDelta.skippedDelta;
     // Fire storyboard-scoped assertions. These observe the full run and can
@@ -3303,12 +3327,14 @@ client, step, storyboardId, phaseId, context, allSteps, options, state) {
             extraction: { path: 'none' },
         };
     }
-    // Account-mode capability gate: sync_accounts is exclusive to implicit mode
-    // (require_operator_auth: false). When the seller declared explicit mode
-    // (require_operator_auth: true), sync_accounts does not apply — grade
-    // not_applicable rather than missing_tool so adopters can distinguish
-    // "your capability declaration says this path isn't yours" from "you forgot
-    // to implement a required tool."
+    // Account-mode capability gate: when the seller declared explicit mode
+    // (require_operator_auth: true) and does not advertise sync_accounts,
+    // sync_accounts does not apply — grade not_applicable rather than
+    // missing_tool so adopters can distinguish "your capability declaration
+    // says this path isn't yours" from "you forgot to implement a required
+    // tool." If the seller explicitly advertises sync_accounts, run it: account
+    // discovery mode and account-level write surfaces such as notification
+    // config registration are orthogonal.
     //
     // list_accounts is NOT gated here: it appears in audience_sync and other
     // storyboard flows regardless of account mode, so it is always applicable.
@@ -3319,7 +3345,8 @@ client, step, storyboardId, phaseId, context, allSteps, options, state) {
         const rawCaps = options._profile?.raw_capabilities;
         if (rawCaps !== undefined) {
             const requireOperatorAuth = resolveCapabilityPath(rawCaps, 'account.require_operator_auth');
-            if (requireOperatorAuth === true) {
+            const syncAccountsAdvertised = options.agentTools?.includes('sync_accounts') === true;
+            if (requireOperatorAuth === true && !syncAccountsAdvertised) {
                 const detail = `Agent declared explicit account mode (require_operator_auth: true); ` +
                     `sync_accounts is not applicable — list_accounts is the correct tool for this account shape.`;
                 const next = getNextStepPreview(step.id, allSteps, context, runState.runnerVars);