FIX: Aligning scenarios with technique registry

Drop the redundant `core`-tag gates from RapidResponse and
AdversarialBenchmark so scenarios expose whatever techniques the active
initializer has registered, rather than re-narrowing to `core`.

- rapid_response: remove `available=TagQuery.all('core')` — the pool is
  now every registered factory (matches the leakage pattern and the
  published blog, which lists the extra-only `pair` technique).
- benchmark: drop the `'core' in technique_tags` clause but keep the
  genuine capability filters (`uses_adversarial` and
  `adversarial_chat is None`), so extra adversarial techniques such as
  `pair`/`violent_durian` can participate in the model sweep.
- Update the benchmark test snapshot to mirror the production predicate.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: e0bc715e-cd3a-480c-afe8-5cac8339224f

Author: rlundeen2

pyrit/scenario/scenarios/airt/rapid_response.py

@@ -35,8 +35,9 @@ def _build_rapid_response_technique() -> type[ScenarioTechnique]:
     """
     Build the RapidResponse technique class dynamically from the registered factories.
 
-    Reads the singleton ``AttackTechniqueRegistry`` and filters to factories
-    tagged ``core``.
+    Reads every technique registered in the singleton ``AttackTechniqueRegistry``
+    and exposes all of them. Which techniques are available is decided by the
+    active initializer (the registration gate), not narrowed again here.
 
     Returns:
         type[ScenarioTechnique]: The dynamically generated technique enum class.
@@ -50,7 +51,6 @@ def _build_rapid_response_technique() -> type[ScenarioTechnique]:
     return AttackTechniqueRegistry.build_technique_class_from_factories(  # type: ignore[ty:invalid-return-type]
         class_name="RapidResponseTechnique",
         factories=factories,
-        available=TagQuery.all("core"),
         aggregate_tags={
             "single_turn": TagQuery.any_of("single_turn"),
             "multi_turn": TagQuery.any_of("multi_turn"),

pyrit/scenario/scenarios/benchmark/adversarial.py

@@ -35,12 +35,14 @@ def _build_benchmark_technique() -> type[ScenarioTechnique]:
     """
     Build the ``BenchmarkTechnique`` enum from the registered factory catalog.
 
-    Reads ``core`` adversarial-capable factories from the
+    Reads adversarial-capable factories from the
     ``AttackTechniqueRegistry`` singleton and passes them to
     ``build_technique_class_from_factories``. Factories that bake their own
     ``adversarial_chat`` are excluded — the benchmark sweeps each technique
     across the user-supplied targets, which is incompatible with a technique
-    that pins its own adversarial target. The resulting enum has one
+    that pins its own adversarial target. Which techniques are registered is
+    decided by the active initializer (the registration gate); this scenario
+    does not narrow the pool further by group. The resulting enum has one
     concrete member per factory (e.g. ``red_teaming``, ``tap``,
     ``crescendo_simulated``) plus ``default`` / ``light`` / ``single_turn``
     / ``multi_turn`` aggregates derived from each factory's ``technique_tags``.
@@ -56,7 +58,7 @@ def _build_benchmark_technique() -> type[ScenarioTechnique]:
     factories = [
         factory
         for factory in registry.get_factories_or_raise().values()
-        if factory.uses_adversarial and "core" in factory.technique_tags and factory.adversarial_chat is None
+        if factory.uses_adversarial and factory.adversarial_chat is None
     ]
     return AttackTechniqueRegistry.build_technique_class_from_factories(  # type: ignore[ty:invalid-return-type]
         class_name="BenchmarkTechnique",
@@ -82,7 +84,7 @@ class AdversarialBenchmark(Scenario):
 
     At run time, ``_build_atomic_attacks_async`` performs the
     ``(technique × adversarial_target × dataset)`` cross-product: for each
-    selected adversarial-capable ``core`` factory in the
+    selected adversarial-capable factory in the
     ``AttackTechniqueRegistry`` and each requested target, it calls
     ``factory.create(adversarial_chat=...)`` with the
     resolved target — no global registry mutation. The resulting

tests/unit/scenario/benchmark/test_adversarial.py

@@ -15,7 +15,7 @@
 These tests cover the new contract:
 * Class metadata (VERSION, BASELINE policy, defaults).
 * Technique enum is built from registered factories with ``uses_adversarial=True``
-  and the ``core`` technique tag; ``light`` aggregate preserves the
+  that do not bake their own ``adversarial_chat``; ``light`` aggregate preserves the
   source ``light`` tag (excludes ``tap`` / ``crescendo_simulated``).
 * ``supported_parameters`` declares ``adversarial_targets: list[str]``.
 * ``_resolve_adversarial_targets`` raises with available names on typos.
@@ -76,7 +76,7 @@ def _build_benchmarkable_factories_snapshot() -> list:
         factories = build_technique_factories()
     finally:
         TargetRegistry.reset_registry_singleton()
-    return [f for f in factories if f.uses_adversarial and "core" in f.technique_tags]
+    return [f for f in factories if f.uses_adversarial and f.adversarial_chat is None]
 
 
 _BENCHMARKABLE_FACTORIES = _build_benchmarkable_factories_snapshot()
@@ -202,7 +202,7 @@ class TestAdversarialBenchmarkTechnique:
     """Tests for ``_build_benchmark_technique`` using the registry-based factory API."""
 
     def test_technique_built_from_registered_adversarial_factories(self):
-        """Each registered ``core`` adversarial factory produces one concrete enum member."""
+        """Each registered adversarial factory produces one concrete enum member."""
         technique_cls = _build_benchmark_technique()
         aggregate_names = {"all"} | technique_cls.get_aggregate_tags()
         concrete_members = [m for m in technique_cls if m.value not in aggregate_names]