@@ -14,9 +14,12 @@
 # other OpenAI-compatible endpoint. See doc/setup/populating_secrets.md
 # for provider-specific examples.
 #
-# If you are using Entra authentication for Azure resources,
-# keys for those resources are not needed. PyRIT auto-detects: if an API key
-# is set, it uses key auth; otherwise it falls back to Entra ID automatically.
+# For Azure resources you can authenticate with Microsoft Entra ID instead of a
+# key. Make it an explicit choice: run `az login` and pass auth_mode="identity"
+# to the target, e.g. OpenAIChatTarget(endpoint=..., auth_mode="identity").
+# Leaving the key unset still selects Entra ID automatically, but that fallback
+# is deprecated and is removed in 1.4.0.
+# See doc/code/setup/1_configuration.ipynb for details.
 #
 # ============================================================================
 
 
@@ -92,7 +92,12 @@ scenario.set_params_from_args(args={"objective_target": target, "max_concurrency
 await scenario.initialize_async()
 ```
 
-The base `Scenario` declares the common run inputs once in `_common_scenario_parameters()`: `objective_target` (a `RegistryReference` — resolved by name or supplied as an instance), the `opaque` live objects `scenario_techniques` / `technique_converters` / `dataset_config` / `memory_labels` (passed by identity, never coerced or deep-copied), and the scalars `max_concurrency` / `max_retries` / `include_baseline`.
+The base `Scenario` declares the common run inputs once in `_common_scenario_parameters()`: `objective_target` (a `RegistryReference` — resolved by name or supplied as an instance), the `opaque` live objects `scenario_techniques` / `technique_converters` / `dataset_config` / `memory_labels` (passed by identity, never coerced or deep-copied), and the scalars `max_concurrency` / `max_retries` / `include_baseline` / `incompatible_technique_policy`.
+
+`incompatible_technique_policy` accepts `skip` (default) or `raise`; `None` uses
+`INCOMPATIBLE_TECHNIQUE_POLICY`. Forward `context.incompatible_technique_policy` to matrix
+builders and apply shared requirement helpers in manual builders. Skip only known incompatibility,
+with one summary per technique/dataset. Raise if no selected technique can run, even with a baseline.
 
 ### Declaring custom parameters — add via `additional_parameters`
 
@@ -273,6 +278,11 @@ config, memory labels, baseline flag, and seed groups), snapshots them into an i
 `_build_atomic_attacks_async` (see the Baseline section below). Scenario authors never read
 half-initialized `self._*` state to build attacks — read everything from `context`.
 
+On resume, `context.stored_run_plan` carries the original plan. Restore committed
+per-input technique choices from it instead of selecting again. The base restores
+the planned source population before builders check compatibility. Saved adaptive
+choices must identify the full technique, including its prompts, not only its inner attack.
+
 ### Zero-boilerplate matrix scenarios
 
 Scenarios whose construction is the plain technique × dataset cross-product delegate to the
@@ -339,6 +349,9 @@ Key points:
   `True` to force opt-in.
 - `kwargs` are validated against the attack class constructor signature at
   factory-construction time, so typos fail loudly and early.
+- Check factory and attack-class requirements through `TargetRequirements.check` to retain custom validation.
+- Use shared seed preparation before adding technique seeds. Keep source groups unchanged and record adaptation.
+- Reject saved plans whose technique identity or accepted inputs cannot be restored.
 
 The canonical catalog factories live in `pyrit/setup/initializers/techniques/`; see
 [setup-techniques.instructions.md](setup-techniques.instructions.md) for how to add one
 
@@ -42,3 +42,13 @@ stop — put the value back inline.
 - Keep entries free of long explanatory comments and paper citations. The factory should read as
   plain configuration; if a technique's mechanics are subtle, document them on the reusable
   converter/model it uses, or here in this file, not as an inline comment block.
+
+## Requirements
+
+Declare `TechniqueRequirements` inline; attack-class target requirements also apply.
+Use `TargetRequirements.required` only when configured adaptation preserves the technique;
+use `native_required` otherwise. Declare modality combinations explicitly.
+
+`objective_only=True` rejects extra dataset seeds and is the simulated-conversation default.
+Set `try_adapt=True` only when removal of extra dataset seeds preserves the technique's behavior.
+Scenarios, not factories, choose skip or raise.
@@ -140,6 +140,16 @@ allow_custom_initializers: false
 # ~/.pyrit/custom_initializers.
 # custom_initializers_source: https://account.blob.core.windows.net/container/custom_initializers
 
+# Upload Folder for API-Created Targets
+# -------------------------------------
+# Folder that targets created through the REST API may upload local files from
+# (HTTPXAPITarget). The server passes it to the target; API callers cannot choose it.
+# When unset, those targets cannot be created through the API; register them in
+# Python or with an initializer instead.
+#
+# Default: unset
+# target_upload_directory: /path/to/upload/files
+
 # Local Backend Server
 # --------------------
 # Client settings used by pyrit_scan when connecting to or launching a backend.
 
@@ -6,9 +6,9 @@
 import argparse
 import json
 import os
-import re
 import runpy
 import subprocess
+import tomllib
 import warnings
 from collections.abc import Callable
 from pathlib import Path
@@ -31,8 +31,12 @@ def _version(root: Path) -> str:
         raise ValueError("Python package version must be a string")
     project_file = root / "pyproject.toml"
     if project_file.is_file():
-        project_version = re.search(r'^version\s*=\s*"([^"]+)"', project_file.read_text(encoding="utf-8"), re.MULTILINE)
-        if project_version is None or project_version[1] != version:
+        project_data = tomllib.loads(project_file.read_text(encoding="utf-8"))
+        project = project_data.get("project", {})
+        if not isinstance(project, dict):
+            raise ValueError("Python package and project versions differ")
+        project_version = project.get("version")
+        if not isinstance(project_version, str) or project_version != version:
             raise ValueError("Python package and project versions differ")
     return version
 
 
@@ -168,6 +168,7 @@ If you are contributing to PyRIT, that work will most likely land in one of the
 
 - A scenario takes user input and uses it to package datasets with attack techniques
 - A scenario orchestrates resiliency and parallelism from a high level
+- A scenario chooses whether to skip or raise for incompatible techniques.
 - No result should depend on previous results (that is an attack's job)
 - **Does not own**: the per-objective conversation logic. Branching, turn-by-turn adaptation, and scoring-based decisions belong to the attack; a scenario selects and packages existing attack techniques rather than defining new attack algorithms or datasets.
 
@@ -187,6 +188,7 @@ If you are contributing to PyRIT, that work will most likely land in one of the
 - Tags describe a technique (behavioral tags like `single_turn`/`multi_turn`, owner tags like `airt`); they don't decide what a scenario runs. There is deliberately **no global `default` tag** — a default is scenario-relative, declared per scenario via `build_technique_class_from_factories` (the `factories` list is the pool, catalog tags become named aggregate presets, and `default_tags` / `default_names` set what runs when nothing is chosen).
 - Generated technique enums follow their factory pool's lifecycle. Registry-derived enums and their lazy exports are discarded on setup registry reset so new scenarios see the replacement catalog. Enums built exclusively from fixed scenario-owned factories, such as `DoctorTechnique` and `JailbreakTechnique`, retain their identity across registry resets, so previously imported members remain valid for new scenario instances.
 - Factories opt into additive request-converter composition with `supports_additional_request_converters=True`. This is a semantic capability, not just constructor-signature detection; the factory validates that opted-in attacks accept `attack_converter_config`.
+- A technique declares target and dataset requirements and permitted adaptation; targets own capabilities and adapters.
 - **Does not own**: the conversation algorithm itself. Branching, turn management, and scoring decisions live in the executor it wraps — a technique only selects and configures existing components, and shouldn't implement new sending, scoring, or branching logic.
 
 **Framework Plans**:
 
@@ -155,6 +155,47 @@
    "cell_type": "markdown",
    "id": "3",
    "metadata": {},
+   "source": [
+    "## Target and dataset requirements\n",
+    "\n",
+    "Declare `TechniqueRequirements` on a factory. The attack class's `TARGET_REQUIREMENTS` also apply.\n",
+    "\n",
+    "```python\n",
+    "from pyrit.executor.attack import PromptSendingAttack\n",
+    "from pyrit.models import SeedGroupRequirements\n",
+    "from pyrit.prompt_target import CapabilityName, TargetRequirements\n",
+    "from pyrit.scenario import AttackTechniqueFactory, TechniqueRequirements\n",
+    "\n",
+    "factory = AttackTechniqueFactory(\n",
+    "    name=\"native_history\",\n",
+    "    attack_class=PromptSendingAttack,\n",
+    "    requirements=TechniqueRequirements(\n",
+    "        objective_target=TargetRequirements(native_required=frozenset({CapabilityName.MULTI_TURN})),\n",
+    "        seed_group=SeedGroupRequirements(objective_only=True),\n",
+    "    ),\n",
+    ")\n",
+    "```\n",
+    "\n",
+    "| Requirement | Behavior |\n",
+    "|-------------|----------|\n",
+    "| `required` | Native target support, or an `ADAPT` policy with a configured adapter. |\n",
+    "| `native_required` | Native target support only. |\n",
+    "| `objective_only=True` | Only the objective before technique seeds are added. |\n",
+    "| `objective_only=True, try_adapt=True` | Permit removal of extra dataset seeds from an execution copy. |\n",
+    "\n",
+    "Required modality combinations must be supported together. Simulated-conversation factories\n",
+    "default to objective-only input. Source groups stay unchanged; applied adaptation is recorded\n",
+    "in result metadata.\n",
+    "\n",
+    "Incompatible inputs raise `IncompatibleTechniqueError`. Scenarios can\n",
+    "[skip them](./1_common_scenario_parameters.ipynb#incompatible-techniques).\n",
+    "Changes to requirements or permitted adaptation can prevent older runs from resuming."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4",
+   "metadata": {},
    "source": [
     "## Executing a single technique\n",
     "\n",
@@ -176,7 +217,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "4",
+   "id": "5",
    "metadata": {},
    "outputs": [
     {
@@ -595,7 +636,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "5",
+   "id": "6",
    "metadata": {},
    "source": [
     "## How techniques are selected\n",
@@ -619,7 +660,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "6",
+   "id": "7",
    "metadata": {
     "class": "col-page-right"
    },
@@ -637,7 +678,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "7",
+   "id": "8",
    "metadata": {},
    "source": [
     "## Relationship to single-turn attacks\n",
 
@@ -117,6 +117,42 @@
 pd.set_option("display.max_colwidth", None)
 print(pd.DataFrame(rows).to_string(index=False))
 
+# %% [markdown]
+# ## Target and dataset requirements
+#
+# Declare `TechniqueRequirements` on a factory. The attack class's `TARGET_REQUIREMENTS` also apply.
+#
+# ```python
+# from pyrit.executor.attack import PromptSendingAttack
+# from pyrit.models import SeedGroupRequirements
+# from pyrit.prompt_target import CapabilityName, TargetRequirements
+# from pyrit.scenario import AttackTechniqueFactory, TechniqueRequirements
+#
+# factory = AttackTechniqueFactory(
+#     name="native_history",
+#     attack_class=PromptSendingAttack,
+#     requirements=TechniqueRequirements(
+#         objective_target=TargetRequirements(native_required=frozenset({CapabilityName.MULTI_TURN})),
+#         seed_group=SeedGroupRequirements(objective_only=True),
+#     ),
+# )
+# ```
+#
+# | Requirement | Behavior |
+# |-------------|----------|
+# | `required` | Native target support, or an `ADAPT` policy with a configured adapter. |
+# | `native_required` | Native target support only. |
+# | `objective_only=True` | Only the objective before technique seeds are added. |
+# | `objective_only=True, try_adapt=True` | Permit removal of extra dataset seeds from an execution copy. |
+#
+# Required modality combinations must be supported together. Simulated-conversation factories
+# default to objective-only input. Source groups stay unchanged; applied adaptation is recorded
+# in result metadata.
+#
+# Incompatible inputs raise `IncompatibleTechniqueError`. Scenarios can
+# [skip them](./1_common_scenario_parameters.ipynb#incompatible-techniques).
+# Changes to requirements or permitted adaptation can prevent older runs from resuming.
+
 # %% [markdown]
 # ## Executing a single technique
 #
 
@@ -664,6 +664,31 @@
    "cell_type": "markdown",
    "id": "19",
    "metadata": {},
+   "source": [
+    "## Incompatible techniques\n",
+    "\n",
+    "Set `incompatible_technique_policy` to `skip` (default) to warn and omit incompatible\n",
+    "techniques, or `raise` to stop initialization.\n",
+    "\n",
+    "```python\n",
+    "scenario = RedTeamAgent()\n",
+    "scenario.set_params_from_args(\n",
+    "    args={\"objective_target\": objective_target, \"incompatible_technique_policy\": \"raise\"}\n",
+    ")\n",
+    "await scenario.initialize_async()\n",
+    "```\n",
+    "\n",
+    "Use `--incompatible-technique-policy raise` on the CLI or\n",
+    "`incompatible_technique_policy: raise` in YAML. `None` uses the scenario class default.\n",
+    "\n",
+    "This policy does not enable adaptation. Initialization fails if no selected technique can run,\n",
+    "even with a baseline. Other construction errors are not skipped."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20",
+   "metadata": {},
    "source": [
     "## Custom Scorers\n",
     "\n",
@@ -677,7 +702,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "20",
+   "id": "21",
    "metadata": {},
    "outputs": [
     {
@@ -790,7 +815,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "21",
+   "id": "22",
    "metadata": {},
    "source": [
     "## Reporting Every Conversation\n",
@@ -805,7 +830,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "22",
+   "id": "23",
    "metadata": {},
    "outputs": [
     {
@@ -876,7 +901,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "23",
+   "id": "24",
    "metadata": {},
    "source": [
     "`output_scenario_full_async` adds the run overview, like `--view full`, and writes the report as\n",
@@ -887,7 +912,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "24",
+   "id": "25",
    "metadata": {},
    "outputs": [
     {
 
@@ -161,6 +161,26 @@
 # await scenario.initialize_async()
 # ```
 
+# %% [markdown]
+# ## Incompatible techniques
+#
+# Set `incompatible_technique_policy` to `skip` (default) to warn and omit incompatible
+# techniques, or `raise` to stop initialization.
+#
+# ```python
+# scenario = RedTeamAgent()
+# scenario.set_params_from_args(
+#     args={"objective_target": objective_target, "incompatible_technique_policy": "raise"}
+# )
+# await scenario.initialize_async()
+# ```
+#
+# Use `--incompatible-technique-policy raise` on the CLI or
+# `incompatible_technique_policy: raise` in YAML. `None` uses the scenario class default.
+#
+# This policy does not enable adaptation. Initialization fails if no selected technique can run,
+# even with a baseline. Other construction errors are not skipped.
+
 # %% [markdown]
 # ## Custom Scorers
 #