Merge remote-tracking branch 'origin/main' into rlundeen2-cleanup-initializers

# Conflicts:
#	pyrit/scenario/core/scenario.py
#	pyrit/scenario/scenarios/adaptive/adaptive_scenario.py
#	pyrit/scenario/scenarios/adaptive/text_adaptive.py
#	tests/unit/scenario/airt/test_cyber.py
#	tests/unit/scenario/airt/test_rapid_response.py
#	tests/unit/scenario/core/test_baseline_deprecation.py

Author: rlundeen2

.github/instructions/scenarios.instructions.md

@@ -39,9 +39,9 @@ For scenarios whose strategy enum is built dynamically (RapidResponse pattern),
 strategy class in a module-level `@cache`-decorated function and pass the result through
 the constructor — no classmethod indirection required.
 
-4. **Optionally override `_get_atomic_attacks_async()`** — the base class provides a default
-   that uses the factory/registry pattern (see "AtomicAttack Construction" below).
-   Only override if your scenario needs custom attack construction logic.
+4. **Implement `_build_atomic_attacks_async(self, *, context)`** — this is the single
+   abstract extension point every scenario must define (see "AtomicAttack Construction" below).
+   Matrix-shaped scenarios delegate to `build_matrix_atomic_attacks(context=...)` in one line.
 
 ## Constructor Pattern
 
@@ -58,7 +58,7 @@ def __init__(
     if not objective_scorer:
         objective_scorer = self._get_default_scorer()
 
-    # 2. Store config objects for _get_atomic_attacks_async
+    # 2. Store config objects for _build_atomic_attacks_async
     self._scorer_config = AttackScoringConfig(objective_scorer=objective_scorer)
 
     # 3. Call super().__init__ — required args: version, strategy_class, objective_scorer
@@ -80,7 +80,7 @@ Requirements:
   may opt into a one-release grace period via the class attribute
   `_brick_legacy_init = True`, which downgrades the error to a
   `DeprecationWarning(removed_in="0.16.0")`. The opt-out is removed in 0.16.0.
-- **All constructor parameters must be optional** (default to `None`) so the registry can instantiate the scenario with no arguments for metadata introspection. Defer required-input validation to `initialize_async()` or `_get_atomic_attacks_async()`. `ScenarioRegistry._build_metadata` raises `TypeError` if `scenario_class()` cannot be called with no arguments.
+- **All constructor parameters must be optional** (default to `None`) so the registry can instantiate the scenario with no arguments for metadata introspection. Defer required-input validation to `initialize_async()` or `_build_atomic_attacks_async()`. `ScenarioRegistry._build_metadata` raises `TypeError` if `scenario_class()` cannot be called with no arguments.
 - `super().__init__()` called with `version`, `strategy_class`, `default_strategy`, `default_dataset_config`, `objective_scorer`
 - complex objects like `adversarial_chat` or `objective_scorer` should be passed into the constructor.
 
@@ -134,39 +134,70 @@ class MyStrategy(ScenarioStrategy):
 - Each member: `NAME = ("string_value", {tag_set})`
 - Aggregates expand to all strategies matching their tag
 
-### `_build_display_group()` — Result Grouping
+### Result grouping (`display_group`)
 
-Override `_build_display_group()` on the `Scenario` base class to control how attack results are grouped for display:
+`display_group` controls how attack results are aggregated for display. It is set per
+`AtomicAttack` at construction time — there is no `_build_display_group` hook. When you build
+via `build_matrix_atomic_attacks`/`MatrixAtomicAttackBuilder`, pass a `display_group_fn`
+callback that maps each `MatrixCombo` to a group string:
 
 ```python
-def _build_display_group(self, *, technique_name: str, seed_group_name: str) -> str:
-    # Default: group by technique name (most common)
-    return technique_name
-
-    # Override examples:
-    # Group by dataset/harm category: return seed_group_name
-    # Cross-product: return f"{technique_name}_{seed_group_name}"
+build_matrix_atomic_attacks(
+    context=context,
+    objective_scorer=self._objective_scorer,
+    display_group_fn=lambda combo: combo.technique_name,  # default: group by technique
+    # Group by dataset/harm category: lambda combo: combo.dataset_name
+    # Cross-product:                   lambda combo: f"{combo.technique_name}_{combo.dataset_name}"
+)
 ```
 
 Note: `atomic_attack_name` must remain unique per `AtomicAttack` for correct resume behaviour.
 `display_group` controls user-facing aggregation only.
 
-## AtomicAttack Construction — Default Base Class Behaviour
+## AtomicAttack Construction — `_build_atomic_attacks_async(context)`
+
+Every scenario implements the single abstract extension point:
+
+```python
+async def _build_atomic_attacks_async(self, *, context: ScenarioContext) -> list[AtomicAttack]:
+    ...
+```
+
+`initialize_async` resolves the run's inputs once (objective target, strategies, dataset
+config, memory labels, baseline flag, and seed groups), snapshots them into an immutable
+`ScenarioContext`, calls this method, and then inserts the baseline centrally. Scenario authors
+never read half-initialized `self._*` state to build attacks — read everything from `context`.
 
-The `Scenario` base class provides a default `_get_atomic_attacks_async()` that uses the
-factory/registry pattern.  Scenarios that register their techniques via `_get_attack_technique_factories()`
-get atomic-attack construction **for free** — no override needed.
+### Zero-boilerplate matrix scenarios
 
-The default implementation:
-1. Calls `self._get_attack_technique_factories()` to get name→factory mapping
-   (defaults to reading every `AttackTechniqueFactory` registered in the
-   `AttackTechniqueRegistry` singleton)
-2. Iterates over every (technique × dataset) pair from `self._dataset_config`
-3. Calls `factory.create()` with `objective_target` and conditional scorer override
-   (also forwards any per-technique converters from `self._strategy_converters`, populated
-   from the CLI `--strategies <technique>:converter.<name>` modifier, as `extra_request_converters`)
-4. Uses `self._build_display_group()` for user-facing grouping
-5. Builds `AtomicAttack` with unique `atomic_attack_name` = `"{technique}_{dataset}"`
+Scenarios whose construction is the plain technique × dataset cross-product delegate to the
+`build_matrix_atomic_attacks` helper in one line (see `Cyber`, `RapidResponse`):
+
+```python
+from pyrit.scenario.core.matrix_atomic_attack_builder import build_matrix_atomic_attacks
+
+async def _build_atomic_attacks_async(self, *, context: ScenarioContext) -> list[AtomicAttack]:
+    return build_matrix_atomic_attacks(
+        context=context,
+        objective_scorer=self._objective_scorer,
+        strategy_converters=self._strategy_converters,  # optional CLI converter stacks
+    )
+```
+
+`build_matrix_atomic_attacks`:
+1. Calls `resolve_technique_factories(context=context)` to map the selected strategies to their
+   registered `AttackTechniqueFactory` instances (reads the `AttackTechniqueRegistry` singleton;
+   strategies with no registered factory are dropped).
+2. Iterates every (technique × dataset) pair from `context.seed_groups_by_dataset`.
+3. Calls `factory.create()` with the objective target, conditional scorer override, and any
+   per-technique converters (from `--strategies <technique>:converter.<name>`) as
+   `extra_request_converters`.
+4. Builds each `AtomicAttack` with a unique `atomic_attack_name` and a `display_group`
+   (customizable via `display_group_fn`).
+
+Scenarios needing extra axes (adversarial targets, caching, converter stacks) call
+`MatrixAtomicAttackBuilder` directly; scenarios whose construction is composite or
+per-objective build the `AtomicAttack` list themselves (see "Manual AtomicAttack construction").
 
 ### AttackTechniqueFactory
 
@@ -213,29 +244,28 @@ by the registry. Tests that exercise scenarios should reset both `AttackTechniqu
 and `TargetRegistry` and re-register a mock `adversarial_chat` so the catalog builder
 resolves without falling back to `OpenAIChatTarget`.
 
-### Customization hooks (no need to override `_get_atomic_attacks_async`):
-- **`_get_attack_technique_factories()`** — override to add/remove/replace factories
-- **`_build_display_group()`** — override to change grouping (default: by technique)
-
-### When to override `_get_atomic_attacks_async`:
-Only override when the scenario **cannot** use the factory/registry pattern — e.g., scenarios
-with custom composite logic, per-strategy converter stacks, or non-standard attack construction.
+### Baseline
 
-Overrides that want baseline support must emit it themselves by calling `self._build_baseline_atomic_attack(seed_groups=...)` with the same seeds used for the strategy attacks and prepending the result. The base implementation emits baseline automatically; passing freshly resolved seeds reintroduces ADO 9012 (baseline-vs-strategy population divergence under `max_dataset_size`).
+The baseline (a `PromptSendingAttack` over the run's seeds) is inserted **centrally** by
+`Scenario.initialize_async` according to the scenario's `BASELINE_ATTACK_POLICY` class var and
+the runtime `include_baseline` flag. `_build_atomic_attacks_async` must **never** prepend its own
+baseline — doing so double-emits it and reintroduces baseline-vs-strategy population divergence
+under `max_dataset_size`.
 
-### Manual AtomicAttack construction (for overrides):
+### Manual AtomicAttack construction:
 
 ```python
 AtomicAttack(
-    atomic_attack_name=strategy_name,   # groups related attacks
+    atomic_attack_name=strategy_name,   # must be unique per AtomicAttack
     attack=attack_instance,             # AttackStrategy implementation
     seed_groups=list(seed_groups),       # must be non-empty
-    memory_labels=self._memory_labels,   # from base class
+    memory_labels=context.memory_labels, # from the context snapshot
 )
 ```
 
 - `seed_groups` must be non-empty — validate before constructing
-- `self._objective_target` is only available after `initialize_async()` — don't access in `__init__`
+- Read runtime inputs from `context`, not `self._*` — `self._objective_target` and
+  `self._scenario_strategies` are only populated after `initialize_async()`
 - Pass `memory_labels` to every AtomicAttack
 
 ## Exports
@@ -248,4 +278,4 @@ New scenarios must be registered in `pyrit/scenario/__init__.py` as virtual pack
 - Forgetting `@apply_defaults` on `__init__`
 - Empty `seed_groups` passed to `AtomicAttack`
 - Missing `VERSION` class constant
-- Missing `_async` suffix on `_get_atomic_attacks_async`
+- Missing `_async` suffix on `_build_atomic_attacks_async`

doc/code/executor/0_executor.md

@@ -44,6 +44,9 @@ as it goes.
 - **[Prompt Generator](7_promptgen.ipynb)** — produces attack prompts (e.g. fuzzing, Anecdoctor) to
   augment datasets; some generate from a model alone, others probe a target to evolve effective
   prompts.
+- **[Modality Feedback](8_modality_feedback.ipynb)** — shows how `TargetCapabilities` determine
+  whether media is forwarded between objective and adversarial targets in multi-turn attacks, with a
+  two-seed Crescendo image-edit example.
 
 **[Attack Configuration](3_attack_configuration.ipynb)** isn't an executor — it's the cross-cutting
 inputs every attack accepts (objective vs. adversarial target, prepended conversations, multimodal