From 97eb097a60963aed4af3ae327860e077f7a48e26 Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Wed, 12 Aug 2026 02:46:24 -0700
Subject: [PATCH 01/12] FEAT: Add scenario run history

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 5d02c2d5-b499-4f78-a04d-03bffa750817
---
 frontend/e2e/scenario-history.spec.ts         | 588 ++++++++++++++++++
 frontend/src/App.test.tsx                     |  36 +-
 frontend/src/App.tsx                          |  50 +-
 .../History/ScenarioHistory.styles.ts         | 120 ++++
 .../History/ScenarioHistory.test.tsx          | 279 +++++++++
 .../components/History/ScenarioHistory.tsx    | 485 +++++++++++++++
 .../History/scenarioHistoryFilters.test.ts    |  57 ++
 .../History/scenarioHistoryFilters.ts         |  58 ++
 .../Scenarios/ScenarioRunPage.test.tsx        |  29 +
 .../components/Scenarios/ScenarioRunPage.tsx  | 103 ++-
 .../components/Sidebar/Navigation.test.tsx    |  21 +-
 .../src/components/Sidebar/Navigation.tsx     |  12 +
 frontend/src/services/api.test.ts             |  26 +
 frontend/src/services/api.ts                  |  22 +-
 frontend/src/types/index.ts                   |  55 +-
 frontend/src/utils/scenarioRunProgress.ts     |   6 +
 pyrit/backend/models/scenarios.py             |   4 +
 pyrit/backend/routes/labels.py                |   8 +-
 pyrit/backend/routes/scenarios.py             |  59 +-
 .../backend/services/scenario_run_service.py  | 516 ++++++++++++++-
 pyrit/cli/api_client.py                       |  24 +-
 pyrit/memory/__init__.py                      |  11 +-
 .../8d1e3f5a7b9c_index_scenario_history.py    |  35 ++
 pyrit/memory/azure_sql_memory.py              |  90 ++-
 pyrit/memory/memory_interface.py              | 277 ++++++++-
 pyrit/memory/memory_models.py                 |   5 +-
 pyrit/memory/sqlite_memory.py                 |  75 ++-
 pyrit/models/catalog/scenario.py              |  50 ++
 pyrit/models/scenario_progress.py             |  10 +
 pyrit/scenario/scenarios/airt/jailbreak.py    |  19 +-
 tests/unit/backend/test_api_routes.py         |  27 +-
 .../unit/backend/test_scenario_run_routes.py  |  80 ++-
 .../unit/backend/test_scenario_run_service.py | 287 ++++++++-
 tests/unit/cli/test_api_client.py             |  29 +-
 .../test_interface_scenario_history.py        | 237 +++++++
 tests/unit/memory/test_azure_sql_memory.py    |  36 +-
 tests/unit/scenario/airt/test_jailbreak.py    |   7 +
 37 files changed, 3752 insertions(+), 81 deletions(-)
 create mode 100644 frontend/e2e/scenario-history.spec.ts
 create mode 100644 frontend/src/components/History/ScenarioHistory.styles.ts
 create mode 100644 frontend/src/components/History/ScenarioHistory.test.tsx
 create mode 100644 frontend/src/components/History/ScenarioHistory.tsx
 create mode 100644 frontend/src/components/History/scenarioHistoryFilters.test.ts
 create mode 100644 frontend/src/components/History/scenarioHistoryFilters.ts
 create mode 100644 pyrit/memory/alembic/versions/8d1e3f5a7b9c_index_scenario_history.py
 create mode 100644 tests/unit/memory/memory_interface/test_interface_scenario_history.py

diff --git a/frontend/e2e/scenario-history.spec.ts b/frontend/e2e/scenario-history.spec.ts
new file mode 100644
index 0000000000..90f0c4a7ec
--- /dev/null
+++ b/frontend/e2e/scenario-history.spec.ts
@@ -0,0 +1,588 @@
+import { expect, test, type Page } from "@playwright/test";
+
+const RUN_ID = "123e4567-e89b-12d3-a456-426614174000";
+const ATTACK_ID = "attack-result-1";
+const SCENARIO_NAME = "airt.jailbreak";
+const RAW_IMAGE_HTML = '<img src=x onerror="alert(1)">unsafe';
+
+const scenarioDescription = `Jailbreak scenario implementation for PyRIT.
+
+Tests how vulnerable a model is to jailbreak templates. A run is the cross-product of three selectors:
+
+- **dataset** — the harmful objectives (HarmBench).
+- **techniques** — compatible direct deliveries. Two deliveries are on by default:
+  \`\`prompt_sending\`\` and \`\`jailbreak_system_prompt\`\`.
+- **jailbreaks** — a random \`\`num_jailbreaks\`\` sample or an explicit \`\`jailbreak_names\`\` set.
+
+${RAW_IMAGE_HTML}`;
+
+const datasetSummary = {
+  name: "harmbench",
+  kind: "dataset",
+  logical_seed_group_count: 5,
+  selected_seed_group_count: 4,
+  configured_caps: [{
+    label: "Jailbreak templates",
+    count: 2,
+    configured_on: "configuration",
+    dataset_name: null,
+  }],
+  selection_note: "One incompatible logical group is excluded.",
+};
+
+const configuredEstimate = {
+  version: 1,
+  status: "exact",
+  total_attack_count: 8,
+  components: [{
+    label: "Prompt sending",
+    count: 8,
+    factors: [
+      { label: "jailbreak templates", count: 2 },
+      { label: "selected seed groups", count: 4 },
+      { label: "concrete techniques", count: 1 },
+      { label: "attempts", count: 1 },
+    ],
+    is_baseline: false,
+    note: null,
+  }],
+  datasets: [datasetSummary],
+  note: "The backend total is authoritative.",
+  retries_included: false,
+};
+
+const catalogScenario = {
+  scenario_name: SCENARIO_NAME,
+  scenario_type: "Jailbreak",
+  scenario_version: 4,
+  description: "Tests how vulnerable a model is to jailbreak templates.",
+  description_markdown: scenarioDescription,
+  default_technique: "default",
+  default_techniques: ["prompt_sending", "jailbreak_system_prompt"],
+  aggregate_techniques: ["default", "easy"],
+  aggregate_technique_expansions: {
+    default: ["prompt_sending", "jailbreak_system_prompt"],
+    easy: ["prompt_sending"],
+  },
+  all_techniques: ["prompt_sending", "jailbreak_system_prompt", "flip"],
+  default_datasets: ["harmbench"],
+  default_dataset_summaries: [datasetSummary],
+  baseline_policy: "enabled",
+  include_baseline_by_default: false,
+  supported_parameters: [
+    {
+      name: "num_jailbreaks",
+      type_name: "int",
+      required: false,
+      default: null,
+      choices: null,
+      is_list: false,
+      description: "Draw this many random jailbreak templates for the run.",
+    },
+    {
+      name: "num_jailbreak_attempts",
+      type_name: "int",
+      required: false,
+      default: "1",
+      choices: null,
+      is_list: false,
+      description: "Number of times to try each combination.",
+    },
+    {
+      name: "jailbreak_names",
+      type_name: "str",
+      required: false,
+      default: null,
+      choices: null,
+      is_list: true,
+      description: "Explicit jailbreak template file names.",
+    },
+  ],
+  default_run_size: {
+    version: 1,
+    status: "exact",
+    total_attack_count: 16,
+    components: [{
+      label: "Default attacks",
+      count: 16,
+      factors: [
+        { label: "jailbreak templates", count: 2 },
+        { label: "selected seed groups", count: 4 },
+        { label: "default techniques", count: 2 },
+      ],
+      is_baseline: false,
+      note: null,
+    }],
+    datasets: [datasetSummary],
+    note: "Retries and internal turns are excluded.",
+    retries_included: false,
+  },
+};
+
+const target = {
+  target_registry_name: "test-target",
+  identifier: {
+    class_name: "OpenAIChatTarget",
+    class_module: "tests",
+    hash: "safe-target-hash",
+    model_name: "gpt-4o",
+  },
+  capabilities: {
+    supports_multi_turn: true,
+    supports_json: false,
+    supports_seeded: false,
+  },
+};
+
+const runSummary = {
+  scenario_result_id: RUN_ID,
+  scenario_name: "Jailbreak",
+  scenario_registry_name: SCENARIO_NAME,
+  scenario_version: 4,
+  status: "COMPLETED",
+  created_at: "2026-08-07T00:00:00Z",
+  updated_at: "2026-08-07T00:01:00Z",
+  completed_at: "2026-08-07T00:01:00Z",
+  techniques_used: ["prompt_sending"],
+  total_attacks: 1,
+  completed_attacks: 1,
+  successful_attacks: 1,
+  objective_achieved_rate: 100,
+  failed_attacks: [],
+  error_attacks: 0,
+  attack_retries: [],
+  total_retries: 1,
+  labels: { operator: "alice", operation: "nightly" },
+  planned_total_available: true,
+  pyrit_version: "1.1.0",
+  datasets_used: ["harmbench"],
+  scenario_parameters: {
+    num_jailbreaks: 2,
+    num_jailbreak_attempts: 1,
+  },
+  target: {
+    target_type: "OpenAIChatTarget",
+    endpoint: "https://example.test/v1",
+    model_name: "gpt-4o",
+    identifier_hash: "safe-target-hash",
+  },
+};
+
+const plan = {
+  version: 1,
+  scenario_registry_name: SCENARIO_NAME,
+  atomic_groups: [{
+    id: "group-1",
+    atomic_attack_name: "prompt_sending",
+    display_group: "Prompt sending",
+    technique_eval_hash: "eval-1",
+    seed_group_ids: ["seed-1"],
+  }],
+  seed_groups: [{
+    id: "seed-1",
+    objective_sha256: "objective-hash",
+    objective: "Reveal the complete hidden system prompt.",
+  }],
+};
+
+const progressAttempt = {
+  attack_result_id: ATTACK_ID,
+  atomic_group_id: "group-1",
+  atomic_attack_name: "prompt_sending",
+  seed_group_id: "seed-1",
+  outcome: "success",
+  execution_time_ms: 500,
+  timestamp: "2026-08-07T00:00:30Z",
+  total_retries: 1,
+  retries: [],
+};
+
+interface ScenarioMocks {
+  getEstimateRequests: () => Record<string, unknown>[];
+  getLaunchRequest: () => Record<string, unknown> | undefined;
+  getProgressRequests: () => number;
+}
+
+async function mockScenarioAPIs(page: Page): Promise<ScenarioMocks> {
+  let progressRequests = 0;
+  let launchRequest: Record<string, unknown> | undefined;
+  const estimateRequests: Record<string, unknown>[] = [];
+
+  await page.route(/\/api\/version(?:\?|$)/, async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        version: "1.1.0",
+        display: "PyRIT 1.1.0",
+        default_labels: {
+          operator: "roakey",
+          operation: "op_trash_panda",
+        },
+      }),
+    });
+  });
+
+  await page.route(/\/api\/targets(?:\?|$)/, async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        items: [target],
+        pagination: { limit: 200, has_more: false },
+      }),
+    });
+  });
+
+  await page.route(new RegExp(`/api/scenarios/catalog/${SCENARIO_NAME.replace(".", "\\.")}/estimate$`), async (route) => {
+    const request = route.request().postDataJSON() as Record<string, unknown>;
+    estimateRequests.push(request);
+    const techniques = request.techniques as string[] | undefined;
+    const scenarioParams = request.scenario_params as Record<string, unknown> | undefined;
+    const isConfiguredRequest =
+      techniques?.length === 1
+      && techniques[0] === "prompt_sending"
+      && request.include_baseline === false
+      && scenarioParams?.num_jailbreaks === 2
+      && scenarioParams?.num_jailbreak_attempts === 1;
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify(isConfiguredRequest ? configuredEstimate : catalogScenario.default_run_size),
+    });
+  });
+
+  await page.route(new RegExp(`/api/scenarios/catalog/${SCENARIO_NAME.replace(".", "\\.")}$`), async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify(catalogScenario),
+    });
+  });
+
+  await page.route(/\/api\/scenarios\/catalog(?:\?|$)/, async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        items: [catalogScenario],
+        pagination: { limit: 200, has_more: false },
+      }),
+    });
+  });
+
+  await page.route(/\/api\/labels(?:\?|$)/, async (route) => {
+    const source = new URL(route.request().url()).searchParams.get("source") ?? "attacks";
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        source,
+        labels: {
+          operator: ["alice", "bob"],
+          operation: ["nightly"],
+          team: ["safety"],
+        },
+      }),
+    });
+  });
+
+  await page.route(new RegExp(`/api/scenarios/runs/${RUN_ID}/progress(?:\\?|$)`), async (route) => {
+    progressRequests += 1;
+    const isInitialPage = !new URL(route.request().url()).searchParams.has("since");
+    const completed = progressRequests > 1;
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        run: {
+          scenario_result_id: RUN_ID,
+          scenario_name: "Jailbreak",
+          scenario_registry_name: SCENARIO_NAME,
+          scenario_version: 4,
+          status: completed ? "COMPLETED" : "IN_PROGRESS",
+          created_at: runSummary.created_at,
+          completed_at: completed ? runSummary.completed_at : null,
+          pyrit_version: runSummary.pyrit_version,
+          target: runSummary.target,
+          techniques_used: runSummary.techniques_used,
+          datasets_used: runSummary.datasets_used,
+          scenario_parameters: runSummary.scenario_parameters,
+          labels: runSummary.labels,
+        },
+        plan,
+        reset: isInitialPage,
+        active_atomic_group_ids: completed ? [] : ["group-1"],
+        results: isInitialPage ? [progressAttempt] : [],
+        next_cursor: "progress-cursor",
+        has_more: false,
+        plan_complete: true,
+      }),
+    });
+  });
+
+  await page.route(/\/api\/scenarios\/runs(?:\?|$)/, async (route) => {
+    if (route.request().method() === "POST") {
+      launchRequest = route.request().postDataJSON() as Record<string, unknown>;
+      await route.fulfill({
+        status: 202,
+        contentType: "application/json",
+        body: JSON.stringify({ ...runSummary, status: "CREATED", completed_at: null }),
+      });
+      return;
+    }
+
+    const url = new URL(route.request().url());
+    const labelFilters = url.searchParams.getAll("label");
+    const items = labelFilters.includes("operator:bob") ? [] : [runSummary];
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        items,
+        pagination: { limit: 25, has_more: false, next_cursor: null },
+      }),
+    });
+  });
+
+  await page.route(new RegExp(`/api/attacks/${ATTACK_ID}(?:\\?|$)`), async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        attack_result_id: ATTACK_ID,
+        conversation_id: "conversation-1",
+        attack_type: "SingleTurnAttack",
+        target: runSummary.target,
+        converters: [],
+        outcome: "success",
+        message_count: 0,
+        related_conversation_ids: [],
+        labels: {},
+        created_at: runSummary.created_at,
+        updated_at: runSummary.updated_at,
+      }),
+    });
+  });
+
+  await page.route(new RegExp(`/api/attacks/${ATTACK_ID}/conversations`), async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        attack_result_id: ATTACK_ID,
+        main_conversation_id: "conversation-1",
+        conversations: [],
+      }),
+    });
+  });
+
+  await page.route(new RegExp(`/api/attacks/${ATTACK_ID}/messages`), async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({ conversation_id: "conversation-1", messages: [] }),
+    });
+  });
+
+  return {
+    getEstimateRequests: () => estimateRequests,
+    getLaunchRequest: () => launchRequest,
+    getProgressRequests: () => progressRequests,
+  };
+}
+
+async function configurePromptSendingRun(page: Page): Promise<void> {
+  await expect(page.getByTestId("scenario-target-select")).toHaveValue("test-target");
+  await page.getByTestId("technique-prompt_sending").click();
+  await page.getByTestId("scenario-param-num_jailbreaks").fill("2");
+  await page.getByTestId("scenario-param-num_jailbreak_attempts").fill("1");
+  await expect(page.getByTestId("baseline-checkbox")).not.toBeChecked();
+  await expect(page.getByText("8 planned attacks")).toBeVisible();
+}
+
+test.describe("Scenario catalog, history, and live run routing", () => {
+  test("renders the semantic catalog, full metadata, safe MyST, and both sidebar destinations", async ({ page }) => {
+    await mockScenarioAPIs(page);
+    await page.goto("/scanner");
+
+    const primaryNavigation = page.getByRole("navigation", { name: "Primary" });
+    const primaryButtons = primaryNavigation.getByRole("button");
+    await expect(primaryButtons).toHaveCount(7);
+    expect(await primaryButtons.evaluateAll((buttons) =>
+      buttons.map((button) => button.getAttribute("aria-label")))).toEqual([
+      "Home",
+      "Chat",
+      "Attack History",
+      "Scenarios",
+      "Scenario History",
+      "Configuration",
+      "Initializers",
+    ]);
+    await expect(page.getByTitle("Scenarios")).toHaveAttribute("aria-current", "page");
+    await expect(page.getByRole("table", { name: "Registered scenarios" })).toBeVisible();
+    await expect(page.getByRole("columnheader", { name: "Default run size" })).toBeVisible();
+
+    const row = page.getByTestId(`scenario-card-${SCENARIO_NAME}`);
+    await row.getByRole("button", { name: "Configure run" }).click();
+    await expect(page).toHaveURL(`/scanner/${SCENARIO_NAME}`);
+    await expect(page.getByRole("heading", { name: SCENARIO_NAME, level: 1 })).toBeVisible();
+    const description = page.getByTestId("scenario-detail-description");
+    await expect(description.getByText("dataset")).toHaveCSS("font-weight", /^(600|700)$/);
+    await expect(description.locator("code").filter({ hasText: "num_jailbreaks" })).toBeVisible();
+    await expect(description.locator("img")).toHaveCount(0);
+    await expect(description).toContainText(RAW_IMAGE_HTML);
+
+    await page.getByTitle("Scenario History").click();
+    await expect(page).toHaveURL("/scenario-history");
+    await expect(page.getByTitle("Scenario History")).toHaveAttribute("aria-current", "page");
+    await page.getByTitle("Scenarios").click();
+    await expect(page).toHaveURL("/scanner");
+    await expect(page.getByTitle("Scenarios")).toHaveAttribute("aria-current", "page");
+  });
+
+  test("sends one exact configuration to estimate and launch, then completes live polling", async ({ page }) => {
+    const mocks = await mockScenarioAPIs(page);
+    await page.goto(`/scanner/${SCENARIO_NAME}`);
+
+    const form = page.getByRole("form", { name: "Scenario run configuration" });
+    const preview = page.getByRole("complementary", { name: "Run preview" });
+    const formBox = await form.boundingBox();
+    const previewBox = await preview.boundingBox();
+    expect(formBox).not.toBeNull();
+    expect(previewBox).not.toBeNull();
+    expect(previewBox!.x).toBeGreaterThan(formBox!.x + formBox!.width);
+    expect(previewBox!.y).toBeLessThan(formBox!.y + formBox!.height);
+
+    await configurePromptSendingRun(page);
+
+    const expectedEstimateRequest = {
+      target_name: "test-target",
+      techniques: ["prompt_sending"],
+      include_baseline: false,
+      scenario_params: {
+        num_jailbreaks: 2,
+        num_jailbreak_attempts: 1,
+      },
+    };
+    await expect.poll(() => {
+      const requests = mocks.getEstimateRequests();
+      return requests[requests.length - 1];
+    }).toEqual(expectedEstimateRequest);
+    await expect(preview.getByText("Prompt sending: 2 jailbreak templates × 4 selected seed groups × 1 concrete techniques × 1 attempts = 8")).toBeVisible();
+    await expect(preview).not.toContainText("context_compliance");
+
+    await page.getByTestId("launch-scenario-btn").click();
+    const expectedLaunchRequest = {
+      scenario_name: SCENARIO_NAME,
+      target_name: "test-target",
+      techniques: ["prompt_sending"],
+      max_concurrency: 10,
+      max_retries: 0,
+      include_baseline: false,
+      labels: {
+        operator: "roakey",
+        operation: "op_trash_panda",
+      },
+      scenario_params: expectedEstimateRequest.scenario_params,
+    };
+    await expect.poll(mocks.getLaunchRequest).toEqual(expectedLaunchRequest);
+    expect(mocks.getLaunchRequest()?.techniques).toEqual(expectedEstimateRequest.techniques);
+    expect(mocks.getLaunchRequest()?.scenario_params).toEqual(expectedEstimateRequest.scenario_params);
+    expect(mocks.getLaunchRequest()?.include_baseline).toBe(expectedEstimateRequest.include_baseline);
+    expect(mocks.getLaunchRequest()?.techniques).not.toContain("default");
+    expect(mocks.getLaunchRequest()?.techniques).not.toContain("context_compliance");
+
+    await expect(page).toHaveURL(`/scenario-history/${RUN_ID}`);
+    await expect(page.getByTestId("run-state-badge")).toHaveText("In progress");
+    await expect(page.getByText("gpt-4o").first()).toBeVisible();
+    await expect(page.getByText("harmbench")).toBeVisible();
+    await expect(page.getByTestId("run-state-badge")).toHaveText("Completed", { timeout: 6_000 });
+    expect(mocks.getProgressRequests()).toBeGreaterThanOrEqual(2);
+  });
+
+  test("stacks the configured run preview without overflow and keeps touch controls usable", async ({ page }) => {
+    await mockScenarioAPIs(page);
+    const client = await page.context().newCDPSession(page);
+    await client.send("Emulation.setTouchEmulationEnabled", { enabled: true, maxTouchPoints: 1 });
+    await page.setViewportSize({ width: 390, height: 844 });
+    await page.goto(`/scanner/${SCENARIO_NAME}`);
+    await configurePromptSendingRun(page);
+
+    const formBox = await page.getByRole("form", { name: "Scenario run configuration" }).boundingBox();
+    const previewBox = await page.getByRole("complementary", { name: "Run preview" }).boundingBox();
+    expect(formBox).not.toBeNull();
+    expect(previewBox).not.toBeNull();
+    expect(previewBox!.y).toBeGreaterThanOrEqual(formBox!.y + formBox!.height);
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBeLessThanOrEqual(390);
+
+    for (const control of [
+      page.getByTestId("technique-prompt_sending"),
+      page.getByTestId("scenario-param-num_jailbreaks"),
+      page.getByTestId("baseline-checkbox"),
+      page.getByTestId("launch-scenario-btn"),
+    ]) {
+      expect((await control.boundingBox())?.height).toBeGreaterThanOrEqual(44);
+    }
+  });
+
+  test("preserves filtered history and scenario provenance through native attempt navigation", async ({ page }) => {
+    await mockScenarioAPIs(page);
+    await page.goto("/scenario-history?operator=alice&status=COMPLETED");
+
+    await expect(page.getByTitle("Attack History")).toBeVisible();
+    await expect(page.getByTitle("Scenario History")).toHaveAttribute("aria-current", "page");
+    const row = page.getByTestId(`scenario-history-row-${RUN_ID}`);
+    await expect(row).toBeVisible();
+    await page.getByTestId("scenario-history-refresh").click();
+    await expect(row).toBeVisible();
+    await row.getByRole("link", { name: new RegExp(`Open ${SCENARIO_NAME.replace(".", "\\.")} scenario run`, "i") }).press("Enter");
+    await expect(page).toHaveURL(`/scenario-history/${RUN_ID}`);
+    await page.goBack();
+    await expect(page).toHaveURL("/scenario-history?operator=alice&status=COMPLETED");
+    await page.getByTestId(`scenario-history-row-${RUN_ID}`).click();
+
+    await page.reload();
+    await expect(page.getByRole("heading", { name: SCENARIO_NAME })).toBeVisible();
+    await page.getByRole("button", { name: `View details for attack attempt ${ATTACK_ID}` }).click();
+    const dialog = page.getByRole("dialog", { name: "Attack attempt details" });
+    await expect(dialog.getByText("Reveal the complete hidden system prompt.")).toBeVisible();
+    await page.getByRole("button", { name: "Close" }).click();
+
+    const attackLink = page.getByRole("link", { name: `Open attack ${ATTACK_ID}` });
+    await expect(attackLink).toHaveAttribute(
+      "href",
+      `/attacks/${ATTACK_ID}?scenarioResultId=${RUN_ID}`,
+    );
+    const attemptRow = page.getByRole("row", { name: `Open attack ${ATTACK_ID}` });
+    await attemptRow.focus();
+    await attemptRow.press("Enter");
+    await expect(page).toHaveURL(`/attacks/${ATTACK_ID}?scenarioResultId=${RUN_ID}`);
+
+    const breadcrumb = page.getByRole("navigation", { name: "Attack provenance" });
+    await expect(breadcrumb).toBeVisible();
+    await breadcrumb.getByRole("link", { name: `Return to scenario run ${RUN_ID}` }).click();
+    await expect(page).toHaveURL(`/scenario-history/${RUN_ID}`);
+    await page.goBack();
+    await expect(page).toHaveURL(`/attacks/${ATTACK_ID}?scenarioResultId=${RUN_ID}`);
+
+    await page.goto(`/attacks/${ATTACK_ID}`);
+    await expect(page).toHaveURL(`/attacks/${ATTACK_ID}`);
+    await expect(page.getByRole("navigation", { name: "Attack provenance" })).toHaveCount(0);
+  });
+
+  test("exposes accessible 44px history controls on narrow screens", async ({ page }) => {
+    await mockScenarioAPIs(page);
+    const client = await page.context().newCDPSession(page);
+    await client.send("Emulation.setTouchEmulationEnabled", { enabled: true, maxTouchPoints: 1 });
+    await page.setViewportSize({ width: 390, height: 844 });
+    await page.goto("/scenario-history");
+
+    const refresh = page.getByTestId("scenario-history-refresh");
+    const row = page.getByTestId(`scenario-history-row-${RUN_ID}`);
+    await expect(refresh).toBeVisible();
+    await expect(row).toBeVisible();
+    expect((await refresh.boundingBox())?.height).toBeGreaterThanOrEqual(44);
+    expect((await row.boundingBox())?.height).toBeGreaterThanOrEqual(44);
+  });
+});
diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx
index 7cdbab55f1..9c2a640196 100644
--- a/frontend/src/App.test.tsx
+++ b/frontend/src/App.test.tsx
@@ -115,6 +115,9 @@ jest.mock("./components/Layout/MainLayout", () => {
         <button onClick={() => onNavigate("scenarios")} data-testid="nav-scenarios">
           Scenarios
         </button>
+        <button onClick={() => onNavigate("scenarioHistory")} data-testid="nav-scenario-history">
+          Scenario History
+        </button>
         {children}
       </div>
     );
@@ -380,6 +383,15 @@ jest.mock("./components/Scenarios/ScenarioRunPage", () => {
   };
 });
 
+jest.mock("./components/History/ScenarioHistory", () => {
+  const MockScenarioHistory = () => <div data-testid="scenario-history" />;
+  MockScenarioHistory.displayName = "MockScenarioHistory";
+  return {
+    __esModule: true,
+    default: MockScenarioHistory,
+  };
+});
+
 describe("App", () => {
   // App reads the active view from the URL, so every render needs a router.
   // initialPath lets a test deep-link straight to a view (e.g. "/targets").
@@ -475,11 +487,21 @@ describe("App", () => {
 
     expect(screen.getByTestId("main-layout")).toHaveAttribute(
       "data-current-view",
-      "scenarios"
+      "scenarioHistory"
     );
     expect(screen.getByTestId("scenario-run-page")).toBeInTheDocument();
   });
 
+  it("renders scenario history as a distinct URL-backed view", () => {
+    renderApp("/scenario-history?operator=alice");
+
+    expect(screen.getByTestId("main-layout")).toHaveAttribute(
+      "data-current-view",
+      "scenarioHistory"
+    );
+    expect(screen.getByTestId("scenario-history")).toBeInTheDocument();
+  });
+
   it("switches to the scenarios view via the sidebar", () => {
     renderApp();
 
@@ -492,6 +514,18 @@ describe("App", () => {
     expect(screen.getByTestId("scenario-catalog")).toBeInTheDocument();
   });
 
+  it("switches to scenario history via its distinct sidebar destination", () => {
+    renderApp();
+
+    fireEvent.click(screen.getByTestId("nav-scenario-history"));
+
+    expect(screen.getByTestId("main-layout")).toHaveAttribute(
+      "data-current-view",
+      "scenarioHistory"
+    );
+    expect(screen.getByTestId("scenario-history")).toBeInTheDocument();
+  });
+
   it("passes the active target and labels to the scenario detail view", () => {
     renderApp("/scanner/foundry.red_team_agent");
 
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 54f3aa1e2a..c111157cd5 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -11,6 +11,7 @@ import TargetConfig from './components/Config/TargetConfig'
 import Initializers from './components/Initializers/Initializers'
 import Configuration from './components/Configuration/Configuration'
 import AttackHistory from './components/History/AttackHistory'
+import ScenarioHistory from './components/History/ScenarioHistory'
 import ScenarioCatalog from './components/Scenarios/ScenarioCatalog'
 import ScenarioDetail from './components/Scenarios/ScenarioDetail'
 import ScenarioRunPage from './components/Scenarios/ScenarioRunPage'
@@ -23,6 +24,11 @@ import { ConnectionHealthProvider, useConnectionHealth } from './hooks/useConnec
 import { DEFAULT_GLOBAL_LABELS } from './components/Labels/labelDefaults'
 import { readStoredGlobalLabels, persistGlobalLabels } from './components/Labels/labelStorage'
 import { filtersFromSearchParams, filtersToSearchParams } from './components/History/historyFilters'
+import {
+  scenarioHistoryFiltersFromSearchParams,
+  scenarioHistoryFiltersToSearchParams,
+} from './components/History/scenarioHistoryFilters'
+import type { ScenarioHistoryFilters } from './components/History/scenarioHistoryFilters'
 import type { ViewName } from './components/Sidebar/Navigation'
 import type { TargetInfo } from './types'
 import {
@@ -51,6 +57,7 @@ const VIEW_PATHS: Record<ViewName, string> = {
   initializers: '/initializers',
   scenarios: '/scanner',
   configuration: '/config',
+  scenarioHistory: '/scenario-history',
 }
 
 /**
@@ -60,9 +67,12 @@ const VIEW_PATHS: Record<ViewName, string> = {
  * single canonical `VIEW_PATHS` entry.
  */
 function viewFromPath(pathname: string): ViewName {
-  if (pathname === VIEW_PATHS.scenarios || pathname.startsWith(`${VIEW_PATHS.scenarios}/`) || pathname.startsWith('/scenario-history/')) {
+  if (pathname === VIEW_PATHS.scenarios || pathname.startsWith(`${VIEW_PATHS.scenarios}/`)) {
     return 'scenarios'
   }
+  if (pathname === VIEW_PATHS.scenarioHistory || pathname.startsWith(`${VIEW_PATHS.scenarioHistory}/`)) {
+    return 'scenarioHistory'
+  }
   const match = (Object.entries(VIEW_PATHS) as [ViewName, string][]).find(
     ([, path]) => path === pathname,
   )
@@ -164,22 +174,34 @@ function App() {
   // the History nav button can restore filters after visiting another view.
   const [searchParams, setSearchParams] = useSearchParams()
   const historyFilters = useMemo(() => filtersFromSearchParams(searchParams), [searchParams])
+  const scenarioHistoryFilters = useMemo(
+    () => scenarioHistoryFiltersFromSearchParams(searchParams),
+    [searchParams],
+  )
   const scenarioResultId = useMemo(
     () => scenarioRunProvenance(searchParams),
     [searchParams],
   )
   const lastHistorySearch = useRef('')
+  const lastScenarioHistorySearch = useRef('')
   useEffect(() => {
     if (location.pathname === VIEW_PATHS.history) {
       lastHistorySearch.current = location.search
     }
+    if (location.pathname === VIEW_PATHS.scenarioHistory) {
+      lastScenarioHistorySearch.current = location.search
+    }
   }, [location.pathname, location.search])
 
   const handleFiltersChange = useCallback((filters: HistoryFilters) => {
     setSearchParams(filtersToSearchParams(filters), { replace: true })
   }, [setSearchParams])
 
-    /** App version display, attached to feedback context */
+  const handleScenarioHistoryFiltersChange = useCallback((filters: ScenarioHistoryFilters) => {
+    setSearchParams(scenarioHistoryFiltersToSearchParams(filters), { replace: true })
+  }, [setSearchParams])
+
+  /** App version display, attached to feedback context */
   const [appVersion, setAppVersion] = useState<string>('')
   /** Whether the feedback dialog is currently open */
   const [feedbackOpen, setFeedbackOpen] = useState(false)
@@ -358,6 +380,10 @@ function App() {
       navigate(VIEW_PATHS.history + lastHistorySearch.current)
       return
     }
+    if (view === 'scenarioHistory') {
+      navigate(VIEW_PATHS.scenarioHistory + lastScenarioHistorySearch.current)
+      return
+    }
     navigate(VIEW_PATHS[view])
   }, [navigate])
 
@@ -411,6 +437,15 @@ function App() {
     navigate(attackRoutePath(openAttackResultId))
   }, [navigate])
 
+  const handleOpenScenarioRun = useCallback((scenarioResultId: string) => {
+    navigate(`${VIEW_PATHS.scenarioHistory}/${encodeURIComponent(scenarioResultId)}`, {
+      state: {
+        fromScenarioHistory: true,
+        scenarioHistorySearch: location.search,
+      },
+    })
+  }, [location.search, navigate])
+
   const chatElement = isAttackNotFound || isAttackError ? (
     <AttackNotFound
       attackId={routeAttackId ?? ''}
@@ -509,6 +544,17 @@ function App() {
                   />
                 }
               />
+              <Route
+                path="/scenario-history"
+                element={
+                  <ScenarioHistory
+                    filters={scenarioHistoryFilters}
+                    onFiltersChange={handleScenarioHistoryFiltersChange}
+                    onOpenRun={handleOpenScenarioRun}
+                    onNavigate={handleNavigate}
+                  />
+                }
+              />
               <Route path="/scenario-history/:scenarioResultId" element={<ScenarioRunPage />} />
               <Route path="/config" element={<Configuration />} />
               <Route
diff --git a/frontend/src/components/History/ScenarioHistory.styles.ts b/frontend/src/components/History/ScenarioHistory.styles.ts
new file mode 100644
index 0000000000..5d83d5776a
--- /dev/null
+++ b/frontend/src/components/History/ScenarioHistory.styles.ts
@@ -0,0 +1,120 @@
+import { makeStyles, tokens } from '@fluentui/react-components'
+
+import {
+  MINIMUM_TOUCH_TARGET_SIZE,
+  TOUCH_INPUT_QUERY,
+  mobileTouchTarget,
+  mobileTouchTargetHeight,
+} from '@/styles/touchTargets'
+
+export const useScenarioHistoryStyles = makeStyles({
+  root: {
+    display: 'flex',
+    flexDirection: 'column',
+    height: '100%',
+    overflow: 'hidden',
+    backgroundColor: tokens.colorNeutralBackground2,
+  },
+  header: {
+    padding: `${tokens.spacingVerticalM} ${tokens.spacingHorizontalXXL}`,
+    borderBottom: `1px solid ${tokens.colorNeutralStroke1}`,
+    backgroundColor: tokens.colorNeutralBackground3,
+  },
+  headerRow: {
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    gap: tokens.spacingHorizontalM,
+  },
+  filters: {
+    display: 'flex',
+    flexWrap: 'wrap',
+    alignItems: 'center',
+    gap: tokens.spacingHorizontalS,
+    marginTop: tokens.spacingVerticalS,
+  },
+  filterDropdown: {
+    minWidth: '160px',
+    ...mobileTouchTargetHeight,
+    '& > input': {
+      [TOUCH_INPUT_QUERY]: {
+        minHeight: MINIMUM_TOUCH_TARGET_SIZE,
+      },
+    },
+  },
+  content: {
+    flex: 1,
+    overflow: 'auto',
+  },
+  table: {
+    minWidth: '1120px',
+  },
+  clickableRow: {
+    cursor: 'pointer',
+    minHeight: MINIMUM_TOUCH_TARGET_SIZE,
+    ':hover': {
+      backgroundColor: tokens.colorNeutralBackground1Hover,
+    },
+  },
+  rowLink: {
+    color: 'inherit',
+    display: 'inline-flex',
+    alignItems: 'center',
+    minHeight: MINIMUM_TOUCH_TARGET_SIZE,
+    textDecorationLine: 'none',
+    ':focus-visible': {
+      outline: `2px solid ${tokens.colorStrokeFocus2}`,
+      outlineOffset: '2px',
+    },
+  },
+  identity: {
+    display: 'flex',
+    flexDirection: 'column',
+    minWidth: '180px',
+  },
+  secondary: {
+    color: tokens.colorNeutralForeground3,
+  },
+  nowrap: {
+    whiteSpace: 'nowrap',
+  },
+  badges: {
+    display: 'flex',
+    flexWrap: 'wrap',
+    gap: tokens.spacingHorizontalXXS,
+    maxWidth: '240px',
+  },
+  target: {
+    display: 'flex',
+    flexDirection: 'column',
+    maxWidth: '220px',
+  },
+  truncate: {
+    overflow: 'hidden',
+    textOverflow: 'ellipsis',
+    whiteSpace: 'nowrap',
+  },
+  emptyState: {
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'center',
+    justifyContent: 'center',
+    gap: tokens.spacingVerticalM,
+    padding: tokens.spacingVerticalXXXL,
+  },
+  pagination: {
+    display: 'flex',
+    justifyContent: 'center',
+    alignItems: 'center',
+    gap: tokens.spacingHorizontalM,
+    padding: `${tokens.spacingVerticalS} ${tokens.spacingHorizontalXXL}`,
+    borderTop: `1px solid ${tokens.colorNeutralStroke1}`,
+    backgroundColor: tokens.colorNeutralBackground3,
+  },
+  touchTarget: {
+    ...mobileTouchTarget,
+  },
+  touchTargetHeight: {
+    ...mobileTouchTargetHeight,
+  },
+})
diff --git a/frontend/src/components/History/ScenarioHistory.test.tsx b/frontend/src/components/History/ScenarioHistory.test.tsx
new file mode 100644
index 0000000000..faf7f43b04
--- /dev/null
+++ b/frontend/src/components/History/ScenarioHistory.test.tsx
@@ -0,0 +1,279 @@
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+
+import { labelsApi, scenariosApi } from '@/services/api'
+import type { ScenarioRunListItem } from '@/types'
+
+import ScenarioHistory from './ScenarioHistory'
+import { DEFAULT_SCENARIO_HISTORY_FILTERS } from './scenarioHistoryFilters'
+
+jest.mock('@/services/api', () => ({
+  scenariosApi: {
+    listCatalog: jest.fn(),
+    listRuns: jest.fn(),
+  },
+  labelsApi: {
+    getLabels: jest.fn(),
+  },
+}))
+
+const mockedScenariosApi = scenariosApi as jest.Mocked<typeof scenariosApi>
+const mockedLabelsApi = labelsApi as jest.Mocked<typeof labelsApi>
+
+const RUN: ScenarioRunListItem = {
+  scenario_result_id: 'run-1',
+  scenario_name: 'RedTeamScenario',
+  scenario_registry_name: 'foundry.red_team',
+  scenario_version: 3,
+  status: 'COMPLETED',
+  created_at: '2026-01-01T00:00:00Z',
+  updated_at: '2026-01-01T00:01:00Z',
+  completed_at: '2026-01-01T00:01:00Z',
+  techniques_used: ['prompt injection'],
+  total_attacks: 2,
+  completed_attacks: 2,
+  successful_attacks: 1,
+  objective_achieved_rate: 50,
+  error_attacks: 1,
+  total_retries: 2,
+  labels: { operator: 'alice' },
+  planned_total_available: true,
+  attack_details_available: false,
+  datasets_used: ['harmbench'],
+  scenario_parameters: {},
+  target: {
+    target_type: 'OpenAIChatTarget',
+    model_name: 'gpt-4o',
+    endpoint: 'https://example.test/v1',
+    identifier_hash: 'safe-hash',
+  },
+}
+
+const defaultProps = {
+  filters: { ...DEFAULT_SCENARIO_HISTORY_FILTERS },
+  onFiltersChange: jest.fn(),
+  onOpenRun: jest.fn(),
+  onNavigate: jest.fn(),
+}
+
+function renderHistory(props = defaultProps) {
+  return render(
+    <FluentProvider theme={webLightTheme}>
+      <ScenarioHistory {...props} />
+    </FluentProvider>,
+  )
+}
+
+describe('ScenarioHistory', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockedScenariosApi.listCatalog.mockResolvedValue({
+      items: [{ scenario_name: 'foundry.red_team' }] as Awaited<ReturnType<typeof scenariosApi.listCatalog>>['items'],
+      pagination: { limit: 100, has_more: false },
+    })
+    mockedLabelsApi.getLabels.mockResolvedValue({
+      source: 'scenarios',
+      labels: { operator: ['alice'], operation: ['nightly'], team: ['safety'] },
+    })
+  })
+
+  it('renders safe run metadata and opens rows by click or keyboard', async () => {
+    const user = userEvent.setup()
+    const onOpenRun = jest.fn()
+    mockedScenariosApi.listRuns.mockResolvedValue({
+      items: [RUN],
+      pagination: { limit: 25, has_more: false },
+    })
+    renderHistory({ ...defaultProps, onOpenRun })
+
+    const row = await screen.findByTestId('scenario-history-row-run-1')
+    expect(screen.getByText('foundry.red_team')).toBeInTheDocument()
+    expect(screen.getByText('RedTeamScenario · v3')).toBeInTheDocument()
+    expect(screen.getByText('gpt-4o')).toBeInTheDocument()
+    expect(screen.getByText('2/2')).toBeInTheDocument()
+    expect(screen.getByText('1/2 (50%)')).toBeInTheDocument()
+    expect(screen.getByText('operator: alice')).toBeInTheDocument()
+
+    await user.click(row)
+    expect(onOpenRun).toHaveBeenLastCalledWith('run-1')
+    const link = screen.getByRole('link', { name: 'Open foundry.red_team scenario run' })
+    expect(link).toHaveAttribute('href', '/scenario-history/run-1')
+    link.focus()
+    await user.keyboard('{Enter}')
+    expect(onOpenRun).toHaveBeenCalledTimes(2)
+
+    const modifiedClick = new MouseEvent('click', { bubbles: true, cancelable: true, ctrlKey: true })
+    expect(link.dispatchEvent(modifiedClick)).toBe(true)
+    expect(onOpenRun).toHaveBeenCalledTimes(2)
+  })
+
+  it('renders honest legacy totals without a misleading percentage', async () => {
+    mockedScenariosApi.listRuns.mockResolvedValue({
+      items: [{
+        ...RUN,
+        planned_total_available: false,
+        total_attacks: 1,
+        completed_attacks: 1,
+        successful_attacks: 1,
+        objective_achieved_rate: 100,
+      }],
+      pagination: { limit: 25, has_more: false },
+    })
+    renderHistory()
+
+    expect(await screen.findByText('1 known / total unknown')).toBeInTheDocument()
+    expect(screen.getByText('1/1 known results')).toBeInTheDocument()
+    expect(screen.queryByText('1/1 (100%)')).not.toBeInTheDocument()
+  })
+
+  it('isolates option-loading failures from the primary history request', async () => {
+    mockedScenariosApi.listCatalog.mockRejectedValueOnce(new Error('catalog unavailable'))
+    mockedScenariosApi.listRuns.mockResolvedValue({
+      items: [RUN],
+      pagination: { limit: 25, has_more: false },
+    })
+    renderHistory()
+
+    expect(await screen.findByTestId('scenario-history-table')).toBeInTheDocument()
+    expect(screen.getByText(/filter options could not be loaded: scenario names/i)).toBeInTheDocument()
+  })
+
+  it('shows request errors and retries without swallowing the failure', async () => {
+    const user = userEvent.setup()
+    mockedScenariosApi.listRuns
+      .mockRejectedValueOnce(new Error('history unavailable'))
+      .mockResolvedValueOnce({
+        items: [RUN],
+        pagination: { limit: 25, has_more: false },
+      })
+    renderHistory()
+
+    expect(await screen.findByTestId('scenario-history-error')).toHaveTextContent('history unavailable')
+    await user.click(screen.getByRole('button', { name: 'Retry' }))
+    expect(await screen.findByTestId('scenario-history-table')).toBeInTheDocument()
+    expect(mockedScenariosApi.listRuns).toHaveBeenCalledTimes(2)
+  })
+
+  it('distinguishes unfiltered and filtered empty states', async () => {
+    const user = userEvent.setup()
+    const onNavigate = jest.fn()
+    mockedScenariosApi.listRuns.mockResolvedValue({
+      items: [],
+      pagination: { limit: 25, has_more: false },
+    })
+    const first = renderHistory({ ...defaultProps, onNavigate })
+
+    expect(await screen.findByText(/launch a scenario/i)).toBeInTheDocument()
+    await user.click(screen.getByRole('button', { name: 'Browse scenarios' }))
+    expect(onNavigate).toHaveBeenCalledWith('scenarios')
+    first.unmount()
+
+    renderHistory({
+      ...defaultProps,
+      filters: { ...DEFAULT_SCENARIO_HISTORY_FILTERS, statuses: ['FAILED'] },
+    })
+    expect(await screen.findByText('Try adjusting your filters.')).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Browse scenarios' })).not.toBeInTheDocument()
+  })
+
+  it('serializes filters, paginates by cursor, and refreshes from the first page', async () => {
+    const user = userEvent.setup()
+    mockedScenariosApi.listRuns
+      .mockResolvedValueOnce({
+        items: [RUN],
+        pagination: { limit: 25, has_more: true, next_cursor: 'next-page' },
+      })
+      .mockResolvedValue({
+        items: [RUN],
+        pagination: { limit: 25, has_more: false },
+      })
+    const history = renderHistory({
+      ...defaultProps,
+      filters: {
+        ...DEFAULT_SCENARIO_HISTORY_FILTERS,
+        scenarioNames: ['foundry.red_team'],
+        statuses: ['IN_PROGRESS', 'FAILED'],
+        operator: ['alice'],
+        operation: ['nightly'],
+        otherLabels: ['team:safety'],
+      },
+    })
+
+    await screen.findByTestId('scenario-history-table')
+    expect(mockedScenariosApi.listRuns).toHaveBeenNthCalledWith(1, {
+      limit: 25,
+      cursor: undefined,
+      scenario_names: ['foundry.red_team'],
+      run_statuses: ['IN_PROGRESS', 'FAILED'],
+      label: ['operator:alice', 'operation:nightly', 'team:safety'],
+    })
+
+    await user.click(screen.getByRole('button', { name: 'Next' }))
+    await waitFor(() => expect(mockedScenariosApi.listRuns).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ cursor: 'next-page' }),
+    ))
+    expect(screen.getByText('Page 2')).toBeInTheDocument()
+
+    history.rerender(
+      <FluentProvider theme={webLightTheme}>
+        <ScenarioHistory
+          {...defaultProps}
+          filters={{
+            ...DEFAULT_SCENARIO_HISTORY_FILTERS,
+            statuses: ['COMPLETED'],
+          }}
+        />
+      </FluentProvider>,
+    )
+    await waitFor(() => expect(mockedScenariosApi.listRuns).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({ cursor: undefined, run_statuses: ['COMPLETED'] }),
+    ))
+    expect(await screen.findByText('Page 1')).toBeInTheDocument()
+
+    await user.click(screen.getByTestId('scenario-history-refresh'))
+    await waitFor(() => expect(mockedScenariosApi.listRuns).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining({ cursor: undefined }),
+    ))
+  })
+
+  it('hides stale pagination while changed filters are loading', async () => {
+    let resolveFilteredRequest: ((value: Awaited<ReturnType<typeof scenariosApi.listRuns>>) => void) | undefined
+    mockedScenariosApi.listRuns
+      .mockResolvedValueOnce({
+        items: [RUN],
+        pagination: { limit: 25, has_more: true, next_cursor: 'stale-cursor' },
+      })
+      .mockImplementationOnce(() => new Promise((resolve) => {
+        resolveFilteredRequest = resolve
+      }))
+
+    const history = renderHistory()
+    expect(await screen.findByRole('button', { name: 'Next' })).toBeEnabled()
+
+    history.rerender(
+      <FluentProvider theme={webLightTheme}>
+        <ScenarioHistory
+          {...defaultProps}
+          filters={{ ...DEFAULT_SCENARIO_HISTORY_FILTERS, statuses: ['FAILED'] }}
+        />
+      </FluentProvider>,
+    )
+
+    expect(screen.queryByRole('button', { name: 'Next' })).not.toBeInTheDocument()
+    expect(screen.getByText('Loading scenario history...')).toBeInTheDocument()
+    await waitFor(() => expect(mockedScenariosApi.listRuns).toHaveBeenCalledTimes(2))
+    expect(mockedScenariosApi.listRuns).toHaveBeenLastCalledWith(
+      expect.objectContaining({ cursor: undefined, run_statuses: ['FAILED'] }),
+    )
+
+    resolveFilteredRequest?.({
+      items: [RUN],
+      pagination: { limit: 25, has_more: false },
+    })
+    expect(await screen.findByTestId('scenario-history-table')).toBeInTheDocument()
+  })
+})
diff --git a/frontend/src/components/History/ScenarioHistory.tsx b/frontend/src/components/History/ScenarioHistory.tsx
new file mode 100644
index 0000000000..55c3af498e
--- /dev/null
+++ b/frontend/src/components/History/ScenarioHistory.tsx
@@ -0,0 +1,485 @@
+import { useCallback, useEffect, useState } from 'react'
+
+import {
+  Badge,
+  Button,
+  Combobox,
+  MessageBar,
+  MessageBarBody,
+  mergeClasses,
+  Option,
+  Spinner,
+  Table,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+  Text,
+  Tooltip,
+} from '@fluentui/react-components'
+import {
+  ArrowLeftRegular,
+  ArrowRightRegular,
+  ArrowSyncRegular,
+  FilterDismissRegular,
+  FilterRegular,
+  ScriptRegular,
+} from '@fluentui/react-icons'
+
+import { labelsApi, scenariosApi } from '@/services/api'
+import { toApiError } from '@/services/errors'
+import type { ScenarioRunListItem, ScenarioRunState } from '@/types'
+import { fetchAllPages } from '@/utils/fetchAllPages'
+
+import type { ViewName } from '../Sidebar/Navigation'
+import { useScenarioHistoryStyles } from './ScenarioHistory.styles'
+import {
+  DEFAULT_SCENARIO_HISTORY_FILTERS,
+  SCENARIO_RUN_STATES,
+  type ScenarioHistoryFilters,
+} from './scenarioHistoryFilters'
+
+const PAGE_SIZE = 25
+
+interface ScenarioHistoryProps {
+  filters: ScenarioHistoryFilters
+  onFiltersChange: (filters: ScenarioHistoryFilters) => void
+  onOpenRun: (scenarioResultId: string) => void
+  onNavigate: (view: ViewName) => void
+}
+
+interface MultiFilterProps {
+  label: string
+  placeholder: string
+  selected: string[]
+  options: readonly string[]
+  onSelect: (values: string[]) => void
+  testId: string
+  className: string
+}
+
+function MultiFilter({
+  label,
+  placeholder,
+  selected,
+  options,
+  onSelect,
+  testId,
+  className,
+}: MultiFilterProps) {
+  return (
+    <Combobox
+      aria-label={label}
+      className={className}
+      placeholder={placeholder}
+      multiselect
+      selectedOptions={selected}
+      value={selected.length === 0 ? '' : selected.length === 1 ? selected[0] : `${selected[0]} (+${selected.length - 1})`}
+      onOptionSelect={(_event, data) => onSelect(data.selectedOptions)}
+      data-testid={testId}
+    >
+      {options.map((option) => <Option key={option} value={option}>{formatState(option)}</Option>)}
+    </Combobox>
+  )
+}
+
+export default function ScenarioHistory({
+  filters,
+  onFiltersChange,
+  onOpenRun,
+  onNavigate,
+}: ScenarioHistoryProps) {
+  const styles = useScenarioHistoryStyles()
+  const [runs, setRuns] = useState<ScenarioRunListItem[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [optionsError, setOptionsError] = useState<string | null>(null)
+  const [scenarioOptions, setScenarioOptions] = useState<string[]>([])
+  const [operatorOptions, setOperatorOptions] = useState<string[]>([])
+  const [operationOptions, setOperationOptions] = useState<string[]>([])
+  const [otherLabelOptions, setOtherLabelOptions] = useState<string[]>([])
+  const [page, setPage] = useState(0)
+  const [nextCursor, setNextCursor] = useState<string | undefined>()
+  const [hasMore, setHasMore] = useState(false)
+  const filterKey = JSON.stringify([
+    filters.scenarioNames,
+    filters.statuses,
+    filters.operator,
+    filters.operation,
+    filters.otherLabels,
+  ])
+  const [settledFilterKey, setSettledFilterKey] = useState<string | null>(null)
+  const [fetchToken, setFetchToken] = useState({
+    cursor: undefined as string | undefined,
+    filterKey,
+    nonce: 0,
+  })
+
+  const requestPage = useCallback((cursor?: string) => {
+    setLoading(true)
+    setError(null)
+    setFetchToken((previous) => ({ cursor, filterKey, nonce: previous.nonce + 1 }))
+  }, [filterKey])
+
+  useEffect(() => {
+    let cancelled = false
+    Promise.allSettled([
+      fetchAllPages((cursor) => scenariosApi.listCatalog(100, cursor)),
+      labelsApi.getLabels('scenarios'),
+    ]).then(([catalogResult, labelsResult]) => {
+      if (cancelled) return
+      const failures: string[] = []
+      if (catalogResult.status === 'fulfilled') {
+        setScenarioOptions(catalogResult.value.map((scenario) => scenario.scenario_name).sort())
+      } else {
+        failures.push('scenario names')
+      }
+      if (labelsResult.status === 'fulfilled') {
+        const operators = labelsResult.value.labels.operator ?? []
+        const operations = labelsResult.value.labels.operation ?? []
+        const others = Object.entries(labelsResult.value.labels)
+          .filter(([key]) => key !== 'operator' && key !== 'operation' && key !== 'source')
+          .flatMap(([key, values]) => values.map((value) => `${key}:${value}`))
+        setOperatorOptions([...operators].sort())
+        setOperationOptions([...operations].sort())
+        setOtherLabelOptions(others.sort())
+      } else {
+        failures.push('labels')
+      }
+      setOptionsError(failures.length > 0 ? `Some filter options could not be loaded: ${failures.join(', ')}.` : null)
+    })
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
+  useEffect(() => {
+    let cancelled = false
+    const effectiveCursor = fetchToken.filterKey === filterKey ? fetchToken.cursor : undefined
+    const label = [
+      ...filters.operator.map((value) => `operator:${value}`),
+      ...filters.operation.map((value) => `operation:${value}`),
+      ...filters.otherLabels,
+    ]
+    scenariosApi.listRuns({
+      limit: PAGE_SIZE,
+      cursor: effectiveCursor,
+      scenario_names: filters.scenarioNames.length > 0 ? filters.scenarioNames : undefined,
+      run_statuses: filters.statuses.length > 0 ? filters.statuses : undefined,
+      label: label.length > 0 ? label : undefined,
+    }).then((response) => {
+      if (cancelled) return
+      setRuns(response.items)
+      setHasMore(response.pagination.has_more)
+      setNextCursor(response.pagination.next_cursor ?? undefined)
+      setSettledFilterKey(filterKey)
+      setError(null)
+      if (!effectiveCursor) setPage(0)
+    }).catch((requestError: unknown) => {
+      if (cancelled) return
+      setRuns([])
+      setHasMore(false)
+      setNextCursor(undefined)
+      setSettledFilterKey(filterKey)
+      setError(toApiError(requestError).detail)
+      if (!effectiveCursor) setPage(0)
+    }).finally(() => {
+      if (!cancelled) setLoading(false)
+    })
+    return () => {
+      cancelled = true
+    }
+  }, [
+    fetchToken,
+    filterKey,
+    filters.scenarioNames,
+    filters.statuses,
+    filters.operator,
+    filters.operation,
+    filters.otherLabels,
+  ])
+
+  const setFilter = <K extends keyof ScenarioHistoryFilters>(
+    key: K,
+    value: ScenarioHistoryFilters[K],
+  ): void => {
+    onFiltersChange({ ...filters, [key]: value })
+  }
+  const hasFilters = filters.scenarioNames.length > 0
+    || filters.statuses.length > 0
+    || filters.operator.length > 0
+    || filters.operation.length > 0
+    || filters.otherLabels.length > 0
+  const filtersPending = settledFilterKey !== filterKey
+  const displayLoading = loading || filtersPending
+
+  return (
+    <main className={styles.root}>
+      <header className={styles.header}>
+        <div className={styles.headerRow}>
+          <Text as="h1" size={500} weight="semibold">Scenario History</Text>
+          <Button
+            className={styles.touchTargetHeight}
+            appearance="subtle"
+            icon={<ArrowSyncRegular />}
+            onClick={() => requestPage()}
+            disabled={displayLoading}
+            data-testid="scenario-history-refresh"
+          >
+            Refresh
+          </Button>
+        </div>
+        <div className={styles.filters}>
+          <FilterRegular />
+          {hasFilters && (
+            <Button
+              className={styles.touchTargetHeight}
+              appearance="subtle"
+              icon={<FilterDismissRegular />}
+              onClick={() => onFiltersChange({ ...DEFAULT_SCENARIO_HISTORY_FILTERS })}
+            >
+              Reset
+            </Button>
+          )}
+          <MultiFilter
+            label="Registered scenario"
+            placeholder="All scenarios"
+            selected={filters.scenarioNames}
+            options={scenarioOptions}
+            onSelect={(values) => setFilter('scenarioNames', values)}
+            testId="scenario-filter"
+            className={styles.filterDropdown}
+          />
+          <MultiFilter
+            label="Run status"
+            placeholder="All statuses"
+            selected={filters.statuses}
+            options={SCENARIO_RUN_STATES}
+            onSelect={(values) => setFilter('statuses', values as ScenarioRunState[])}
+            testId="scenario-status-filter"
+            className={styles.filterDropdown}
+          />
+          <MultiFilter
+            label="Operator"
+            placeholder="All operators"
+            selected={filters.operator}
+            options={operatorOptions}
+            onSelect={(values) => setFilter('operator', values)}
+            testId="scenario-operator-filter"
+            className={styles.filterDropdown}
+          />
+          <MultiFilter
+            label="Operation"
+            placeholder="All operations"
+            selected={filters.operation}
+            options={operationOptions}
+            onSelect={(values) => setFilter('operation', values)}
+            testId="scenario-operation-filter"
+            className={styles.filterDropdown}
+          />
+          <MultiFilter
+            label="Other labels"
+            placeholder="Other labels"
+            selected={filters.otherLabels}
+            options={otherLabelOptions}
+            onSelect={(values) => setFilter('otherLabels', values)}
+            testId="scenario-label-filter"
+            className={styles.filterDropdown}
+          />
+        </div>
+        {optionsError && (
+          <MessageBar intent="warning">
+            <MessageBarBody>{optionsError}</MessageBarBody>
+          </MessageBar>
+        )}
+      </header>
+
+      <div className={styles.content}>
+        {displayLoading ? (
+          <div className={styles.emptyState}><Spinner label="Loading scenario history..." /></div>
+        ) : error ? (
+          <div className={styles.emptyState} data-testid="scenario-history-error">
+            <MessageBar intent="error"><MessageBarBody>{error}</MessageBarBody></MessageBar>
+            <Button appearance="primary" icon={<ArrowSyncRegular />} onClick={() => requestPage()}>
+              Retry
+            </Button>
+          </div>
+        ) : runs.length === 0 ? (
+          <div className={styles.emptyState} data-testid="scenario-history-empty">
+            <Text size={400}>No scenario runs found</Text>
+            <Text>{hasFilters ? 'Try adjusting your filters.' : 'Launch a scenario to see its progress and results here.'}</Text>
+            {!hasFilters && (
+              <Button appearance="primary" icon={<ScriptRegular />} onClick={() => onNavigate('scenarios')}>
+                Browse scenarios
+              </Button>
+            )}
+          </div>
+        ) : (
+          <ScenarioHistoryTable runs={runs} onOpenRun={onOpenRun} />
+        )}
+      </div>
+
+      {!displayLoading && !error && runs.length > 0 && (
+        <div className={styles.pagination}>
+          <Button
+            className={styles.touchTarget}
+            icon={<ArrowLeftRegular />}
+            disabled={page === 0}
+            onClick={() => {
+              setPage(0)
+              requestPage()
+            }}
+          >
+            First
+          </Button>
+          <Text>Page {page + 1}</Text>
+          <Button
+            className={styles.touchTarget}
+            icon={<ArrowRightRegular />}
+            iconPosition="after"
+            disabled={!hasMore || !nextCursor}
+            onClick={() => {
+              if (!nextCursor) return
+              setPage((current) => current + 1)
+              requestPage(nextCursor)
+            }}
+          >
+            Next
+          </Button>
+        </div>
+      )}
+    </main>
+  )
+}
+
+interface ScenarioHistoryTableProps {
+  runs: ScenarioRunListItem[]
+  onOpenRun: (scenarioResultId: string) => void
+}
+
+function ScenarioHistoryTable({ runs, onOpenRun }: ScenarioHistoryTableProps) {
+  const styles = useScenarioHistoryStyles()
+  return (
+    <Table className={styles.table} aria-label="Scenario history" data-testid="scenario-history-table">
+      <TableHeader>
+        <TableRow>
+          <TableHeaderCell>Scenario</TableHeaderCell>
+          <TableHeaderCell>State</TableHeaderCell>
+          <TableHeaderCell>Target</TableHeaderCell>
+          <TableHeaderCell>Created</TableHeaderCell>
+          <TableHeaderCell>Completed / elapsed</TableHeaderCell>
+          <TableHeaderCell>Work</TableHeaderCell>
+          <TableHeaderCell>Success</TableHeaderCell>
+          <TableHeaderCell>Errors / retries</TableHeaderCell>
+          <TableHeaderCell>Labels</TableHeaderCell>
+        </TableRow>
+      </TableHeader>
+      <TableBody>
+        {runs.map((run) => (
+          <TableRow
+            key={run.scenario_result_id}
+            className={styles.clickableRow}
+            data-testid={`scenario-history-row-${run.scenario_result_id}`}
+            onClick={() => onOpenRun(run.scenario_result_id)}
+          >
+            <TableCell>
+              <a
+                href={`/scenario-history/${run.scenario_result_id}`}
+                className={styles.rowLink}
+                aria-label={`Open ${run.scenario_registry_name ?? run.scenario_name} scenario run`}
+                onClick={(event) => {
+                  if (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
+                    event.stopPropagation()
+                    return
+                  }
+                  event.preventDefault()
+                  event.stopPropagation()
+                  onOpenRun(run.scenario_result_id)
+                }}
+              >
+                <span className={styles.identity}>
+                  <Text weight="semibold">{run.scenario_registry_name ?? run.scenario_name}</Text>
+                  <Text size={200} className={styles.secondary}>
+                    {run.scenario_registry_name && run.scenario_registry_name !== run.scenario_name
+                      ? `${run.scenario_name} · v${run.scenario_version}`
+                      : `v${run.scenario_version}`}
+                  </Text>
+                </span>
+              </a>
+            </TableCell>
+            <TableCell><Badge appearance="outline">{formatState(run.status)}</Badge></TableCell>
+            <TableCell>
+              {run.target ? (
+                <Tooltip content={run.target.endpoint ?? run.target.target_type} relationship="label">
+                  <div className={styles.target}>
+                    <Text>{run.target.model_name ?? run.target.target_type}</Text>
+                    <Text size={200} className={mergeClasses(styles.secondary, styles.truncate)}>
+                      {run.target.target_type}
+                    </Text>
+                  </div>
+                </Tooltip>
+              ) : 'Unavailable'}
+            </TableCell>
+            <TableCell className={styles.nowrap}>{formatTimestamp(run.created_at)}</TableCell>
+            <TableCell className={styles.nowrap}>
+              <div className={styles.identity}>
+                <Text>{run.completed_at ? formatTimestamp(run.completed_at) : 'Not yet'}</Text>
+                <Text size={200} className={styles.secondary}>{formatElapsed(run)}</Text>
+              </div>
+            </TableCell>
+            <TableCell className={styles.nowrap}>
+              {run.planned_total_available !== false && run.total_attacks !== null
+                ? `${run.completed_attacks}/${run.total_attacks}`
+                : `${run.completed_attacks} known / total unknown`}
+            </TableCell>
+            <TableCell className={styles.nowrap}>
+              {formatSuccess(run)}
+            </TableCell>
+            <TableCell className={styles.nowrap}>{run.error_attacks} / {run.total_retries}</TableCell>
+            <TableCell>
+              <div className={styles.badges}>
+                {Object.entries(run.labels).map(([key, value]) => (
+                  <Badge key={key} appearance="tint" size="small">{key}: {value}</Badge>
+                ))}
+              </div>
+            </TableCell>
+          </TableRow>
+        ))}
+      </TableBody>
+    </Table>
+  )
+}
+
+function formatState(value: string): string {
+  return value.toLowerCase().replace(/_/g, ' ').replace(/^\w/, (letter: string) => letter.toUpperCase())
+}
+
+function formatTimestamp(value: string): string {
+  return new Date(value).toLocaleString(undefined, {
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  })
+}
+
+function formatElapsed(run: ScenarioRunListItem): string {
+  const start = Date.parse(run.created_at)
+  const end = run.completed_at ? Date.parse(run.completed_at) : Date.now()
+  const seconds = Math.max(0, Math.floor((end - start) / 1000))
+  if (seconds < 60) return `${seconds}s elapsed`
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m elapsed`
+  return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m elapsed`
+}
+
+function formatSuccess(run: ScenarioRunListItem): string {
+  const successful = run.successful_attacks
+  if (run.planned_total_available === false) {
+    return `${successful}/${run.completed_attacks} known results`
+  }
+  if (run.completed_attacks === 0) {
+    return '0/0'
+  }
+  return `${successful}/${run.completed_attacks} (${run.objective_achieved_rate}%)`
+}
diff --git a/frontend/src/components/History/scenarioHistoryFilters.test.ts b/frontend/src/components/History/scenarioHistoryFilters.test.ts
new file mode 100644
index 0000000000..7f3ce048b1
--- /dev/null
+++ b/frontend/src/components/History/scenarioHistoryFilters.test.ts
@@ -0,0 +1,57 @@
+import {
+  DEFAULT_SCENARIO_HISTORY_FILTERS,
+  SCENARIO_RUN_STATES,
+  scenarioHistoryFiltersFromSearchParams,
+  scenarioHistoryFiltersToSearchParams,
+} from './scenarioHistoryFilters'
+
+describe('scenario history URL filters', () => {
+  it('round-trips repeated filters and label search text', () => {
+    const filters = {
+      scenarioNames: ['red.team', 'benchmark'],
+      statuses: ['IN_PROGRESS', 'FAILED'] as const,
+      operator: ['alice', 'bob'],
+      operation: ['nightly'],
+      otherLabels: ['team:security', 'team:safety'],
+      labelSearchText: 'team',
+    }
+
+    const params = scenarioHistoryFiltersToSearchParams({
+      ...filters,
+      statuses: [...filters.statuses],
+    })
+
+    expect(params.getAll('scenario')).toEqual(['red.team', 'benchmark'])
+    expect(params.getAll('status')).toEqual(['IN_PROGRESS', 'FAILED'])
+    expect(scenarioHistoryFiltersFromSearchParams(params)).toEqual({
+      ...filters,
+      statuses: [...filters.statuses],
+    })
+  })
+
+  it('ignores synthetic and invalid run states without dropping valid filters', () => {
+    const params = new URLSearchParams('status=COMPLETED&status=QUEUED&status=UNKNOWN&operator=alice')
+
+    expect(scenarioHistoryFiltersFromSearchParams(params)).toEqual({
+      ...DEFAULT_SCENARIO_HISTORY_FILTERS,
+      statuses: ['COMPLETED'],
+      operator: ['alice'],
+    })
+  })
+
+  it('round-trips every persisted run state', () => {
+    const filters = {
+      ...DEFAULT_SCENARIO_HISTORY_FILTERS,
+      statuses: [...SCENARIO_RUN_STATES],
+    }
+
+    const params = scenarioHistoryFiltersToSearchParams(filters)
+
+    expect(params.getAll('status')).toEqual(SCENARIO_RUN_STATES)
+    expect(scenarioHistoryFiltersFromSearchParams(params)).toEqual(filters)
+  })
+
+  it('omits empty filters from the URL', () => {
+    expect(scenarioHistoryFiltersToSearchParams(DEFAULT_SCENARIO_HISTORY_FILTERS).toString()).toBe('')
+  })
+})
diff --git a/frontend/src/components/History/scenarioHistoryFilters.ts b/frontend/src/components/History/scenarioHistoryFilters.ts
new file mode 100644
index 0000000000..3f78640d6a
--- /dev/null
+++ b/frontend/src/components/History/scenarioHistoryFilters.ts
@@ -0,0 +1,58 @@
+import type { ScenarioRunState } from '@/types'
+
+export interface ScenarioHistoryFilters {
+  scenarioNames: string[]
+  statuses: ScenarioRunState[]
+  operator: string[]
+  operation: string[]
+  otherLabels: string[]
+  labelSearchText: string
+}
+
+export const DEFAULT_SCENARIO_HISTORY_FILTERS: ScenarioHistoryFilters = {
+  scenarioNames: [],
+  statuses: [],
+  operator: [],
+  operation: [],
+  otherLabels: [],
+  labelSearchText: '',
+}
+
+export const SCENARIO_RUN_STATES: readonly ScenarioRunState[] = [
+  'CREATED',
+  'IN_PROGRESS',
+  'COMPLETED',
+  'FAILED',
+  'CANCELLED',
+]
+
+const RUN_STATES = new Set<string>(SCENARIO_RUN_STATES)
+
+export function scenarioHistoryFiltersFromSearchParams(
+  params: URLSearchParams,
+): ScenarioHistoryFilters {
+  const statuses = params
+    .getAll('status')
+    .filter((status): status is ScenarioRunState => RUN_STATES.has(status))
+  return {
+    scenarioNames: params.getAll('scenario'),
+    statuses,
+    operator: params.getAll('operator'),
+    operation: params.getAll('operation'),
+    otherLabels: params.getAll('label'),
+    labelSearchText: params.get('labelSearch') ?? '',
+  }
+}
+
+export function scenarioHistoryFiltersToSearchParams(
+  filters: ScenarioHistoryFilters,
+): URLSearchParams {
+  const params = new URLSearchParams()
+  for (const scenarioName of filters.scenarioNames) params.append('scenario', scenarioName)
+  for (const status of filters.statuses) params.append('status', status)
+  for (const operator of filters.operator) params.append('operator', operator)
+  for (const operation of filters.operation) params.append('operation', operation)
+  for (const label of filters.otherLabels) params.append('label', label)
+  if (filters.labelSearchText) params.set('labelSearch', filters.labelSearchText)
+  return params
+}
diff --git a/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx b/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx
index 4c3c772308..3d34013d48 100644
--- a/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx
@@ -141,6 +141,35 @@ describe('ScenarioRunPage', () => {
     expect(screen.queryByRole('columnheader', { name: 'Actions' })).not.toBeInTheDocument()
   })
 
+  it('renders contract-backed safe target and run configuration metadata', () => {
+    mockHookState(makeState({
+      run: {
+        ...makeState().run!,
+        target: {
+          target_type: 'OpenAIChatTarget',
+          endpoint: 'https://example.test/v1',
+          model_name: 'gpt-4o',
+          identifier_hash: 'safe-hash',
+        },
+        techniques_used: ['Technique One'],
+        datasets_used: ['harmbench'],
+        scenario_parameters: { max_turns: 5 },
+        labels: { operator: 'alice' },
+        pyrit_version: '0.10.0',
+      },
+    }))
+
+    renderPage()
+
+    expect(screen.getByText('gpt-4o')).toBeInTheDocument()
+    expect(screen.getByText('https://example.test/v1')).toBeInTheDocument()
+    expect(screen.getByText('safe-hash')).toBeInTheDocument()
+    expect(screen.getByText('harmbench')).toBeInTheDocument()
+    expect(screen.getByText('max_turns: 5')).toBeInTheDocument()
+    expect(screen.getByText('operator: alice')).toBeInTheDocument()
+    expect(screen.getByText('0.10.0')).toBeInTheDocument()
+  })
+
   it('keeps legacy runs useful without misleading totals, ETA, or a progress bar', () => {
     mockHookState(makeState({ planComplete: false }))
 
diff --git a/frontend/src/components/Scenarios/ScenarioRunPage.tsx b/frontend/src/components/Scenarios/ScenarioRunPage.tsx
index b2516de87e..fa21c5dee4 100644
--- a/frontend/src/components/Scenarios/ScenarioRunPage.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunPage.tsx
@@ -33,7 +33,7 @@ import {
   EyeRegular,
   StopRegular,
 } from '@fluentui/react-icons'
-import { Link, useNavigate, useParams } from 'react-router'
+import { Link, useLocation, useNavigate, useParams } from 'react-router'
 
 import { useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
 import { scenariosApi } from '@/services/api'
@@ -64,6 +64,7 @@ const INTERACTIVE_ELEMENT_SELECTOR = 'a, button, input, select, textarea, [role=
 
 const RUN_BADGE_COLORS: Record<ScenarioRunState, 'informative' | 'brand' | 'success' | 'danger' | 'warning'> = {
   CREATED: 'informative',
+  QUEUED: 'informative',
   IN_PROGRESS: 'brand',
   COMPLETED: 'success',
   FAILED: 'danger',
@@ -88,6 +89,7 @@ interface ScenarioRunPageContentProps {
 
 function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProps) {
   const styles = useScenarioRunPageStyles()
+  const location = useLocation()
   const navigate = useNavigate()
   const { state, retry, applyRunSummary } = useScenarioRunProgress(scenarioResultId)
   const [nowMilliseconds, setNowMilliseconds] = useState(() => Date.now())
@@ -96,6 +98,19 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
   const [cancelError, setCancelError] = useState<string | null>(null)
   const [selectedAttempt, setSelectedAttempt] = useState<ScenarioProgressResult | null>(null)
   const detailsTriggerRef = useRef<HTMLButtonElement | null>(null)
+  const navigationState = location.state as {
+    fromScenarioHistory?: boolean
+    scenarioHistorySearch?: string
+    scenarioName?: string
+  } | null
+  const backPath = navigationState?.fromScenarioHistory
+    ? `/scenario-history${navigationState.scenarioHistorySearch ?? ''}`
+    : navigationState?.scenarioName
+      ? `/scanner/${encodeURIComponent(navigationState.scenarioName)}`
+      : '/scenario-history'
+  const backLabel = navigationState?.scenarioName && !navigationState.fromScenarioHistory
+    ? 'Back to scenario'
+    : 'Back to scenario history'
 
   const overall = useMemo(() => getOverallProgress(state), [state])
   const techniques = useMemo(() => getTechniqueRollups(state), [state])
@@ -149,8 +164,8 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
     return (
       <main className={styles.root} data-testid="scenario-run-page">
         <div className={styles.content}>
-          <Link to="/scanner" className={styles.backLink}>
-            <ArrowLeftRegular /> Back to scanners
+          <Link to={backPath} className={styles.backLink}>
+            <ArrowLeftRegular /> {backLabel}
           </Link>
           <div className={styles.centeredState} aria-label="Loading scenario run">
             <Skeleton className={styles.loadingBlock}>
@@ -171,8 +186,8 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
     return (
       <main className={styles.root} data-testid="scenario-run-page">
         <div className={styles.content}>
-          <Link to="/scanner" className={styles.backLink}>
-            <ArrowLeftRegular /> Back to scanners
+          <Link to={backPath} className={styles.backLink}>
+            <ArrowLeftRegular /> {backLabel}
           </Link>
           <div className={styles.centeredState}>
             <ErrorCircleRegular fontSize={32} />
@@ -191,8 +206,8 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
     return (
       <main className={styles.root} data-testid="scenario-run-page">
         <div className={styles.content}>
-          <Link to="/scanner" className={styles.backLink}>
-            <ArrowLeftRegular /> Back to scanners
+          <Link to={backPath} className={styles.backLink}>
+            <ArrowLeftRegular /> {backLabel}
           </Link>
           <div className={styles.centeredState}>
             <ErrorCircleRegular fontSize={32} />
@@ -222,8 +237,8 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
   return (
     <main className={styles.root} data-testid="scenario-run-page">
       <div className={styles.content}>
-        <Link to="/scanner" className={styles.backLink}>
-          <ArrowLeftRegular /> Back to scanners
+        <Link to={backPath} className={styles.backLink}>
+          <ArrowLeftRegular /> {backLabel}
         </Link>
 
         <header className={styles.header}>
@@ -278,8 +293,52 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
             <Text size={200} className={styles.metadataLabel}>Completed</Text>
             <Text weight="semibold">{run.completed_at ? formatTimestamp(run.completed_at) : 'Not yet'}</Text>
           </div>
+          {run.target && (
+            <div className={styles.metadataItem}>
+              <Text size={200} className={styles.metadataLabel}>Target</Text>
+              <Text weight="semibold">{run.target.model_name ?? run.target.target_type}</Text>
+              <Text size={200} className={styles.sectionHint}>{run.target.target_type}</Text>
+            </div>
+          )}
+          {run.pyrit_version && (
+            <div className={styles.metadataItem}>
+              <Text size={200} className={styles.metadataLabel}>PyRIT version</Text>
+              <Text weight="semibold">{run.pyrit_version}</Text>
+            </div>
+          )}
         </div>
 
+        <section className={styles.section} aria-labelledby="run-configuration-heading">
+          <div className={styles.sectionHeading}>
+            <Text as="h2" id="run-configuration-heading" size={500} weight="semibold">
+              Run configuration
+            </Text>
+            <Text className={styles.sectionHint}>Persisted, secret-free settings for this run.</Text>
+          </div>
+          <div className={styles.summaryGrid}>
+            <ConfigurationItem
+              label="Techniques"
+              value={(run.techniques_used?.length ?? 0) > 0 ? run.techniques_used?.join(', ') ?? '' : 'Unavailable'}
+            />
+            <ConfigurationItem
+              label="Datasets"
+              value={(run.datasets_used?.length ?? 0) > 0 ? run.datasets_used?.join(', ') ?? '' : 'Unavailable'}
+            />
+            <ConfigurationItem
+              label="Scenario parameters"
+              value={formatConfiguration(run.scenario_parameters ?? {})}
+            />
+            <ConfigurationItem
+              label="Labels"
+              value={formatConfiguration(run.labels ?? {})}
+            />
+            {run.target?.endpoint && <ConfigurationItem label="Target endpoint" value={run.target.endpoint} />}
+            {run.target?.identifier_hash && (
+              <ConfigurationItem label="Target identifier" value={run.target.identifier_hash} />
+            )}
+          </div>
+        </section>
+
         {state.stale && (
           <MessageBar intent="warning">
             <MessageBarBody>
@@ -663,6 +722,21 @@ interface MetricProps {
   readonly value: string
 }
 
+interface ConfigurationItemProps {
+  readonly label: string
+  readonly value: string
+}
+
+function ConfigurationItem({ label, value }: ConfigurationItemProps) {
+  const styles = useScenarioRunPageStyles()
+  return (
+    <article className={styles.summaryItem}>
+      <Text size={200} className={styles.metadataLabel}>{label}</Text>
+      <Text className={styles.objective}>{value}</Text>
+    </article>
+  )
+}
+
 function Metric({ label, value }: MetricProps) {
   const styles = useScenarioRunPageStyles()
   return (
@@ -727,6 +801,7 @@ function formatTimestamp(timestamp: string): string {
   if (Number.isNaN(date.getTime())) {
     return 'Unavailable'
   }
+
   return date.toLocaleString(undefined, {
     month: 'short',
     day: 'numeric',
@@ -737,6 +812,16 @@ function formatTimestamp(timestamp: string): string {
   })
 }
 
+function formatConfiguration(value: Record<string, unknown>): string {
+  const entries = Object.entries(value)
+  if (entries.length === 0) {
+    return 'None'
+  }
+  return entries
+    .map(([key, item]) => `${key}: ${typeof item === 'string' ? item : JSON.stringify(item)}`)
+    .join(', ')
+}
+
 function formatDuration(milliseconds: number): string {
   if (!Number.isFinite(milliseconds) || milliseconds < 0) {
     return 'Unavailable'
diff --git a/frontend/src/components/Sidebar/Navigation.test.tsx b/frontend/src/components/Sidebar/Navigation.test.tsx
index e85813e3bd..8c61db38ae 100644
--- a/frontend/src/components/Sidebar/Navigation.test.tsx
+++ b/frontend/src/components/Sidebar/Navigation.test.tsx
@@ -126,7 +126,7 @@ describe("Navigation", () => {
     ).toBeInTheDocument();
   });
 
-  it("places Scanner immediately after Attack History without a history placeholder", () => {
+  it("renders the final primary navigation order", () => {
     renderWithProvider(<Navigation {...defaultProps} />);
     const navigation = screen.getByRole("navigation", { name: "Primary" });
     const labels = within(navigation)
@@ -138,11 +138,28 @@ describe("Navigation", () => {
       "Chat",
       "Attack History",
       "Scanner",
+      "Scenario History",
       "Targets",
       "Initializers",
       "Configuration",
     ]);
-    expect(screen.queryByRole("button", { name: "Scenario History" })).not.toBeInTheDocument();
+  });
+
+  it("marks Scenario History current and navigates to its dedicated view", async () => {
+    const user = userEvent.setup();
+    const onNavigate = jest.fn();
+    renderWithProvider(
+      <Navigation
+        {...defaultProps}
+        currentView="scenarioHistory"
+        onNavigate={onNavigate}
+      />,
+    );
+
+    const button = screen.getByRole("button", { name: "Scenario History" });
+    expect(button).toHaveAttribute("aria-current", "page");
+    await user.click(button);
+    expect(onNavigate).toHaveBeenCalledWith("scenarioHistory");
   });
 
   it("calls onNavigate with 'scenarios' when the scenarios button is clicked", async () => {
diff --git a/frontend/src/components/Sidebar/Navigation.tsx b/frontend/src/components/Sidebar/Navigation.tsx
index 816eb40fe7..7ba48fb620 100644
--- a/frontend/src/components/Sidebar/Navigation.tsx
+++ b/frontend/src/components/Sidebar/Navigation.tsx
@@ -15,6 +15,7 @@ import {
   HistoryRegular,
   PersonFeedbackRegular,
   ScriptRegular,
+  TableRegular,
   WrenchRegular,
   OpenRegular,
   WeatherMoonRegular,
@@ -32,6 +33,7 @@ export type ViewName =
   | 'targets'
   | 'initializers'
   | 'configuration'
+  | 'scenarioHistory'
   | 'scenarios'
 
 interface NavigationProps {
@@ -120,6 +122,16 @@ export default function Navigation({
           onClick={() => onNavigate('scenarios')}
         />
 
+        <Button
+          className={styles.navButton}
+          data-active={currentView === 'scenarioHistory'}
+          appearance="subtle"
+          icon={<TableRegular />}
+          title="Scenario History"
+          aria-label="Scenario History"
+          aria-current={currentView === 'scenarioHistory' ? 'page' : undefined}
+          onClick={() => onNavigate('scenarioHistory')}
+        />
         <Button
           className={styles.navButton}
           data-active={currentView === 'targets'}
diff --git a/frontend/src/services/api.test.ts b/frontend/src/services/api.test.ts
index ee1e72c2e9..9de3b57847 100644
--- a/frontend/src/services/api.test.ts
+++ b/frontend/src/services/api.test.ts
@@ -742,6 +742,32 @@ describe("api service", () => {
       expect(result.status).toBe("IN_PROGRESS");
     });
 
+    it("lists scenario history with repeated array query parameters", async () => {
+      const mockResponse = {
+        data: { items: [], pagination: { limit: 10, has_more: false } },
+      };
+      (apiClient.get as jest.Mock).mockResolvedValueOnce(mockResponse);
+
+      await scenariosApi.listRuns({
+        limit: 10,
+        cursor: "history-cursor",
+        scenario_names: ["first.scenario", "second.scenario"],
+        run_statuses: ["IN_PROGRESS", "FAILED"],
+        label: ["operator:alice", "operator:bob", "team:safety"],
+      });
+
+      expect(apiClient.get).toHaveBeenCalledWith("/scenarios/runs", {
+        params: {
+          limit: 10,
+          cursor: "history-cursor",
+          scenario_names: ["first.scenario", "second.scenario"],
+          run_statuses: ["IN_PROGRESS", "FAILED"],
+          label: ["operator:alice", "operator:bob", "team:safety"],
+        },
+        paramsSerializer: { indexes: null },
+      });
+    });
+
     it("gets scenario run progress with since/limit query params", async () => {
       const mockResponse = {
         data: {
diff --git a/frontend/src/services/api.ts b/frontend/src/services/api.ts
index 4238e04013..e8d92de2c4 100644
--- a/frontend/src/services/api.ts
+++ b/frontend/src/services/api.ts
@@ -36,7 +36,9 @@ import type {
   ScenarioRunSizeEstimateResponse,
   ScenarioRunSizeEstimateRequest,
   ScenarioRunSummary,
+  ScenarioRunListResponse,
   ScenarioRunProgress,
+  ScenarioRunState,
   ConfigurationFileContent,
   EnvironmentFileContent,
   UpdateEnvironmentFileRequest,
@@ -398,7 +400,9 @@ export const attacksApi = {
 }
 
 export const labelsApi = {
-  getLabels: async (source: string = 'attacks'): Promise<{ source: string; labels: Record<string, string[]> }> => {
+  getLabels: async (
+    source: 'attacks' | 'scenarios' = 'attacks',
+  ): Promise<{ source: string; labels: Record<string, string[]> }> => {
     const response = await apiClient.get('/labels', { params: { source } })
     return response.data
   },
@@ -454,6 +458,22 @@ export const scenariosApi = {
     return response.data
   },
 
+  listRuns: async (params?: {
+    limit?: number
+    cursor?: string
+    scenario_names?: string[]
+    run_statuses?: ScenarioRunState[]
+    label?: string[]
+  }): Promise<ScenarioRunListResponse> => {
+    const response = await apiClient.get('/scenarios/runs', {
+      params,
+      paramsSerializer: {
+        indexes: null,
+      },
+    })
+    return response.data
+  },
+
   getRunProgress: async (
     scenarioResultId: string,
     params?: { since?: string; limit?: number },
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 3d5d188868..0bfba6837a 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -679,7 +679,7 @@ export interface AttackRetrySummary {
   retries: RetryEvent[]
 }
 
-export type ScenarioRunState = 'CREATED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'CANCELLED'
+export type ScenarioRunState = 'CREATED' | 'QUEUED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'CANCELLED'
 
 export interface ScenarioRunSummary {
   scenario_result_id: string
@@ -700,6 +700,53 @@ export interface ScenarioRunSummary {
   total_retries: number
   labels: Record<string, string>
   completed_at?: string | null
+  pyrit_version?: string | null
+  target?: ScenarioTargetSummary | null
+  datasets_used?: string[]
+  scenario_parameters?: Record<string, unknown>
+  planned_total_available?: boolean
+  successful_attacks?: number
+  error_attacks?: number
+  attack_details_available?: boolean
+}
+
+export interface ScenarioTargetSummary {
+  target_type: string
+  endpoint?: string | null
+  model_name?: string | null
+  identifier_hash?: string | null
+}
+
+export interface ScenarioRunListItem {
+  scenario_result_id: string
+  scenario_name: string
+  scenario_registry_name?: string | null
+  scenario_version: number
+  status: ScenarioRunState
+  created_at: string
+  updated_at: string
+  error?: string | null
+  error_type?: string | null
+  techniques_used: string[]
+  total_attacks: number | null
+  completed_attacks: number
+  objective_achieved_rate: number
+  total_retries: number
+  labels: Record<string, string>
+  completed_at?: string | null
+  pyrit_version?: string | null
+  target?: ScenarioTargetSummary | null
+  datasets_used: string[]
+  scenario_parameters: Record<string, unknown>
+  planned_total_available: boolean
+  successful_attacks: number
+  error_attacks: number
+  attack_details_available: boolean
+}
+
+export interface ScenarioRunListResponse {
+  items: ScenarioRunListItem[]
+  pagination: PaginationInfo
 }
 
 /** Compact persisted run header returned by the progress endpoint. */
@@ -711,6 +758,12 @@ export interface ScenarioProgressHeader {
   status: ScenarioRunState
   created_at: string
   completed_at?: string | null
+  pyrit_version?: string | null
+  target?: ScenarioTargetSummary | null
+  techniques_used?: string[]
+  datasets_used?: string[]
+  scenario_parameters?: Record<string, unknown>
+  labels?: Record<string, string>
 }
 
 /** One persisted attack attempt in ascending progress order. */
diff --git a/frontend/src/utils/scenarioRunProgress.ts b/frontend/src/utils/scenarioRunProgress.ts
index 3b8d3fbe23..bac819f9c6 100644
--- a/frontend/src/utils/scenarioRunProgress.ts
+++ b/frontend/src/utils/scenarioRunProgress.ts
@@ -132,6 +132,12 @@ export function scenarioRunProgressReducer(
         status: action.run.status,
         created_at: action.run.created_at,
         completed_at: action.run.completed_at,
+        pyrit_version: action.run.pyrit_version,
+        target: action.run.target,
+        techniques_used: action.run.techniques_used,
+        datasets_used: action.run.datasets_used ?? [],
+        scenario_parameters: action.run.scenario_parameters ?? {},
+        labels: action.run.labels,
       },
       activeAtomicGroupIds: [],
       error: null,
diff --git a/pyrit/backend/models/scenarios.py b/pyrit/backend/models/scenarios.py
index 820133367d..9dfc075203 100644
--- a/pyrit/backend/models/scenarios.py
+++ b/pyrit/backend/models/scenarios.py
@@ -32,3 +32,7 @@ class ScenarioRunListResponse(BaseModel):
     """Response for listing scenario runs."""
 
     items: list[ScenarioRunListItem] = Field(..., description="List of scenario runs")
+    pagination: PaginationInfo = Field(
+        default_factory=lambda: PaginationInfo(limit=100, has_more=False),
+        description="Pagination metadata",
+    )
diff --git a/pyrit/backend/routes/labels.py b/pyrit/backend/routes/labels.py
index 71ad775a5a..167e87a631 100644
--- a/pyrit/backend/routes/labels.py
+++ b/pyrit/backend/routes/labels.py
@@ -11,6 +11,7 @@
 
 from fastapi import APIRouter, Query
 from pydantic import BaseModel, Field
+from starlette.concurrency import run_in_threadpool
 
 from pyrit.memory import CentralMemory
 
@@ -29,9 +30,9 @@ class LabelOptionsResponse(BaseModel):
     response_model=LabelOptionsResponse,
 )
 async def get_label_options(  # pyrit-async-suffix-exempt
-    source: Literal["attacks"] = Query(
+    source: Literal["attacks", "scenarios"] = Query(
         "attacks",
-        description="Source type to get labels from. Currently only 'attacks' is supported.",
+        description="Source type to get labels from.",
     ),
 ) -> LabelOptionsResponse:
     """
@@ -48,6 +49,7 @@ async def get_label_options(  # pyrit-async-suffix-exempt
     """
     memory = CentralMemory.get_memory_instance()
 
-    labels = memory.get_unique_attack_labels() if source == "attacks" else {}
+    label_loader = memory.get_unique_attack_labels if source == "attacks" else memory.get_unique_scenario_labels
+    labels = await run_in_threadpool(label_loader)
 
     return LabelOptionsResponse(source=source, labels=labels)
diff --git a/pyrit/backend/routes/scenarios.py b/pyrit/backend/routes/scenarios.py
index 117e47712d..34e1372dbc 100644
--- a/pyrit/backend/routes/scenarios.py
+++ b/pyrit/backend/routes/scenarios.py
@@ -22,7 +22,7 @@
 )
 from pyrit.backend.services.scenario_run_service import get_scenario_run_service
 from pyrit.backend.services.scenario_service import get_scenario_service
-from pyrit.models import ScenarioResult
+from pyrit.models import ScenarioResult, ScenarioRunState
 from pyrit.models.catalog.scenario import (
     RegisteredScenario,
     RunScenarioRequest,
@@ -35,6 +35,25 @@
 router = APIRouter(prefix="/scenarios", tags=["scenarios"])
 
 
+def _parse_labels(label_params: list[str] | None) -> dict[str, list[str]] | None:
+    """
+    Parse repeated key:value label filters with OR-within-key semantics.
+
+    Returns:
+        dict[str, str | list[str]] | None: Grouped effective label filters.
+    """
+    labels: dict[str, list[str]] = {}
+    for param in label_params or []:
+        if ":" not in param:
+            continue
+        key, value = param.split(":", 1)
+        key = key.strip()
+        value = value.strip()
+        if key and value:
+            labels.setdefault(key, []).append(value)
+    return labels or None
+
+
 # ============================================================================
 # Scenario Catalog
 # ============================================================================
@@ -170,20 +189,48 @@ async def start_scenario_run(request: RunScenarioRequest) -> ScenarioRunSummary:
     "/runs",
     response_model=ScenarioRunListResponse,
 )
-async def list_scenario_runs(
-    limit: int = Query(100, ge=1, le=100),
-) -> ScenarioRunListResponse:  # pyrit-async-suffix-exempt
+async def list_scenario_runs(  # pyrit-async-suffix-exempt
+    *,
+    scenario_names: list[str] | None = Query(
+        None,
+        description="Registered or persisted scenario names; repeated values are OR-matched.",
+    ),
+    run_statuses: list[ScenarioRunState] | None = Query(
+        None,
+        description="Run states; repeated values are OR-matched.",
+    ),
+    label: list[str] | None = Query(
+        None,
+        description="key:value labels; OR within a key and AND across keys.",
+    ),
+    limit: int = Query(100, ge=1, le=100, description="Maximum items per page"),
+    cursor: str | None = Query(None, description="Opaque descending history cursor"),
+) -> ScenarioRunListResponse:
     """
     List tracked scenario runs (most recent first).
 
     Args:
-        limit (int): Maximum number of runs to return. Defaults to 100.
+        scenario_names: Registered or persisted scenario names to match.
+        run_statuses: Run states to match.
+        label: Repeated key:value label filters.
+        limit: Maximum number of runs to return.
+        cursor: Opaque cursor from the previous page.
 
     Returns:
         ScenarioRunListResponse: Runs, most recent first.
     """
     service = get_scenario_run_service()
-    return await run_in_threadpool(service.list_runs, limit=limit)
+    try:
+        return await run_in_threadpool(
+            service.list_runs,
+            scenario_names=scenario_names,
+            statuses=run_statuses,
+            labels=_parse_labels(label),
+            limit=limit,
+            cursor=cursor,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from None
 
 
 @router.get(
diff --git a/pyrit/backend/services/scenario_run_service.py b/pyrit/backend/services/scenario_run_service.py
index c635dab06f..eca4d095af 100644
--- a/pyrit/backend/services/scenario_run_service.py
+++ b/pyrit/backend/services/scenario_run_service.py
@@ -10,19 +10,30 @@
 
 import asyncio
 import base64
+import binascii
 import contextlib
+import hashlib
 import json
 import logging
 import uuid
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import Any
+from urllib.parse import urlsplit, urlunsplit
 
+from pydantic import TypeAdapter, ValidationError
+
+from pyrit.backend.models.common import PaginationInfo, filter_sensitive_fields
 from pyrit.backend.models.scenarios import ScenarioRunListResponse
 from pyrit.backend.services.scenario_configuration_resolver import ScenarioConfigurationResolver
 from pyrit.common.utils import to_sha256
 from pyrit.memory import AttackResultKeysetCursor, CentralMemory
+from pyrit.memory.memory_interface import (
+    ScenarioHistoryKeysetCursor,
+    ScenarioHistoryRunRecord,
+    ScenarioHistoryUnitRecord,
+)
 from pyrit.models import (
     SCENARIO_RUN_PLAN_METADATA_KEY,
     AtomicAttackIdentifier,
@@ -30,6 +41,7 @@
     AttackResult,
     ComponentIdentifier,
     ScenarioAttackResultDelta,
+    ScenarioIdentifier,
     ScenarioProgressHeader,
     ScenarioProgressResult,
     ScenarioResult,
@@ -38,6 +50,7 @@
     ScenarioRunPlanSeedGroup,
     ScenarioRunProgress,
     ScenarioRunState,
+    TargetIdentifier,
     config_hash,
 )
 from pyrit.models.catalog.scenario import (
@@ -46,6 +59,7 @@
     RunScenarioRequest,
     ScenarioRunListItem,
     ScenarioRunSummary,
+    ScenarioTargetSummary,
 )
 from pyrit.registry import InitializerRegistry, ScenarioRegistry
 from pyrit.scenario import Scenario
@@ -54,6 +68,21 @@
 
 _DEFAULT_MAX_CONCURRENT_RUNS = 3
 
+_SAFE_SCENARIO_PARAMETER_NAMES = frozenset(
+    {
+        "adversarial_targets",
+        "jailbreak_names",
+        "max_attempts_per_objective",
+        "max_turns",
+        "num_jailbreak_attempts",
+        "num_jailbreaks",
+        "sub_harm",
+        "version",
+    }
+)
+_HISTORY_ATOMIC_GROUPS_ADAPTER = TypeAdapter(list[ScenarioRunPlanAtomicGroup])
+_HISTORY_SEED_ID_MAP_ADAPTER = TypeAdapter(list[dict[str, str]])
+
 
 @dataclass
 class _ActiveTask:
@@ -269,19 +298,77 @@ def get_run_from_storage(
         """
         return self._build_response(scenario_result_id=scenario_result_id, active_error=active_error)
 
-    def list_runs(self, *, limit: int = 100) -> ScenarioRunListResponse:
+    def list_runs(
+        self,
+        *,
+        scenario_names: Sequence[str] | None = None,
+        statuses: Sequence[ScenarioRunState | str] | None = None,
+        labels: Mapping[str, str | Sequence[str]] | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> ScenarioRunListResponse:
         """
         List scenario runs by querying the database (most recent first).
 
         Args:
-            limit (int): Maximum number of runs to return. Defaults to 100.
+            scenario_names: Registered or persisted scenario names to match.
+            statuses: Run states to match.
+            labels: Labels with OR-within-key and AND-across-key semantics.
+            limit: Maximum number of runs to return.
+            cursor: Opaque cursor from the previous page.
 
         Returns:
             ScenarioRunListResponse with runs.
         """
-        results = self._memory.get_scenario_result_headers(limit=limit)
-        items = [self._build_list_response_from_header(scenario_result=result) for result in results]
-        return ScenarioRunListResponse(items=items)
+        normalized_names = sorted({name.strip() for name in scenario_names or [] if name.strip()})
+        normalized_statuses = sorted(
+            {
+                status.value if isinstance(status, ScenarioRunState) else str(status).strip().upper()
+                for status in statuses or []
+                if str(status).strip()
+            }
+        )
+        normalized_labels = self._normalize_history_labels(labels=labels)
+        fingerprint = self._history_filter_fingerprint(
+            scenario_names=normalized_names,
+            statuses=normalized_statuses,
+            labels=normalized_labels,
+        )
+        after = self._decode_history_cursor(cursor=cursor, fingerprint=fingerprint)
+        records, units_by_run, has_more = self._memory.get_scenario_run_history_page(
+            scenario_names=normalized_names,
+            statuses=normalized_statuses,
+            labels=normalized_labels,
+            cursor=after,
+            limit=limit,
+        )
+        items = [
+            self._build_history_summary(
+                record=record,
+                units=units_by_run.get(record.scenario_result_id, []),
+            )
+            for record in records
+        ]
+        next_cursor = (
+            self._encode_history_cursor(
+                cursor=ScenarioHistoryKeysetCursor(
+                    timestamp=records[-1].created_at,
+                    scenario_result_id=records[-1].scenario_result_id,
+                ),
+                fingerprint=fingerprint,
+            )
+            if has_more and records
+            else None
+        )
+        return ScenarioRunListResponse(
+            items=items,
+            pagination=PaginationInfo(
+                limit=limit,
+                has_more=has_more,
+                next_cursor=next_cursor,
+                prev_cursor=cursor,
+            ),
+        )
 
     def _build_list_response_from_header(self, *, scenario_result: ScenarioResult) -> ScenarioRunListItem:
         """
@@ -320,6 +407,7 @@ def _build_list_response_from_header(self, *, scenario_result: ScenarioResult) -
             total_attacks=total_attacks,
             labels=scenario_result.labels,
             completed_at=scenario_result.completion_time if terminal else None,
+            planned_total_available=plan is not None,
         )
 
     async def cancel_run_async(self, *, scenario_result_id: str) -> ScenarioRunSummary | None:
@@ -508,11 +596,18 @@ def _build_response_from_db(
             ScenarioRunState.FAILED,
             ScenarioRunState.CANCELLED,
         )
-        plan = self._load_run_plan(scenario_result=scenario_result)
+        try:
+            plan = self._load_run_plan(scenario_result=scenario_result)
+        except (ValidationError, ValueError):
+            logger.warning(
+                "Scenario run %s has invalid persisted plan metadata; using legacy run detail fields.",
+                scenario_result_id,
+            )
+            plan = None
         plan_lookup = _ScenarioPlanLookup.from_plan(plan=plan)
 
         # Build result fields from DB (always computed so in-progress runs show progress)
-        total_attacks, completed_attacks, objective_achieved_rate = self._calculate_progress_counts(
+        total_attacks, completed_attacks, objective_achieved_rate, successful_attacks = self._calculate_progress_counts(
             scenario_result=scenario_result,
             plan=plan,
             plan_lookup=plan_lookup,
@@ -522,6 +617,9 @@ def _build_response_from_db(
             if plan is not None
             else scenario_result.get_techniques_used()
         )
+        target, datasets_used, scenario_parameters = self._safe_run_metadata(
+            scenario_identifier=getattr(scenario_result, "scenario_identifier", None)
+        )
 
         # Surface per-attack errors and retry pressure regardless of overall run status:
         # a COMPLETED scenario can still hide errored objectives or rate-limit retries.
@@ -586,6 +684,387 @@ def _build_response_from_db(
             total_retries=total_retries,
             labels=scenario_result.labels,
             completed_at=scenario_result.completion_time if terminal else None,
+            pyrit_version=(
+                scenario_result.pyrit_version
+                if isinstance(getattr(scenario_result, "pyrit_version", None), str)
+                else None
+            ),
+            target=target,
+            datasets_used=datasets_used,
+            scenario_parameters=scenario_parameters,
+            planned_total_available=plan is not None,
+            successful_attacks=successful_attacks,
+            error_attacks=len(failed_attacks),
+        )
+
+    def _build_history_summary(
+        self,
+        *,
+        record: ScenarioHistoryRunRecord,
+        units: list[ScenarioHistoryUnitRecord],
+    ) -> ScenarioRunListItem:
+        """
+        Map lightweight persisted history projections to the public summary DTO.
+
+        Returns:
+            ScenarioRunListItem: Safe, aggregated history summary.
+        """
+        scenario_identifier = None
+        try:
+            scenario_identifier = ScenarioIdentifier.from_component_identifier(
+                ComponentIdentifier.model_validate(
+                    {**record.scenario_identifier, "pyrit_version": record.pyrit_version}
+                )
+            )
+        except (ValidationError, ValueError):
+            logger.warning(
+                "Scenario run %s has invalid persisted identifier metadata; using legacy history fields.",
+                record.scenario_result_id,
+            )
+        atomic_groups = None
+        seed_id_by_objective_hash: dict[str, str] = {}
+        if record.plan_atomic_groups is not None:
+            try:
+                raw_atomic_groups = (
+                    json.loads(record.plan_atomic_groups)
+                    if isinstance(record.plan_atomic_groups, str)
+                    else record.plan_atomic_groups
+                )
+                candidate_atomic_groups = _HISTORY_ATOMIC_GROUPS_ADAPTER.validate_python(raw_atomic_groups)
+                group_ids = [group.id for group in candidate_atomic_groups]
+                if len(group_ids) != len(set(group_ids)):
+                    raise ValueError("duplicate atomic group IDs")
+                raw_seed_map = (
+                    json.loads(record.plan_seed_id_map)
+                    if isinstance(record.plan_seed_id_map, str)
+                    else record.plan_seed_id_map
+                )
+                candidate_seed_map = _HISTORY_SEED_ID_MAP_ADAPTER.validate_python(raw_seed_map)
+                candidate_seed_ids: dict[str, str] = {}
+                for seed in candidate_seed_map:
+                    objective_sha256 = seed["objective_sha256"]
+                    seed_id = seed["id"]
+                    previous_seed_id = candidate_seed_ids.get(objective_sha256)
+                    if previous_seed_id is not None and previous_seed_id != seed_id:
+                        raise ValueError("ambiguous objective hash in run plan")
+                    candidate_seed_ids[objective_sha256] = seed_id
+                atomic_groups = candidate_atomic_groups
+                seed_id_by_objective_hash = candidate_seed_ids
+            except (json.JSONDecodeError, ValidationError, ValueError):
+                logger.warning(
+                    "Scenario run %s has an incomplete persisted plan; using legacy history totals.",
+                    record.scenario_result_id,
+                )
+        target, datasets_used, scenario_parameters = self._safe_run_metadata(scenario_identifier=scenario_identifier)
+        if target is None and record.objective_target_identifier:
+            try:
+                target = self._safe_target_metadata(
+                    target_identifier=TargetIdentifier.from_component_identifier(
+                        ComponentIdentifier.model_validate(record.objective_target_identifier)
+                    )
+                )
+            except ValidationError:
+                logger.warning(
+                    "Scenario run %s has invalid persisted target metadata; omitting the target summary.",
+                    record.scenario_result_id,
+                )
+
+        units_by_key: dict[tuple[str, str], ScenarioHistoryUnitRecord] = {}
+        for unit in units:
+            unit_key = self._history_unit_key(
+                unit=unit,
+                atomic_groups=atomic_groups,
+                seed_id_by_objective_hash=seed_id_by_objective_hash,
+            )
+            existing = units_by_key.get(unit_key)
+            units_by_key[unit_key] = self._merge_history_units(existing=existing, incoming=unit) if existing else unit
+        planned_units = (
+            {(group.id, seed_group_id) for group in atomic_groups for seed_group_id in group.seed_group_ids}
+            if atomic_groups is not None
+            else set(units_by_key)
+        )
+        included_units = [unit for key, unit in units_by_key.items() if key in planned_units]
+        completed_units = [unit for unit in included_units if unit.latest_outcome != AttackOutcome.ERROR.value]
+        successful = sum(unit.latest_outcome == AttackOutcome.SUCCESS.value for unit in completed_units)
+        error_count = sum(unit.error_count for unit in included_units)
+        retry_count = sum(max(0, unit.total_retries) for unit in included_units)
+        status = ScenarioRunState(record.status)
+        terminal = status in (
+            ScenarioRunState.COMPLETED,
+            ScenarioRunState.FAILED,
+            ScenarioRunState.CANCELLED,
+        )
+        timestamps = [record.created_at, *(unit.latest_timestamp for unit in units)]
+        if terminal and record.completed_at is not None:
+            timestamps.append(record.completed_at)
+        updated_at = max(timestamps)
+        techniques = (
+            list(dict.fromkeys(group.display_group for group in atomic_groups))
+            if atomic_groups is not None
+            else sorted({unit.atomic_attack_name for unit in units if unit.atomic_attack_name})
+        )
+        completed = len(completed_units)
+        return ScenarioRunListItem(
+            scenario_result_id=record.scenario_result_id,
+            scenario_name=record.scenario_name,
+            scenario_registry_name=record.scenario_registry_name,
+            scenario_version=record.scenario_version,
+            status=status,
+            created_at=record.created_at,
+            updated_at=updated_at,
+            error=record.error_message,
+            error_type=record.error_type,
+            techniques_used=techniques,
+            total_attacks=len(planned_units),
+            completed_attacks=completed,
+            objective_achieved_rate=int((successful / completed) * 100) if completed else 0,
+            total_retries=retry_count,
+            labels=record.labels,
+            completed_at=record.completed_at if terminal else None,
+            pyrit_version=record.pyrit_version,
+            target=target,
+            datasets_used=datasets_used,
+            scenario_parameters=scenario_parameters,
+            planned_total_available=atomic_groups is not None,
+            successful_attacks=successful,
+            error_attacks=error_count,
+            attack_details_available=False,
+        )
+
+    @staticmethod
+    def _history_unit_key(
+        *,
+        unit: ScenarioHistoryUnitRecord,
+        atomic_groups: list[ScenarioRunPlanAtomicGroup] | None,
+        seed_id_by_objective_hash: dict[str, str],
+    ) -> tuple[str, str]:
+        """
+        Resolve a projected history attempt to its logical planned unit.
+
+        Returns:
+            tuple[str, str]: Atomic-group and logical seed-group IDs.
+        """
+        atomic_group_id = unit.atomic_attack_name
+        if atomic_groups is not None:
+            for group in atomic_groups:
+                if group.atomic_attack_name == unit.atomic_attack_name and (
+                    not unit.technique_eval_hash or group.technique_eval_hash == unit.technique_eval_hash
+                ):
+                    atomic_group_id = group.id
+                    break
+        seed_group_id = seed_id_by_objective_hash.get(unit.seed_group_id, unit.seed_group_id)
+        return atomic_group_id, seed_group_id
+
+    @staticmethod
+    def _merge_history_units(
+        *,
+        existing: ScenarioHistoryUnitRecord,
+        incoming: ScenarioHistoryUnitRecord,
+    ) -> ScenarioHistoryUnitRecord:
+        """
+        Merge attempt partitions that resolve to the same persisted logical unit.
+
+        Returns:
+            ScenarioHistoryUnitRecord: Combined counters and preferred latest outcome.
+        """
+        existing_completed = existing.latest_outcome != AttackOutcome.ERROR.value
+        incoming_completed = incoming.latest_outcome != AttackOutcome.ERROR.value
+        if incoming_completed != existing_completed:
+            preferred = incoming if incoming_completed else existing
+        else:
+            preferred = incoming if incoming.latest_timestamp > existing.latest_timestamp else existing
+        return ScenarioHistoryUnitRecord(
+            scenario_result_id=preferred.scenario_result_id,
+            atomic_attack_name=preferred.atomic_attack_name,
+            technique_eval_hash=preferred.technique_eval_hash,
+            seed_group_id=preferred.seed_group_id,
+            objective_sha256=preferred.objective_sha256 or existing.objective_sha256 or incoming.objective_sha256,
+            latest_outcome=preferred.latest_outcome,
+            latest_timestamp=max(existing.latest_timestamp, incoming.latest_timestamp),
+            total_retries=max(0, existing.total_retries) + max(0, incoming.total_retries) + 1,
+            error_count=max(0, existing.error_count) + max(0, incoming.error_count),
+        )
+
+    @staticmethod
+    def _safe_run_metadata(
+        *,
+        scenario_identifier: ScenarioIdentifier | None,
+    ) -> tuple[ScenarioTargetSummary | None, list[str], dict[str, Any]]:
+        """
+        Project canonical identifiers to an allow-listed, secret-free API shape.
+
+        Returns:
+            tuple[ScenarioTargetSummary | None, list[str], dict[str, Any]]:
+                Safe target, datasets, and scenario parameters.
+        """
+        if scenario_identifier is None:
+            return None, [], {}
+
+        target = ScenarioRunService._safe_target_metadata(target_identifier=scenario_identifier.objective_target)
+        return (
+            target,
+            list(scenario_identifier.datasets or []),
+            ScenarioRunService._safe_scenario_parameters(parameters=dict(scenario_identifier.params)),
+        )
+
+    @staticmethod
+    def _safe_target_metadata(*, target_identifier: TargetIdentifier | None) -> ScenarioTargetSummary | None:
+        """
+        Project a target identifier to the secret-free public shape.
+
+        Returns:
+            ScenarioTargetSummary | None: Safe target metadata when available.
+        """
+        if target_identifier is None:
+            return None
+        return ScenarioTargetSummary(
+            target_type=target_identifier.class_name,
+            endpoint=ScenarioRunService._safe_endpoint(target_identifier.endpoint),
+            model_name=target_identifier.model_name or target_identifier.underlying_model_name,
+            identifier_hash=target_identifier.hash,
+        )
+
+    @staticmethod
+    def _safe_scenario_parameters(*, parameters: dict[str, Any]) -> dict[str, Any]:
+        """
+        Return only explicitly approved, JSON-safe scenario configuration fields.
+
+        Returns:
+            dict[str, Any]: Allow-listed scenario parameters with sensitive keys removed.
+        """
+        filtered = filter_sensitive_fields(parameters)
+        return {
+            key: value
+            for key, value in filtered.items()
+            if key in _SAFE_SCENARIO_PARAMETER_NAMES
+            and (
+                value is None
+                or isinstance(value, (bool, int, float, str))
+                or (
+                    isinstance(value, list)
+                    and all(item is None or isinstance(item, (bool, int, float, str)) for item in value)
+                )
+            )
+        }
+
+    @staticmethod
+    def _safe_endpoint(endpoint: str | None) -> str | None:
+        """
+        Remove endpoint credentials, query parameters, and fragments.
+
+        Returns:
+            str | None: Sanitized endpoint.
+        """
+        if not endpoint:
+            return None
+        parsed = urlsplit(endpoint)
+        if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+            return None
+        host = parsed.hostname or ""
+        try:
+            port = parsed.port
+        except ValueError:
+            port = None
+        if port is not None:
+            host = f"{host}:{port}"
+        return urlunsplit((parsed.scheme, host, "", "", ""))
+
+    @staticmethod
+    def _normalize_history_labels(
+        *,
+        labels: Mapping[str, str | Sequence[str]] | None,
+    ) -> dict[str, str | list[str]] | None:
+        """
+        Normalize history labels for filtering and cursor binding.
+
+        Returns:
+            dict[str, str | list[str]] | None: Canonical effective labels.
+        """
+        normalized: dict[str, str | list[str]] = {}
+        for key in sorted(labels or {}):
+            raw_value = (labels or {})[key]
+            if isinstance(raw_value, str):
+                if raw_value:
+                    normalized[key] = raw_value
+                continue
+            values = sorted({str(value) for value in raw_value if str(value)})
+            if values:
+                normalized[key] = values
+        return normalized or None
+
+    @staticmethod
+    def _history_filter_fingerprint(
+        *,
+        scenario_names: Sequence[str],
+        statuses: Sequence[str],
+        labels: Mapping[str, str | Sequence[str]] | None,
+    ) -> str:
+        """Return a stable fingerprint binding a cursor to normalized filters."""
+        payload = {
+            "scenario_names": sorted(scenario_names),
+            "statuses": sorted(statuses),
+            "labels": labels,
+        }
+        canonical = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+        return hashlib.sha256(canonical.encode("utf-8")).hexdigest()[:16]
+
+    @staticmethod
+    def _encode_history_cursor(*, cursor: ScenarioHistoryKeysetCursor, fingerprint: str) -> str:
+        """
+        Encode a descending scenario-history keyset anchor.
+
+        Returns:
+            str: Opaque cursor.
+        """
+        payload = {
+            "v": 1,
+            "f": fingerprint,
+            "t": cursor.timestamp.isoformat(),
+            "i": cursor.scenario_result_id,
+        }
+        raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
+        return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
+
+    @staticmethod
+    def _decode_history_cursor(
+        *,
+        cursor: str | None,
+        fingerprint: str,
+    ) -> ScenarioHistoryKeysetCursor | None:
+        """
+        Decode and validate a filter-bound scenario-history cursor.
+
+        Returns:
+            ScenarioHistoryKeysetCursor | None: Validated keyset anchor.
+
+        Raises:
+            ValueError: If the cursor is malformed or belongs to different filters.
+        """
+        if cursor is None:
+            return None
+        try:
+            padded = cursor + "=" * (-len(cursor) % 4)
+            payload = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")))
+        except (binascii.Error, UnicodeDecodeError, ValueError, TypeError) as exc:
+            raise ValueError("Malformed scenario history cursor.") from exc
+        if not isinstance(payload, dict) or payload.get("v") != 1:
+            raise ValueError("Malformed scenario history cursor.")
+        if payload.get("f") != fingerprint:
+            raise ValueError("Scenario history cursor does not match the requested filters.")
+        try:
+            timestamp = datetime.fromisoformat(payload["t"])
+            scenario_result_id = str(uuid.UUID(payload["i"]))
+        except (KeyError, TypeError, ValueError) as exc:
+            raise ValueError("Malformed scenario history cursor.") from exc
+        if timestamp.tzinfo is None:
+            raise ValueError("Scenario history cursor timestamp must include a timezone.")
+        try:
+            timestamp = timestamp.astimezone(timezone.utc)
+        except (OverflowError, OSError) as exc:
+            raise ValueError("Malformed scenario history cursor.") from exc
+        return ScenarioHistoryKeysetCursor(
+            timestamp=timestamp,
+            scenario_result_id=scenario_result_id,
         )
 
     def _get_active_task(self, *, scenario_result_id: str) -> _ActiveTask | None:
@@ -672,12 +1151,13 @@ def _calculate_progress_counts(
         scenario_result: ScenarioResult,
         plan: ScenarioRunPlan | None,
         plan_lookup: _ScenarioPlanLookup,
-    ) -> tuple[int, int, int]:
+    ) -> tuple[int, int, int, int]:
         """
         Calculate planned-unit totals without inflating retries or error attempts.
 
         Returns:
-            tuple[int, int, int]: Total, completed, and success-rate percentage.
+            tuple[int, int, int, int]: Total, completed, success-rate percentage,
+                and successful-unit count.
         """
         latest_result_by_unit: dict[_ResultUnitIdentity, AttackResult] = {}
         for atomic_attack_name, results in scenario_result.attack_results.items():
@@ -697,7 +1177,7 @@ def _calculate_progress_counts(
         completed = len(completed_results)
         succeeded = sum(result.outcome == AttackOutcome.SUCCESS for result in completed_results)
         rate = int((succeeded / completed) * 100) if completed else 0
-        return total, completed, rate
+        return total, completed, rate, succeeded
 
     @staticmethod
     def _result_order_key(attack_result: AttackResult) -> tuple[datetime, str]:
@@ -764,6 +1244,14 @@ def get_run_progress_from_storage(
             ScenarioRunState.FAILED,
             ScenarioRunState.CANCELLED,
         )
+        scenario_identifier = header_result.scenario_identifier
+        target, datasets_used, scenario_parameters = self._safe_run_metadata(scenario_identifier=scenario_identifier)
+        if plan is not None:
+            techniques_used = list(dict.fromkeys(group.display_group for group in plan.atomic_groups))
+        elif scenario_identifier is not None:
+            techniques_used = list(scenario_identifier.techniques or [])
+        else:
+            techniques_used = []
         return ScenarioRunProgress(
             run=ScenarioProgressHeader(
                 scenario_result_id=scenario_result_id,
@@ -773,6 +1261,12 @@ def get_run_progress_from_storage(
                 status=header_result.scenario_run_state,
                 created_at=header_result.creation_time,
                 completed_at=header_result.completion_time if terminal else None,
+                pyrit_version=header_result.pyrit_version,
+                target=target,
+                techniques_used=techniques_used,
+                datasets_used=datasets_used,
+                scenario_parameters=scenario_parameters,
+                labels=header_result.labels,
             ),
             plan=response_plan,
             reset=False,
diff --git a/pyrit/cli/api_client.py b/pyrit/cli/api_client.py
index a930a1f09c..d27fbc669e 100644
--- a/pyrit/cli/api_client.py
+++ b/pyrit/cli/api_client.py
@@ -349,11 +349,31 @@ async def list_scenario_runs_async(self, *, limit: int = 100) -> list[ScenarioRu
 
         Returns:
             list[ScenarioRunListItem]: All tracked scenario runs.
+
+        Raises:
+            ValueError: If the requested limit is invalid or a paginated response has no cursor.
         """
         from pyrit.models.catalog import ScenarioRunListItem
 
-        payload = await self._get_json_async(path="/api/scenarios/runs", params={"limit": limit})
-        return [ScenarioRunListItem.model_validate(item) for item in payload.get("items", [])]
+        if limit < 1:
+            raise ValueError("Scenario history limit must be positive.")
+
+        runs: list[ScenarioRunListItem] = []
+        cursor: str | None = None
+        while len(runs) < limit:
+            params: dict[str, int | str] = {"limit": min(100, limit - len(runs))}
+            if cursor is not None:
+                params["cursor"] = cursor
+            payload = await self._get_json_async(path="/api/scenarios/runs", params=params)
+            runs.extend(ScenarioRunListItem.model_validate(item) for item in payload.get("items", []))
+            pagination = payload.get("pagination", {})
+            if not pagination.get("has_more"):
+                break
+            next_cursor = pagination.get("next_cursor")
+            if not isinstance(next_cursor, str) or not next_cursor:
+                raise ValueError("Scenario history response is missing its next-page cursor.")
+            cursor = next_cursor
+        return runs[:limit]
 
     # ------------------------------------------------------------------
     # Attacks / conversations
diff --git a/pyrit/memory/__init__.py b/pyrit/memory/__init__.py
index cab9590799..56c2c9ee33 100644
--- a/pyrit/memory/__init__.py
+++ b/pyrit/memory/__init__.py
@@ -16,7 +16,13 @@
     from pyrit.memory.azure_sql_memory import AzureSQLMemory
     from pyrit.memory.central_memory import CentralMemory
     from pyrit.memory.memory_embedding import MemoryEmbedding
-    from pyrit.memory.memory_interface import AttackResultKeysetCursor, MemoryInterface
+    from pyrit.memory.memory_interface import (
+        AttackResultKeysetCursor,
+        MemoryInterface,
+        ScenarioHistoryKeysetCursor,
+        ScenarioHistoryRunRecord,
+        ScenarioHistoryUnitRecord,
+    )
     from pyrit.memory.memory_models import AttackResultEntry, EmbeddingDataEntry, PromptMemoryEntry, SeedEntry
     from pyrit.memory.sqlite_memory import SQLiteMemory
     from pyrit.memory.storage import (
@@ -55,6 +61,9 @@
     "ImagePathDataTypeSerializer": "pyrit.memory.storage",
     "MemoryInterface": "pyrit.memory.memory_interface",
     "MemoryEmbedding": "pyrit.memory.memory_embedding",
+    "ScenarioHistoryKeysetCursor": "pyrit.memory.memory_interface",
+    "ScenarioHistoryRunRecord": "pyrit.memory.memory_interface",
+    "ScenarioHistoryUnitRecord": "pyrit.memory.memory_interface",
     "PromptMemoryEntry": "pyrit.memory.memory_models",
     "SeedEntry": "pyrit.memory.memory_models",
     "set_message_piece_sha256_async": "pyrit.memory.storage",
diff --git a/pyrit/memory/alembic/versions/8d1e3f5a7b9c_index_scenario_history.py b/pyrit/memory/alembic/versions/8d1e3f5a7b9c_index_scenario_history.py
new file mode 100644
index 0000000000..f5747554ff
--- /dev/null
+++ b/pyrit/memory/alembic/versions/8d1e3f5a7b9c_index_scenario_history.py
@@ -0,0 +1,35 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""
+Index scenario results for descending history keyset pagination.
+
+Revision ID: 8d1e3f5a7b9c
+Revises: 6b8d0f2a4c1e
+Create Date: 2026-08-06 22:40:00.000000
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+
+revision: str = "8d1e3f5a7b9c"
+down_revision: str | None = "6b8d0f2a4c1e"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+_INDEX_NAME = "ix_ScenarioResultEntries_timestamp_id"
+
+
+def upgrade() -> None:
+    """Create the scenario history keyset index."""
+    op.create_index(
+        _INDEX_NAME,
+        "ScenarioResultEntries",
+        ["timestamp", "id"],
+    )
+
+
+def downgrade() -> None:
+    """Drop the scenario history keyset index."""
+    op.drop_index(_INDEX_NAME, table_name="ScenarioResultEntries")
diff --git a/pyrit/memory/azure_sql_memory.py b/pyrit/memory/azure_sql_memory.py
index 551d111c32..bce6d08a50 100644
--- a/pyrit/memory/azure_sql_memory.py
+++ b/pyrit/memory/azure_sql_memory.py
@@ -3,12 +3,12 @@
 
 import logging
 import struct
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from contextlib import closing
 from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING, Any, Literal, cast
 
-from sqlalchemy import and_, create_engine, event, exists, text
+from sqlalchemy import and_, create_engine, event, exists, func, literal_column, text
 from sqlalchemy.engine.base import Engine
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import InstrumentedAttribute, sessionmaker
@@ -22,6 +22,7 @@
 from pyrit.memory.memory_models import (
     AttackResultEntry,
     PromptMemoryEntry,
+    ScenarioResultEntry,
 )
 from pyrit.memory.storage import AzureBlobStorageIO
 from pyrit.models import ConversationStats
@@ -594,7 +595,7 @@ def get_conversation_stats(self, *, conversation_ids: Sequence[str]) -> dict[str
 
         return result
 
-    def _get_scenario_result_label_condition(self, *, labels: dict[str, str]) -> Any:
+    def _get_scenario_result_label_condition(self, *, labels: Mapping[str, str | Sequence[str]]) -> Any:
         """
         Get the SQL Azure implementation for filtering ScenarioResults by labels.
 
@@ -608,13 +609,86 @@ def _get_scenario_result_label_condition(self, *, labels: dict[str, str]) -> Any
         """
         # Return combined conditions for all labels
         conditions = []
-        for key, value in labels.items():
-            condition = text(f"ISJSON(labels) = 1 AND JSON_VALUE(labels, '$.{key}') = :{key}").bindparams(
-                **{key: str(value)}
-            )
-            conditions.append(condition)
+        for key_index, (key, raw_value) in enumerate(labels.items()):
+            values = [raw_value] if isinstance(raw_value, str) else list(raw_value)
+            placeholders = []
+            path_param = f"scenario_label_path_{key_index}"
+            bindparams: dict[str, str] = {path_param: f'$."{key}"'}
+            for index, value in enumerate(values):
+                param = f"scenario_label_value_{key_index}_{index}"
+                placeholders.append(f":{param}")
+                bindparams[param] = str(value)
+            if placeholders:
+                conditions.append(
+                    text(
+                        f"ISJSON(labels) = 1 AND JSON_VALUE(labels, :{path_param}) IN ({', '.join(placeholders)})"
+                    ).bindparams(**bindparams)
+                )
         return and_(*conditions)
 
+    def _get_scenario_registry_name_condition(self, *, scenario_names: Sequence[str]) -> Any:
+        """
+        Match requested scenario registry names inside the persisted run plan.
+
+        Returns:
+            Any: SQL Server JSON condition for the requested names.
+        """
+        placeholders = []
+        bindparams: dict[str, str] = {}
+        for index, value in enumerate(scenario_names):
+            param = f"scenario_registry_name_{index}"
+            placeholders.append(f":{param}")
+            bindparams[param] = value
+        return text(
+            "ISJSON(scenario_metadata) = 1 AND "
+            "JSON_VALUE(scenario_metadata, '$.run_plan.scenario_registry_name') "
+            f"IN ({', '.join(placeholders)})"
+        ).bindparams(**bindparams)
+
+    def _get_scenario_history_plan_expressions(self) -> tuple[Any, Any, Any]:
+        """Return compact SQL Server run-plan fields without objective-bearing seed groups."""
+        return (
+            func.json_value(
+                ScenarioResultEntry.scenario_metadata,
+                "$.run_plan.scenario_registry_name",
+            ),
+            func.json_query(
+                ScenarioResultEntry.scenario_metadata,
+                "$.run_plan.atomic_groups",
+            ),
+            literal_column(
+                """
+                (
+                    SELECT
+                        JSON_VALUE([history_seed].[value], '$.id') AS [id],
+                        JSON_VALUE([history_seed].[value], '$.objective_sha256') AS [objective_sha256]
+                    FROM OPENJSON(
+                        [ScenarioResultEntries].[scenario_metadata],
+                        '$.run_plan.seed_groups'
+                    ) AS [history_seed]
+                    FOR JSON PATH
+                )
+                """
+            ),
+        )
+
+    def _get_scenario_attempt_unit_expressions(self) -> tuple[Any, Any, Any]:
+        """Return SQL Server JSON expressions for persisted scenario attempt attribution."""
+        atomic_name = func.coalesce(
+            func.json_value(AttackResultEntry.attribution_data, '$."parent_collection"'),
+            "",
+        )
+        technique_hash = func.coalesce(
+            func.json_value(AttackResultEntry.attribution_data, '$."parent_eval_hash"'),
+            "",
+        )
+        seed_group_id = func.coalesce(
+            func.json_value(AttackResultEntry.attribution_data, '$."seed_group_id"'),
+            AttackResultEntry.objective_sha256,
+            "",
+        )
+        return atomic_name, technique_hash, seed_group_id
+
     def get_session(self) -> Session:
         """
         Provide a session for database operations.
diff --git a/pyrit/memory/memory_interface.py b/pyrit/memory/memory_interface.py
index 758c03bdcd..90b97843bf 100644
--- a/pyrit/memory/memory_interface.py
+++ b/pyrit/memory/memory_interface.py
@@ -18,7 +18,7 @@
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, NamedTuple, TypeVar
 from urllib.parse import urlparse
 
-from sqlalchemy import MetaData, and_, func, not_, or_, select
+from sqlalchemy import MetaData, and_, case, func, not_, or_, select
 from sqlalchemy.engine.base import Engine
 from sqlalchemy.exc import IntegrityError, SQLAlchemyError
 from sqlalchemy.orm import joinedload
@@ -142,6 +142,49 @@ def from_attack_result(cls, result: AttackResult) -> "AttackResultKeysetCursor":
         )
 
 
+class ScenarioHistoryKeysetCursor(NamedTuple):
+    """Descending keyset anchor for scenario history."""
+
+    timestamp: datetime
+    scenario_result_id: str
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ScenarioHistoryRunRecord:
+    """Lightweight persisted scenario header for one history row."""
+
+    scenario_result_id: str
+    scenario_name: str
+    scenario_version: int
+    pyrit_version: str
+    scenario_identifier: dict[str, Any]
+    objective_target_identifier: dict[str, Any]
+    status: str
+    labels: dict[str, str]
+    created_at: datetime
+    completed_at: datetime | None
+    error_message: str | None
+    error_type: str | None
+    scenario_registry_name: str | None
+    plan_atomic_groups: str | list[dict[str, Any]] | None
+    plan_seed_id_map: str | list[dict[str, str]] | None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ScenarioHistoryUnitRecord:
+    """One logical scenario work unit aggregated from all persisted attempts."""
+
+    scenario_result_id: str
+    atomic_attack_name: str
+    technique_eval_hash: str
+    seed_group_id: str
+    objective_sha256: str | None
+    latest_outcome: str
+    latest_timestamp: datetime
+    total_retries: int
+    error_count: int
+
+
 @dataclass(frozen=True, slots=True, kw_only=True)
 class _AttackResultQuery:
     """
@@ -1609,17 +1652,53 @@ def get_conversation_stats(self, *, conversation_ids: Sequence[str]) -> dict[str
         """
 
     @abc.abstractmethod
-    def _get_scenario_result_label_condition(self, *, labels: dict[str, str]) -> Any:
+    def _get_scenario_result_label_condition(self, *, labels: Mapping[str, str | Sequence[str]]) -> Any:
         """
         Return a database-specific condition for filtering ScenarioResults by labels.
 
         Args:
-            labels: Dictionary of labels that must ALL be present.
+            labels: Labels with OR-within-key and AND-across-key semantics.
 
         Returns:
             Database-specific SQLAlchemy condition.
         """
 
+    def _get_scenario_registry_name_condition(self, *, scenario_names: Sequence[str]) -> Any:
+        """
+        Return a backend-specific condition matching persisted run-plan registry names.
+
+        Raises:
+            NotImplementedError: If the memory backend does not support Scenario history filtering.
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} must implement _get_scenario_registry_name_condition "
+            "to support Scenario history filtering."
+        )
+
+    def _get_scenario_history_plan_expressions(self) -> tuple[Any, Any, Any]:
+        """
+        Return registry-name and compact atomic-group expressions for history rows.
+
+        Raises:
+            NotImplementedError: If the memory backend does not support Scenario history queries.
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} must implement _get_scenario_history_plan_expressions "
+            "to support Scenario history queries."
+        )
+
+    def _get_scenario_attempt_unit_expressions(self) -> tuple[Any, Any, Any]:
+        """
+        Return backend-specific JSON expressions for scenario attempt unit attribution.
+
+        Raises:
+            NotImplementedError: If the memory backend does not support Scenario history queries.
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} must implement _get_scenario_attempt_unit_expressions "
+            "to support Scenario history queries."
+        )
+
     def add_scores_to_memory(self, *, scores: Sequence[Score]) -> None:
         """
         Persist scores whose loose-content anchors need no asynchronous file copy.
@@ -3942,6 +4021,198 @@ def get_scenario_result_headers(self, *, limit: int = 100) -> Sequence[ScenarioR
         )
         return [entry.get_scenario_result() for entry in entries]
 
+    def get_scenario_run_history_page(
+        self,
+        *,
+        scenario_names: Sequence[str] | None = None,
+        statuses: Sequence[str] | None = None,
+        labels: Mapping[str, str | Sequence[str]] | None = None,
+        cursor: ScenarioHistoryKeysetCursor | None = None,
+        limit: int = 100,
+    ) -> tuple[list[ScenarioHistoryRunRecord], dict[str, list[ScenarioHistoryUnitRecord]], bool]:
+        """
+        Return one descending scenario-history page and minimal linked attempts.
+
+        Only selected ScenarioResult columns and the linked AttackResult columns
+        required for aggregate counts are read. Full ORM result objects and their
+        relationships are never hydrated.
+
+        Returns:
+            tuple[list[ScenarioHistoryRunRecord], dict[str, list[ScenarioHistoryUnitRecord]], bool]:
+                Page headers, logical work units grouped by scenario ID, and whether
+                another page exists.
+
+        Raises:
+            ValueError: If the limit, cursor ID, or label keys are invalid.
+        """
+        if limit < 1 or limit > 100:
+            raise ValueError("Scenario history limit must be between 1 and 100.")
+
+        conditions: list[Any] = []
+        effective_names = sorted({name.strip() for name in scenario_names or [] if name.strip()})
+        if effective_names:
+            conditions.append(
+                or_(
+                    ScenarioResultEntry.scenario_name.in_(effective_names),
+                    self._get_scenario_registry_name_condition(scenario_names=effective_names),
+                )
+            )
+        effective_statuses = sorted({status.strip().upper() for status in statuses or [] if status.strip()})
+        if effective_statuses:
+            conditions.append(ScenarioResultEntry.scenario_run_state.in_(effective_statuses))
+        effective_labels = {
+            key: value
+            for key, value in (labels or {}).items()
+            if (isinstance(value, str) and value) or (not isinstance(value, str) and len(value) > 0)
+        }
+        invalid_keys = sorted(key for key in effective_labels if not self._LABEL_KEY_PATTERN.fullmatch(key))
+        if invalid_keys:
+            raise ValueError(
+                f"Invalid label key(s) {invalid_keys!r}: keys must match {self._LABEL_KEY_PATTERN.pattern}."
+            )
+        if effective_labels:
+            conditions.append(self._get_scenario_result_label_condition(labels=effective_labels))
+        if cursor is not None:
+            cursor_id = uuid.UUID(cursor.scenario_result_id)
+            conditions.append(
+                or_(
+                    ScenarioResultEntry.timestamp < cursor.timestamp,
+                    and_(
+                        ScenarioResultEntry.timestamp == cursor.timestamp,
+                        ScenarioResultEntry.id < cursor_id,
+                    ),
+                )
+            )
+
+        statement = select(
+            ScenarioResultEntry.id,
+            ScenarioResultEntry.scenario_name,
+            ScenarioResultEntry.scenario_version,
+            ScenarioResultEntry.pyrit_version,
+            ScenarioResultEntry.scenario_identifier,
+            ScenarioResultEntry.objective_target_identifier,
+            ScenarioResultEntry.scenario_run_state,
+            ScenarioResultEntry.labels,
+            ScenarioResultEntry.timestamp,
+            ScenarioResultEntry.completion_time,
+            ScenarioResultEntry.error_message,
+            ScenarioResultEntry.error_type,
+            *(
+                expression.label(label)
+                for expression, label in zip(
+                    self._get_scenario_history_plan_expressions(),
+                    ("scenario_registry_name", "plan_atomic_groups", "plan_seed_id_map"),
+                    strict=True,
+                )
+            ),
+        )
+        if conditions:
+            statement = statement.where(and_(*conditions))
+        statement = statement.order_by(
+            ScenarioResultEntry.timestamp.desc(),
+            ScenarioResultEntry.id.desc(),
+        ).limit(limit + 1)
+        with closing(self.get_session()) as session:
+            rows = session.execute(statement).all()
+            page_rows = rows[:limit]
+            page_ids = [row.id for row in page_rows]
+            unit_rows = []
+            if page_ids:
+                atomic_name, technique_hash, seed_group_id = self._get_scenario_attempt_unit_expressions()
+                unit_partition = (
+                    AttackResultEntry.attribution_parent_id,
+                    atomic_name,
+                    technique_hash,
+                    seed_group_id,
+                )
+                ranked_units = select(
+                    AttackResultEntry.attribution_parent_id.label("scenario_result_id"),
+                    atomic_name.label("atomic_attack_name"),
+                    technique_hash.label("technique_eval_hash"),
+                    seed_group_id.label("seed_group_id"),
+                    AttackResultEntry.objective_sha256.label("objective_sha256"),
+                    AttackResultEntry.outcome.label("latest_outcome"),
+                    func.max(AttackResultEntry.timestamp).over(partition_by=unit_partition).label("latest_timestamp"),
+                    (
+                        func.sum(func.coalesce(AttackResultEntry.total_retries, 0)).over(partition_by=unit_partition)
+                        + func.count().over(partition_by=unit_partition)
+                        - 1
+                    ).label("total_retries"),
+                    func.sum(case((AttackResultEntry.outcome == AttackOutcome.ERROR.value, 1), else_=0))
+                    .over(partition_by=unit_partition)
+                    .label("error_count"),
+                    func.row_number()
+                    .over(
+                        partition_by=unit_partition,
+                        order_by=(
+                            case((AttackResultEntry.outcome != AttackOutcome.ERROR.value, 1), else_=0).desc(),
+                            AttackResultEntry.timestamp.desc(),
+                            AttackResultEntry.id.desc(),
+                        ),
+                    )
+                    .label("unit_rank"),
+                ).where(AttackResultEntry.attribution_parent_id.in_(page_ids))
+                ranked_subquery = ranked_units.subquery()
+                unit_rows = session.execute(select(ranked_subquery).where(ranked_subquery.c.unit_rank == 1)).all()
+
+        records = [
+            ScenarioHistoryRunRecord(
+                scenario_result_id=str(row.id),
+                scenario_name=row.scenario_name,
+                scenario_version=row.scenario_version,
+                pyrit_version=row.pyrit_version,
+                scenario_identifier=row.scenario_identifier or {},
+                objective_target_identifier=row.objective_target_identifier or {},
+                status=row.scenario_run_state,
+                labels=row.labels or {},
+                created_at=row.timestamp,
+                completed_at=row.completion_time,
+                error_message=row.error_message,
+                error_type=row.error_type,
+                scenario_registry_name=row.scenario_registry_name,
+                plan_atomic_groups=row.plan_atomic_groups,
+                plan_seed_id_map=row.plan_seed_id_map,
+            )
+            for row in page_rows
+        ]
+        units_by_run: dict[str, list[ScenarioHistoryUnitRecord]] = {record.scenario_result_id: [] for record in records}
+        for row in unit_rows:
+            if row.scenario_result_id is None:
+                continue
+            run_id = str(row.scenario_result_id)
+            units_by_run[run_id].append(
+                ScenarioHistoryUnitRecord(
+                    scenario_result_id=run_id,
+                    atomic_attack_name=row.atomic_attack_name or "",
+                    technique_eval_hash=row.technique_eval_hash or "",
+                    seed_group_id=row.seed_group_id or "",
+                    objective_sha256=row.objective_sha256,
+                    latest_outcome=row.latest_outcome,
+                    latest_timestamp=row.latest_timestamp,
+                    total_retries=row.total_retries or 0,
+                    error_count=row.error_count or 0,
+                )
+            )
+        return records, units_by_run, len(rows) > limit
+
+    def get_unique_scenario_labels(self) -> dict[str, list[str]]:
+        """Return all unique label values across scenario results."""
+        label_values: dict[str, set[str]] = {}
+        with closing(self.get_session()) as session:
+            rows = (
+                session.query(ScenarioResultEntry.labels)
+                .filter(ScenarioResultEntry.labels.isnot(None))
+                .distinct()
+                .all()
+            )
+        for (labels,) in rows:
+            if not isinstance(labels, dict):
+                continue
+            for key, value in labels.items():
+                if isinstance(value, str):
+                    label_values.setdefault(key, set()).add(value)
+        return {key: sorted(values) for key, values in sorted(label_values.items())}
+
     def get_scenario_attack_result_deltas(
         self,
         *,
diff --git a/pyrit/memory/memory_models.py b/pyrit/memory/memory_models.py
index f9723ce7cb..867f3922a7 100644
--- a/pyrit/memory/memory_models.py
+++ b/pyrit/memory/memory_models.py
@@ -1893,7 +1893,10 @@ class ScenarioResultEntry(Base):
     """
 
     __tablename__ = "ScenarioResultEntries"
-    __table_args__ = {"extend_existing": True}
+    __table_args__ = (
+        Index("ix_ScenarioResultEntries_timestamp_id", "timestamp", "id"),
+        {"extend_existing": True},
+    )
     id = mapped_column(CustomUUID, nullable=False, primary_key=True)
     scenario_name = mapped_column(String, nullable=False)
     scenario_description = mapped_column(Unicode, nullable=True)
diff --git a/pyrit/memory/sqlite_memory.py b/pyrit/memory/sqlite_memory.py
index 210c3f1da6..74f41bc60a 100644
--- a/pyrit/memory/sqlite_memory.py
+++ b/pyrit/memory/sqlite_memory.py
@@ -2,13 +2,13 @@
 # Licensed under the MIT license.
 
 import logging
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from contextlib import closing
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Literal
 
-from sqlalchemy import and_, create_engine, exists, func, or_, text
+from sqlalchemy import and_, create_engine, exists, func, or_, select, text
 from sqlalchemy.engine.base import Engine
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import InstrumentedAttribute, sessionmaker
@@ -439,7 +439,7 @@ def get_conversation_stats(self, *, conversation_ids: Sequence[str]) -> dict[str
 
         return result
 
-    def _get_scenario_result_label_condition(self, *, labels: dict[str, str]) -> Any:
+    def _get_scenario_result_label_condition(self, *, labels: Mapping[str, str | Sequence[str]]) -> Any:
         """
         SQLite implementation for filtering ScenarioResults by labels.
         Uses json_extract() function specific to SQLite.
@@ -447,6 +447,71 @@ def _get_scenario_result_label_condition(self, *, labels: dict[str, str]) -> Any
         Returns:
             Any: A SQLAlchemy exists subquery condition.
         """
-        return and_(
-            *[func.json_extract(ScenarioResultEntry.labels, f"$.{key}") == value for key, value in labels.items()]
+        conditions = []
+        for key, raw_value in labels.items():
+            values = [raw_value] if isinstance(raw_value, str) else list(raw_value)
+            if values:
+                conditions.append(func.json_extract(ScenarioResultEntry.labels, f'$."{key}"').in_(values))
+        return and_(*conditions)
+
+    def _get_scenario_registry_name_condition(self, *, scenario_names: Sequence[str]) -> Any:
+        """
+        Match requested scenario registry names inside the persisted run plan.
+
+        Returns:
+            Any: SQLite JSON condition for the requested names.
+        """
+        registry_name = func.json_extract(
+            ScenarioResultEntry.scenario_metadata,
+            "$.run_plan.scenario_registry_name",
+        )
+        return registry_name.in_(scenario_names)
+
+    def _get_scenario_history_plan_expressions(self) -> tuple[Any, Any, Any]:
+        """Return compact SQLite run-plan fields without objective-bearing seed groups."""
+        seed_rows = func.json_each(
+            ScenarioResultEntry.scenario_metadata,
+            "$.run_plan.seed_groups",
+        ).table_valued("value")
+        compact_seed_map = (
+            select(
+                func.json_group_array(
+                    func.json_object(
+                        "id",
+                        func.json_extract(seed_rows.c.value, "$.id"),
+                        "objective_sha256",
+                        func.json_extract(seed_rows.c.value, "$.objective_sha256"),
+                    )
+                )
+            )
+            .select_from(seed_rows)
+            .scalar_subquery()
+        )
+        return (
+            func.json_extract(
+                ScenarioResultEntry.scenario_metadata,
+                "$.run_plan.scenario_registry_name",
+            ),
+            func.json_extract(
+                ScenarioResultEntry.scenario_metadata,
+                "$.run_plan.atomic_groups",
+            ),
+            compact_seed_map,
+        )
+
+    def _get_scenario_attempt_unit_expressions(self) -> tuple[Any, Any, Any]:
+        """Return SQLite JSON expressions for persisted scenario attempt attribution."""
+        atomic_name = func.coalesce(
+            func.json_extract(AttackResultEntry.attribution_data, '$."parent_collection"'),
+            "",
+        )
+        technique_hash = func.coalesce(
+            func.json_extract(AttackResultEntry.attribution_data, '$."parent_eval_hash"'),
+            "",
+        )
+        seed_group_id = func.coalesce(
+            func.json_extract(AttackResultEntry.attribution_data, '$."seed_group_id"'),
+            AttackResultEntry.objective_sha256,
+            "",
         )
+        return atomic_name, technique_hash, seed_group_id
diff --git a/pyrit/models/catalog/scenario.py b/pyrit/models/catalog/scenario.py
index 11c7c2e269..8884d466ef 100644
--- a/pyrit/models/catalog/scenario.py
+++ b/pyrit/models/catalog/scenario.py
@@ -339,6 +339,23 @@ class ScenarioRunSummary(BaseModel):
     )
     labels: dict[str, str] = Field(default_factory=dict, description="Labels attached to this run")
     completed_at: datetime | None = Field(None, description="When the scenario finished")
+    pyrit_version: str | None = Field(None, description="PyRIT version that created the run")
+    target: "ScenarioTargetSummary | None" = Field(None, description="Safe objective-target identity")
+    datasets_used: list[str] = Field(default_factory=list, description="Resolved datasets selected for the run")
+    scenario_parameters: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Safe resolved scenario parameters; sensitive fields are removed",
+    )
+    planned_total_available: bool = Field(
+        True,
+        description="Whether total_attacks comes from a complete persisted run plan",
+    )
+    successful_attacks: int = Field(0, ge=0, description="Latest successful planned units")
+    error_attacks: int = Field(0, ge=0, description="Persisted error attempts")
+    attack_details_available: bool = Field(
+        True,
+        description="Whether failed_attacks and attack_retries contain per-attempt details",
+    )
 
 
 class ScenarioRunListItem(BaseModel):
@@ -355,5 +372,38 @@ class ScenarioRunListItem(BaseModel):
     error_type: str | None = Field(None, description="Persisted run-level exception class")
     techniques_used: list[str] = Field(default_factory=list, description="Planned technique display groups")
     total_attacks: int | None = Field(None, ge=0, description="Number of planned execution units when known")
+    completed_attacks: int = Field(0, ge=0, description="Latest completed planned units")
+    objective_achieved_rate: int = Field(0, ge=0, le=100, description="Success rate as percentage (0-100)")
+    total_retries: int = Field(0, ge=0, description="Retry attempts recorded across projected work units")
     labels: dict[str, str] = Field(default_factory=dict, description="Labels attached to this run")
     completed_at: datetime | None = Field(None, description="When the scenario finished")
+    pyrit_version: str | None = Field(None, description="PyRIT version that created the run")
+    target: "ScenarioTargetSummary | None" = Field(None, description="Safe objective-target identity")
+    datasets_used: list[str] = Field(default_factory=list, description="Resolved datasets selected for the run")
+    scenario_parameters: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Safe resolved scenario parameters; sensitive fields are removed",
+    )
+    planned_total_available: bool = Field(
+        True,
+        description="Whether total_attacks comes from a complete persisted run plan",
+    )
+    successful_attacks: int = Field(0, ge=0, description="Latest successful planned units")
+    error_attacks: int = Field(0, ge=0, description="Persisted error attempts")
+    attack_details_available: bool = Field(
+        True,
+        description="Whether failed_attacks and attack_retries contain per-attempt details",
+    )
+
+
+class ScenarioTargetSummary(BaseModel):
+    """Safe target identity suitable for scenario history and run headers."""
+
+    target_type: str = Field(..., description="Target implementation type")
+    endpoint: str | None = Field(None, description="Configured endpoint, when present")
+    model_name: str | None = Field(None, description="Configured model or deployment name")
+    identifier_hash: str | None = Field(None, description="Canonical target identifier hash")
+
+
+ScenarioRunSummary.model_rebuild()
+ScenarioRunListItem.model_rebuild()
diff --git a/pyrit/models/scenario_progress.py b/pyrit/models/scenario_progress.py
index 89fc6888c3..df7e1b2822 100644
--- a/pyrit/models/scenario_progress.py
+++ b/pyrit/models/scenario_progress.py
@@ -8,6 +8,7 @@
 
 from pydantic import AwareDatetime, BaseModel, Field, model_validator
 
+from pyrit.models.catalog.scenario import ScenarioTargetSummary  # noqa: TC001
 from pyrit.models.identifiers.atomic_attack_identifier import AtomicAttackIdentifier
 from pyrit.models.results.attack_result import AttackOutcome
 from pyrit.models.results.scenario_result import ScenarioRunState
@@ -85,6 +86,12 @@ class ScenarioProgressHeader(BaseModel):
     status: ScenarioRunState
     created_at: datetime
     completed_at: datetime | None = None
+    pyrit_version: str | None = None
+    target: "ScenarioTargetSummary | None" = None
+    techniques_used: list[str] = Field(default_factory=list)
+    datasets_used: list[str] = Field(default_factory=list)
+    scenario_parameters: dict[str, Any] = Field(default_factory=dict)
+    labels: dict[str, str] = Field(default_factory=dict)
 
 
 class ScenarioProgressResult(BaseModel):
@@ -131,3 +138,6 @@ class ScenarioAttackResultDelta(BaseModel):
     error_type: str | None = None
     error_message: str | None = None
     attribution_data: dict[str, Any] = Field(default_factory=dict)
+
+
+ScenarioProgressHeader.model_rebuild()
diff --git a/pyrit/scenario/scenarios/airt/jailbreak.py b/pyrit/scenario/scenarios/airt/jailbreak.py
index f6dc906c43..ac94993d52 100644
--- a/pyrit/scenario/scenarios/airt/jailbreak.py
+++ b/pyrit/scenario/scenarios/airt/jailbreak.py
@@ -195,6 +195,21 @@ def additional_parameters(cls) -> list[Parameter]:
             ),
         ]
 
+    def set_params_from_args(self, *, args: dict[str, Any]) -> None:
+        """
+        Resolve run parameters and reject non-positive repeat counts.
+
+        Args:
+            args (dict[str, Any]): Raw scenario run parameters.
+
+        Raises:
+            ValueError: If ``num_jailbreak_attempts`` is less than one.
+        """
+        super().set_params_from_args(args=args)
+        num_attempts = self.params["num_jailbreak_attempts"]
+        if num_attempts < 1:
+            raise ValueError("num_jailbreak_attempts must be at least 1")
+
     @apply_defaults
     def __init__(
         self,
@@ -317,7 +332,7 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
         template_count = len(self.params.get("jailbreak_names") or []) or (
             self.params.get("num_jailbreaks") or _DEFAULT_NUM_JAILBREAKS
         )
-        attempt_count = self.params.get("num_jailbreak_attempts") or 1
+        attempt_count = self.params["num_jailbreak_attempts"]
         technique_names = {technique.value for technique in self._scenario_techniques}
         converter_count = len(technique_names - {_JAILBREAK_SYSTEM_PROMPT})
         system_delivery_selected = _JAILBREAK_SYSTEM_PROMPT in technique_names
@@ -445,7 +460,7 @@ async def _build_atomic_attacks_async(self, *, context: ScenarioContext) -> list
             )
 
         self._resolved_jailbreaks = self._resolve_templates()
-        num_attempts = self.params.get("num_jailbreak_attempts", 1)
+        num_attempts = self.params["num_jailbreak_attempts"]
 
         technique_factories = resolve_technique_factories(context=context, extra_factories=_extra_default_factories())
 
diff --git a/tests/unit/backend/test_api_routes.py b/tests/unit/backend/test_api_routes.py
index c9f8ffba5f..959a0e17ae 100644
--- a/tests/unit/backend/test_api_routes.py
+++ b/tests/unit/backend/test_api_routes.py
@@ -39,7 +39,6 @@
     TargetListResponse,
 )
 from pyrit.backend.routes import version as version_routes
-from pyrit.backend.routes.labels import get_label_options
 from pyrit.models import ConverterIdentifier, MessagePiece, TargetCapabilities, TargetIdentifier
 from pyrit.models.catalog.target import TargetInstance
 
@@ -1338,13 +1337,21 @@ def test_get_labels_returns_keys_without_normalization(self, client: TestClient)
             assert set(data["labels"]["operator"]) == {"alice", "bob"}
             assert set(data["labels"]["operation"]) == {"hunt", "scan"}
 
-    async def test_get_label_options_unsupported_source_returns_empty_labels(self) -> None:
-        """Test that get_label_options returns empty labels for unsupported source types."""
-        with patch("pyrit.backend.routes.labels.CentralMemory"):
-            # Call the function directly with a non-"attacks" source to cover the else branch.
-            # The Literal["attacks"] type hint prevents this via the API, but the function
-            # handles it gracefully.
-            result = await get_label_options(source="other")  # type: ignore[arg-type]
+    async def test_get_label_options_rejects_unsupported_source(self, client: TestClient) -> None:
+        """Test that unsupported label source types are rejected."""
+        response = client.get("/api/labels?source=other")
 
-        assert result.source == "other"
-        assert result.labels == {}
+        assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+
+    async def test_get_scenario_label_options(self, client: TestClient) -> None:
+        """Test that scenario labels use the scenario memory source."""
+        with patch("pyrit.backend.routes.labels.CentralMemory") as mock_central_memory:
+            mock_memory = MagicMock()
+            mock_memory.get_unique_scenario_labels.return_value = {"operator": ["alice"]}
+            mock_central_memory.get_memory_instance.return_value = mock_memory
+
+            response = client.get("/api/labels?source=scenarios")
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.json() == {"source": "scenarios", "labels": {"operator": ["alice"]}}
+        mock_memory.get_unique_scenario_labels.assert_called_once_with()
diff --git a/tests/unit/backend/test_scenario_run_routes.py b/tests/unit/backend/test_scenario_run_routes.py
index 627c0ab705..558768b1fd 100644
--- a/tests/unit/backend/test_scenario_run_routes.py
+++ b/tests/unit/backend/test_scenario_run_routes.py
@@ -16,8 +16,11 @@
 import pyrit.backend.services.scenario_run_service as _svc_mod
 from pyrit.backend.main import app
 from pyrit.backend.models.scenarios import ScenarioRunListResponse
-from pyrit.backend.routes.scenarios import get_scenario_run_progress
+from pyrit.backend.routes.scenarios import get_scenario_run_progress, list_scenario_runs
 from pyrit.models import (
+    SCENARIO_RUN_PLAN_METADATA_KEY,
+    AttackOutcome,
+    AttackResult,
     ScenarioProgressHeader,
     ScenarioRunPlan,
     ScenarioRunProgress,
@@ -186,6 +189,11 @@ def test_list_runs_rejects_unbounded_limit(self, client: TestClient) -> None:
 
         assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
 
+    async def test_list_runs_requires_keyword_arguments(self) -> None:
+        """Test that route parameters cannot be passed positionally."""
+        with pytest.raises(TypeError, match="positional"):
+            await list_scenario_runs(None, None, None, 100, None)
+
     def test_list_runs_returns_multiple_runs(self, client: TestClient) -> None:
         """Test that list runs returns all tracked runs."""
         runs = [
@@ -205,6 +213,42 @@ def test_list_runs_returns_multiple_runs(self, client: TestClient) -> None:
         assert response.status_code == status.HTTP_200_OK
         assert len(response.json()["items"]) == 2
 
+    def test_list_runs_passes_repeated_filters_and_labels(self, client: TestClient) -> None:
+        """Test that history query parameters preserve repeated values."""
+        with patch("pyrit.backend.routes.scenarios.get_scenario_run_service") as mock_get:
+            mock_service = MagicMock()
+            mock_service.list_runs.return_value = ScenarioRunListResponse(items=[])
+            mock_get.return_value = mock_service
+
+            response = client.get(
+                "/api/scenarios/runs"
+                "?scenario_names=first&scenario_names=second"
+                "&run_statuses=IN_PROGRESS&run_statuses=FAILED"
+                "&label=operator%3Aalice&label=operator%3Abob&label=team%3Asafety"
+                "&limit=10&cursor=opaque"
+            )
+
+        assert response.status_code == status.HTTP_200_OK
+        mock_service.list_runs.assert_called_once_with(
+            scenario_names=["first", "second"],
+            statuses=[ScenarioRunState.IN_PROGRESS, ScenarioRunState.FAILED],
+            labels={"operator": ["alice", "bob"], "team": ["safety"]},
+            limit=10,
+            cursor="opaque",
+        )
+
+    def test_list_runs_returns_400_for_invalid_cursor(self, client: TestClient) -> None:
+        """Test that invalid cursors are surfaced clearly."""
+        with patch("pyrit.backend.routes.scenarios.get_scenario_run_service") as mock_get:
+            mock_service = MagicMock()
+            mock_service.list_runs.side_effect = ValueError("Malformed scenario history cursor.")
+            mock_get.return_value = mock_service
+
+            response = client.get("/api/scenarios/runs?cursor=bad")
+
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert response.json()["detail"] == "Malformed scenario history cursor."
+
 
 class TestGetScenarioRunRoute:
     """Tests for GET /api/scenarios/runs/{id}."""
@@ -236,6 +280,40 @@ def test_get_run_not_found_returns_404(self, client: TestClient) -> None:
 
         assert response.status_code == status.HTTP_404_NOT_FOUND
 
+    def test_get_run_with_forward_version_plan_returns_legacy_detail(self, client: TestClient) -> None:
+        attack_result = AttackResult(
+            conversation_id="conversation-1",
+            objective="objective",
+            outcome=AttackOutcome.SUCCESS,
+            timestamp=datetime(2025, 1, 1, tzinfo=timezone.utc),
+            attribution_data={"parent_collection": "legacy attack"},
+        )
+        db_result = make_scenario_result(
+            scenario_name="foundry.red_team_agent",
+            attack_results={"legacy attack": [attack_result]},
+            metadata={
+                SCENARIO_RUN_PLAN_METADATA_KEY: {
+                    "version": 2,
+                    "atomic_groups": [],
+                    "seed_groups": [],
+                }
+            },
+        )
+        memory = MagicMock()
+        memory.get_scenario_results.return_value = [db_result]
+        memory.get_attack_results.return_value = []
+        with patch.object(_svc_mod.CentralMemory, "get_memory_instance", return_value=memory):
+            service = _svc_mod.ScenarioRunService()
+
+        with patch("pyrit.backend.routes.scenarios.get_scenario_run_service", return_value=service):
+            response = client.get(f"/api/scenarios/runs/{db_result.id}")
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.json()["planned_total_available"] is False
+        assert response.json()["total_attacks"] == 1
+        assert response.json()["completed_attacks"] == 1
+        assert response.json()["techniques_used"] == ["legacy attack"]
+
     def test_progress_invalid_cursor_returns_400(self, client: TestClient) -> None:
         with patch("pyrit.backend.routes.scenarios.get_scenario_run_service") as mock_get:
             mock_service = MagicMock()
diff --git a/tests/unit/backend/test_scenario_run_service.py b/tests/unit/backend/test_scenario_run_service.py
index 83eb1b0995..b213c6f489 100644
--- a/tests/unit/backend/test_scenario_run_service.py
+++ b/tests/unit/backend/test_scenario_run_service.py
@@ -7,7 +7,8 @@
 
 import asyncio
 import uuid
-from datetime import datetime, timezone
+from dataclasses import replace
+from datetime import datetime, timedelta, timezone
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -20,6 +21,7 @@
     ScenarioRunService,
 )
 from pyrit.converter import Converter
+from pyrit.memory import ScenarioHistoryRunRecord, ScenarioHistoryUnitRecord
 from pyrit.models import (
     SCENARIO_RUN_PLAN_METADATA_KEY,
     AtomicAttackIdentifier,
@@ -115,7 +117,9 @@ def _make_db_scenario_result(
     sr.id = result_id
     sr.scenario_name = scenario_name
     sr.scenario_version = 1
+    sr.pyrit_version = "0.10.0"
     sr.scenario_run_state = run_state
+    sr.scenario_identifier = None
     sr.get_techniques_used.return_value = []
     sr.attack_results = attack_results or {}
     sr.number_tries = 1
@@ -130,6 +134,31 @@ def _make_db_scenario_result(
     return sr
 
 
+def _make_history_record(
+    *,
+    result_id: str,
+    run_state: ScenarioRunState,
+) -> ScenarioHistoryRunRecord:
+    scenario_result = make_scenario_result(scenario_name="foundry.red_team_agent", attack_results={})
+    return ScenarioHistoryRunRecord(
+        scenario_result_id=result_id,
+        scenario_name=scenario_result.scenario_name,
+        scenario_version=scenario_result.scenario_version,
+        pyrit_version=scenario_result.pyrit_version,
+        scenario_identifier=scenario_result.scenario_identifier.model_dump(mode="json"),
+        objective_target_identifier={},
+        status=run_state.value,
+        labels={},
+        created_at=scenario_result.creation_time,
+        completed_at=scenario_result.completion_time,
+        error_message=None,
+        error_type=None,
+        scenario_registry_name=None,
+        plan_atomic_groups=None,
+        plan_seed_id_map=None,
+    )
+
+
 @pytest.fixture
 def mock_memory():
     """Patch CentralMemory.get_memory_instance to return a mock."""
@@ -646,6 +675,75 @@ def test_get_run_maps_typed_scenario_result_state(self, mock_memory) -> None:
         assert fetched.error == "Scenario failed"
         assert fetched.error_type == "RuntimeError"
 
+    @pytest.mark.parametrize(
+        ("raw_plan", "expected_registry_name", "expected_total", "expected_planned_total", "expected_warning"),
+        [
+            (
+                ScenarioRunPlan(
+                    scenario_registry_name="registered.scenario",
+                    atomic_groups=[
+                        ScenarioRunPlanAtomicGroup(
+                            id="group-1",
+                            atomic_attack_name="legacy attack",
+                            display_group="Attack",
+                            technique_eval_hash="eval",
+                            seed_group_ids=["seed-1"],
+                        )
+                    ],
+                    seed_groups=[
+                        ScenarioRunPlanSeedGroup(
+                            id="seed-1",
+                            objective_sha256=_svc_mod.to_sha256("objective"),
+                            objective="objective",
+                        )
+                    ],
+                ).model_dump(mode="json"),
+                "registered.scenario",
+                1,
+                True,
+                False,
+            ),
+            (None, None, 1, False, False),
+            ({"version": 2, "atomic_groups": [], "seed_groups": []}, None, 1, False, True),
+            ({"version": 1, "atomic_groups": "malformed", "seed_groups": []}, None, 1, False, True),
+        ],
+        ids=["valid", "legacy", "forward-version", "malformed"],
+    )
+    def test_get_run_detail_preserves_readability_across_plan_metadata(
+        self,
+        mock_memory,
+        caplog: pytest.LogCaptureFixture,
+        raw_plan: dict[str, Any] | None,
+        expected_registry_name: str | None,
+        expected_total: int,
+        expected_planned_total: bool,
+        expected_warning: bool,
+    ) -> None:
+        metadata = {SCENARIO_RUN_PLAN_METADATA_KEY: raw_plan} if raw_plan is not None else {}
+        attack_result = AttackResult(
+            conversation_id="conversation-1",
+            objective="objective",
+            outcome=AttackOutcome.SUCCESS,
+            timestamp=datetime(2025, 1, 1, tzinfo=timezone.utc),
+            attribution_data={"parent_collection": "legacy attack", "parent_eval_hash": "eval"},
+        )
+        db_result = make_scenario_result(
+            scenario_name="foundry.red_team_agent",
+            attack_results={"legacy attack": [attack_result]},
+            metadata=metadata,
+        )
+        mock_memory.get_scenario_results.return_value = [db_result]
+
+        fetched = ScenarioRunService().get_run(scenario_result_id=str(db_result.id))
+
+        assert fetched is not None
+        assert fetched.scenario_registry_name == expected_registry_name
+        assert fetched.total_attacks == expected_total
+        assert fetched.completed_attacks == 1
+        assert fetched.planned_total_available is expected_planned_total
+        assert fetched.techniques_used == (["Attack"] if expected_planned_total else ["legacy attack"])
+        assert ("using legacy run detail fields" in caplog.text) is expected_warning
+
     def test_get_run_falls_back_to_persisted_error(self, mock_memory) -> None:
         """Test that get_run extracts error from persisted error AttackResult when no active task.
 
@@ -680,31 +778,200 @@ class TestScenarioRunServiceListRuns:
 
     def test_list_runs_empty(self, mock_memory) -> None:
         """Test that list_runs returns empty list when DB has no results."""
-        mock_memory.get_scenario_result_headers.return_value = []
+        mock_memory.get_scenario_run_history_page.return_value = ([], {}, False)
         service = ScenarioRunService()
         result = service.list_runs()
         assert result.items == []
-        mock_memory.get_scenario_result_headers.assert_called_once_with(limit=100)
+        assert result.pagination.has_more is False
+        mock_memory.get_scenario_results.assert_not_called()
 
     def test_list_runs_returns_all_runs(self, mock_memory) -> None:
         """Test that list_runs returns all runs from the database."""
-        db_results = [
-            _make_db_scenario_result(result_id="sr-1", run_state=ScenarioRunState.COMPLETED),
-            _make_db_scenario_result(result_id="sr-2", run_state=ScenarioRunState.IN_PROGRESS),
+        records = [
+            _make_history_record(result_id="sr-1", run_state=ScenarioRunState.COMPLETED),
+            _make_history_record(result_id="sr-2", run_state=ScenarioRunState.IN_PROGRESS),
         ]
-        mock_memory.get_scenario_result_headers.return_value = db_results
+        mock_memory.get_scenario_run_history_page.return_value = (records, {"sr-1": [], "sr-2": []}, False)
 
         service = ScenarioRunService()
         result = service.list_runs()
         assert len(result.items) == 2
-        mock_memory.get_scenario_result_headers.assert_called_once_with(limit=100)
+        assert [item.scenario_result_id for item in result.items] == ["sr-1", "sr-2"]
+        mock_memory.get_scenario_results.assert_not_called()
 
     def test_list_runs_passes_custom_limit(self, mock_memory) -> None:
         """Test that list_runs passes a custom limit to the memory query."""
-        mock_memory.get_scenario_result_headers.return_value = []
+        mock_memory.get_scenario_run_history_page.return_value = ([], {}, False)
         service = ScenarioRunService()
         service.list_runs(limit=10)
-        mock_memory.get_scenario_result_headers.assert_called_once_with(limit=10)
+        mock_memory.get_scenario_run_history_page.assert_called_once_with(
+            scenario_names=[],
+            statuses=[],
+            labels=None,
+            cursor=None,
+            limit=10,
+        )
+
+    def test_history_cursor_is_filter_bound_and_rejects_malformed_values(self, mock_memory) -> None:
+        record = _make_history_record(result_id=str(uuid.uuid4()), run_state=ScenarioRunState.COMPLETED)
+        mock_memory.get_scenario_run_history_page.return_value = ([record], {record.scenario_result_id: []}, True)
+        service = ScenarioRunService()
+
+        first_page = service.list_runs(scenario_names=["first"], labels={"operator": ["alice", "bob"]})
+
+        assert first_page.pagination.has_more is True
+        assert first_page.pagination.next_cursor is not None
+        with pytest.raises(ValueError, match="filters"):
+            service.list_runs(scenario_names=["second"], cursor=first_page.pagination.next_cursor)
+        with pytest.raises(ValueError, match="Malformed scenario history cursor"):
+            service.list_runs(cursor="not-a-cursor")
+
+    def test_history_uses_plan_and_latest_non_error_attempt_per_unit(self, mock_memory) -> None:
+        record = _make_history_record(result_id="sr-aggregate", run_state=ScenarioRunState.COMPLETED)
+        plan = ScenarioRunPlan(
+            scenario_registry_name="registered.scenario",
+            atomic_groups=[
+                ScenarioRunPlanAtomicGroup(
+                    id="group-1",
+                    atomic_attack_name="attack",
+                    display_group="Attack",
+                    technique_eval_hash="eval-1",
+                    seed_group_ids=["seed-1", "seed-2"],
+                )
+            ],
+            seed_groups=[
+                ScenarioRunPlanSeedGroup(id="seed-1", objective_sha256="hash-1", objective="first"),
+                ScenarioRunPlanSeedGroup(id="seed-2", objective_sha256="hash-2", objective="second"),
+            ],
+        )
+        record = replace(
+            record,
+            scenario_registry_name=plan.scenario_registry_name,
+            plan_atomic_groups=[group.model_dump(mode="json") for group in plan.atomic_groups],
+            plan_seed_id_map=[{"id": seed.id, "objective_sha256": seed.objective_sha256} for seed in plan.seed_groups],
+        )
+        timestamp = datetime(2026, 8, 7, tzinfo=timezone.utc)
+        units = [
+            ScenarioHistoryUnitRecord(
+                scenario_result_id=record.scenario_result_id,
+                atomic_attack_name="attack",
+                technique_eval_hash="eval-1",
+                seed_group_id="hash-1",
+                objective_sha256="hash-1",
+                latest_outcome=AttackOutcome.ERROR.value,
+                latest_timestamp=timestamp - timedelta(seconds=1),
+                total_retries=0,
+                error_count=1,
+            ),
+            ScenarioHistoryUnitRecord(
+                scenario_result_id=record.scenario_result_id,
+                atomic_attack_name="attack",
+                technique_eval_hash="eval-1",
+                seed_group_id="seed-1",
+                objective_sha256="hash-1",
+                latest_outcome=AttackOutcome.SUCCESS.value,
+                latest_timestamp=timestamp,
+                total_retries=2,
+                error_count=0,
+            ),
+        ]
+        mock_memory.get_scenario_run_history_page.return_value = (
+            [record],
+            {record.scenario_result_id: units},
+            False,
+        )
+
+        summary = ScenarioRunService().list_runs().items[0]
+
+        assert summary.total_attacks == 2
+        assert summary.completed_attacks == 1
+        assert summary.successful_attacks == 1
+        assert summary.error_attacks == 1
+        assert summary.total_retries == 3
+        assert summary.planned_total_available is True
+        assert summary.attack_details_available is False
+
+    def test_history_metadata_is_allow_listed_and_secret_free(self, mock_memory) -> None:
+        scenario_result = make_scenario_result(
+            scenario_name="SafeScenario",
+            objective_target_identifier=ComponentIdentifier(
+                class_name="OpenAIChatTarget",
+                class_module="tests",
+                endpoint="https://user:password@example.test/v1?api-key=secret#fragment",
+                model_name="gpt-4o",
+            ),
+            params={
+                "max_turns": 5,
+                "api_key": "top-secret",
+                "connection_string": "AccountKey=connection-secret",
+                "headers": {"X-Custom": "header-secret"},
+                "nested": {"access_token": "also-secret", "safe": "visible"},
+            },
+            datasets=["harmbench"],
+            attack_results={},
+        )
+        record = _make_history_record(result_id="sr-safe", run_state=ScenarioRunState.COMPLETED)
+        record = replace(
+            record,
+            scenario_name=scenario_result.scenario_name,
+            scenario_identifier=scenario_result.scenario_identifier.model_dump(mode="json"),
+        )
+        mock_memory.get_scenario_run_history_page.return_value = ([record], {record.scenario_result_id: []}, False)
+
+        summary = ScenarioRunService().list_runs().items[0]
+        serialized = summary.model_dump_json()
+
+        assert summary.target is not None
+        assert summary.target.endpoint == "https://example.test"
+        assert summary.target.model_name == "gpt-4o"
+        assert summary.datasets_used == ["harmbench"]
+        assert summary.scenario_parameters["max_turns"] == 5
+        assert "connection_string" not in summary.scenario_parameters
+        assert "headers" not in summary.scenario_parameters
+        assert "nested" not in summary.scenario_parameters
+        assert "top-secret" not in serialized
+        assert "also-secret" not in serialized
+        assert "connection-secret" not in serialized
+        assert "header-secret" not in serialized
+        assert "/v1" not in serialized
+        assert "password" not in serialized
+
+    def test_history_falls_back_honestly_for_incomplete_persisted_plan(self, mock_memory) -> None:
+        record = _make_history_record(result_id="sr-legacy", run_state=ScenarioRunState.COMPLETED)
+        record = replace(
+            record,
+            scenario_registry_name="registered.scenario",
+            plan_atomic_groups="{}",
+            plan_seed_id_map="[]",
+        )
+        mock_memory.get_scenario_run_history_page.return_value = ([record], {record.scenario_result_id: []}, False)
+
+        summary = ScenarioRunService().list_runs().items[0]
+
+        assert summary.planned_total_available is False
+        assert summary.total_attacks == 0
+        assert summary.completed_attacks == 0
+
+    def test_history_discards_duplicate_plan_groups_before_legacy_fallback(self, mock_memory) -> None:
+        record = _make_history_record(result_id="sr-duplicate-plan", run_state=ScenarioRunState.COMPLETED)
+        group = ScenarioRunPlanAtomicGroup(
+            id="duplicate",
+            atomic_attack_name="attack",
+            display_group="Attack",
+            technique_eval_hash="eval",
+            seed_group_ids=["seed-1"],
+        ).model_dump(mode="json")
+        record = replace(
+            record,
+            plan_atomic_groups=[group, group],
+            plan_seed_id_map=[{"id": "seed-1", "objective_sha256": "hash-1"}],
+        )
+        mock_memory.get_scenario_run_history_page.return_value = ([record], {record.scenario_result_id: []}, False)
+
+        summary = ScenarioRunService().list_runs().items[0]
+
+        assert summary.planned_total_available is False
+        assert summary.total_attacks == 0
 
     def test_list_runs_reports_unknown_total_without_plan(self, mock_memory) -> None:
         """Test that legacy runs do not report a false zero planned total."""
diff --git a/tests/unit/cli/test_api_client.py b/tests/unit/cli/test_api_client.py
index 8267b36293..261d812ba2 100644
--- a/tests/unit/cli/test_api_client.py
+++ b/tests/unit/cli/test_api_client.py
@@ -6,7 +6,7 @@
 """
 
 from datetime import datetime, timezone
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, call, patch
 
 import httpx
 import pytest
@@ -506,6 +506,33 @@ async def test_get_conversation_messages_async(client, mock_httpx_client):
     mock_httpx_client.get.assert_awaited_once_with("/api/attacks/a1/messages", params={"conversation_id": "c1"})
 
 
+async def test_list_scenario_runs_async_follows_bounded_pages(client, mock_httpx_client):
+    first_page = [_run_summary_payload() for _ in range(100)]
+    second_page = [_run_summary_payload()]
+    mock_httpx_client.get.side_effect = [
+        _make_response(
+            json_data={
+                "items": first_page,
+                "pagination": {"limit": 100, "has_more": True, "next_cursor": "next-page"},
+            }
+        ),
+        _make_response(
+            json_data={
+                "items": second_page,
+                "pagination": {"limit": 1, "has_more": False},
+            }
+        ),
+    ]
+
+    result = await client.list_scenario_runs_async(limit=101)
+
+    assert len(result) == 101
+    assert mock_httpx_client.get.await_args_list == [
+        call("/api/scenarios/runs", params={"limit": 100}),
+        call("/api/scenarios/runs", params={"limit": 1, "cursor": "next-page"}),
+    ]
+
+
 # ---------------------------------------------------------------------------
 # _get_json_async error path
 # ---------------------------------------------------------------------------
diff --git a/tests/unit/memory/memory_interface/test_interface_scenario_history.py b/tests/unit/memory/memory_interface/test_interface_scenario_history.py
new file mode 100644
index 0000000000..07c8d2de3d
--- /dev/null
+++ b/tests/unit/memory/memory_interface/test_interface_scenario_history.py
@@ -0,0 +1,237 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Tests for lightweight scenario-history memory queries."""
+
+import json
+import uuid
+from datetime import datetime, timedelta, timezone
+from unittest.mock import MagicMock
+
+import pytest
+from unit.mocks import get_mock_target_identifier, make_scenario_result
+
+from pyrit.memory import MemoryInterface, ScenarioHistoryKeysetCursor
+from pyrit.memory.memory_models import ScenarioResultEntry
+from pyrit.models import (
+    SCENARIO_RUN_PLAN_METADATA_KEY,
+    AttackOutcome,
+    AttackResult,
+    ScenarioRunPlan,
+    ScenarioRunPlanAtomicGroup,
+    ScenarioRunPlanSeedGroup,
+    ScenarioRunState,
+)
+
+
+@pytest.mark.parametrize(
+    ("method_name", "kwargs"),
+    [
+        ("_get_scenario_registry_name_condition", {"scenario_names": ["test.scenario"]}),
+        ("_get_scenario_history_plan_expressions", {}),
+        ("_get_scenario_attempt_unit_expressions", {}),
+    ],
+)
+def test_scenario_history_dialect_hooks_are_optional_until_used(
+    method_name: str,
+    kwargs: dict[str, object],
+) -> None:
+    assert method_name not in MemoryInterface.__abstractmethods__
+
+    with pytest.raises(NotImplementedError, match=method_name):
+        getattr(MemoryInterface, method_name)(MagicMock(), **kwargs)
+
+
+def _make_scenario(
+    *,
+    result_id: uuid.UUID,
+    timestamp: datetime,
+    name: str,
+    state: ScenarioRunState,
+    labels: dict[str, str],
+    registry_name: str | None = None,
+):
+    metadata = {}
+    if registry_name:
+        metadata[SCENARIO_RUN_PLAN_METADATA_KEY] = ScenarioRunPlan(
+            scenario_registry_name=registry_name,
+            atomic_groups=[
+                ScenarioRunPlanAtomicGroup(
+                    id="group-1",
+                    atomic_attack_name="attack",
+                    display_group="Attack",
+                    technique_eval_hash="eval-1",
+                    seed_group_ids=["seed-1"],
+                )
+            ],
+            seed_groups=[
+                ScenarioRunPlanSeedGroup(
+                    id="seed-1",
+                    objective_sha256="objective-hash",
+                    objective="objective",
+                )
+            ],
+        ).model_dump(mode="json", exclude_none=True)
+    return make_scenario_result(
+        id=result_id,
+        scenario_name=name,
+        scenario_run_state=state,
+        labels=labels,
+        creation_time=timestamp,
+        completion_time=timestamp + timedelta(minutes=1),
+        metadata=metadata,
+        attack_results={},
+        objective_target_identifier=get_mock_target_identifier(),
+    )
+
+
+def test_history_pages_descending_equal_timestamps_by_id(sqlite_instance: MemoryInterface) -> None:
+    timestamp = datetime(2026, 8, 7, tzinfo=timezone.utc)
+    scenarios = [
+        _make_scenario(
+            result_id=uuid.UUID(int=value),
+            timestamp=timestamp,
+            name=f"Scenario{value}",
+            state=ScenarioRunState.COMPLETED,
+            labels={},
+        )
+        for value in (1, 2, 3)
+    ]
+    sqlite_instance.add_scenario_results_to_memory(scenario_results=scenarios)
+    entries = sqlite_instance._query_entries(ScenarioResultEntry)
+    for entry in entries:
+        entry.timestamp = timestamp
+        sqlite_instance._update_entry(entry)
+
+    first_page, _, has_more = sqlite_instance.get_scenario_run_history_page(limit=2)
+    second_page, _, second_has_more = sqlite_instance.get_scenario_run_history_page(
+        cursor=ScenarioHistoryKeysetCursor(
+            timestamp=first_page[-1].created_at,
+            scenario_result_id=first_page[-1].scenario_result_id,
+        ),
+        limit=2,
+    )
+
+    assert [row.scenario_result_id for row in first_page] == [str(uuid.UUID(int=3)), str(uuid.UUID(int=2))]
+    assert has_more is True
+    assert [row.scenario_result_id for row in second_page] == [str(uuid.UUID(int=1))]
+    assert second_has_more is False
+
+
+def test_history_filters_names_statuses_and_labels_without_hydration(
+    sqlite_instance: MemoryInterface,
+    monkeypatch,
+) -> None:
+    timestamp = datetime(2026, 8, 7, tzinfo=timezone.utc)
+    included = _make_scenario(
+        result_id=uuid.UUID(int=10),
+        timestamp=timestamp,
+        name="ImplementationClass",
+        registry_name="registered.scenario",
+        state=ScenarioRunState.IN_PROGRESS,
+        labels={"operator": "alice", "operation": "nightly", "team.name": "safety"},
+    )
+    excluded = _make_scenario(
+        result_id=uuid.UUID(int=11),
+        timestamp=timestamp - timedelta(minutes=1),
+        name="OtherScenario",
+        state=ScenarioRunState.COMPLETED,
+        labels={"operator": "bob", "operation": "nightly", "team.name": "safety"},
+    )
+    sqlite_instance.add_scenario_results_to_memory(scenario_results=[included, excluded])
+    attacks = [
+        AttackResult(
+            attack_result_id=str(uuid.UUID(int=12)),
+            conversation_id="conversation-12",
+            objective="objective",
+            outcome=AttackOutcome.ERROR,
+            execution_time_ms=1,
+            timestamp=timestamp,
+            attribution_parent_id=str(included.id),
+            attribution_data={
+                "parent_collection": "attack",
+                "parent_eval_hash": "eval-1",
+                "seed_group_id": "seed-1",
+            },
+            error_type="RuntimeError",
+            error_message="failed",
+        ),
+        AttackResult(
+            attack_result_id=str(uuid.UUID(int=13)),
+            conversation_id="conversation-13",
+            objective="objective",
+            outcome=AttackOutcome.SUCCESS,
+            execution_time_ms=1,
+            timestamp=timestamp + timedelta(seconds=1),
+            total_retries=2,
+            attribution_parent_id=str(included.id),
+            attribution_data={
+                "parent_collection": "attack",
+                "parent_eval_hash": "eval-1",
+                "seed_group_id": "seed-1",
+            },
+        ),
+    ]
+    sqlite_instance.add_attack_results_to_memory(attack_results=attacks)
+    monkeypatch.setattr(
+        "pyrit.memory.memory_models.AttackResultEntry.get_attack_result",
+        MagicMock(side_effect=AssertionError("history hydrated an AttackResult")),
+    )
+
+    rows, units, has_more = sqlite_instance.get_scenario_run_history_page(
+        scenario_names=["registered.scenario"],
+        statuses=[ScenarioRunState.IN_PROGRESS.value],
+        labels={
+            "operator": ["alice", "carol"],
+            "operation": "nightly",
+            "team.name": ["safety"],
+        },
+        limit=25,
+    )
+
+    assert [row.scenario_result_id for row in rows] == [str(included.id)]
+    assert rows[0].scenario_identifier["class_name"] == "ImplementationClass"
+    assert rows[0].scenario_registry_name == "registered.scenario"
+    compact_groups = (
+        json.loads(rows[0].plan_atomic_groups)
+        if isinstance(rows[0].plan_atomic_groups, str)
+        else rows[0].plan_atomic_groups
+    )
+    assert compact_groups == [
+        {
+            "id": "group-1",
+            "atomic_attack_name": "attack",
+            "display_group": "Attack",
+            "technique_eval_hash": "eval-1",
+            "seed_group_ids": ["seed-1"],
+        }
+    ]
+    compact_seed_map = (
+        json.loads(rows[0].plan_seed_id_map) if isinstance(rows[0].plan_seed_id_map, str) else rows[0].plan_seed_id_map
+    )
+    assert compact_seed_map == [{"id": "seed-1", "objective_sha256": "objective-hash"}]
+    assert len(units[str(included.id)]) == 1
+    assert units[str(included.id)][0].latest_outcome == AttackOutcome.SUCCESS.value
+    assert units[str(included.id)][0].error_count == 1
+    assert units[str(included.id)][0].total_retries == 3
+    assert has_more is False
+
+
+def test_unique_scenario_labels_are_grouped_for_filter_options(sqlite_instance: MemoryInterface) -> None:
+    timestamp = datetime(2026, 8, 7, tzinfo=timezone.utc)
+    scenarios = [
+        _make_scenario(
+            result_id=uuid.UUID(int=index),
+            timestamp=timestamp,
+            name=f"Scenario{index}",
+            state=ScenarioRunState.COMPLETED,
+            labels={"operator": operator, "operation": "nightly"},
+        )
+        for index, operator in ((20, "alice"), (21, "bob"), (22, "alice"))
+    ]
+    sqlite_instance.add_scenario_results_to_memory(scenario_results=scenarios)
+
+    assert sqlite_instance.get_unique_scenario_labels() == {
+        "operation": ["nightly"],
+        "operator": ["alice", "bob"],
+    }
diff --git a/tests/unit/memory/test_azure_sql_memory.py b/tests/unit/memory/test_azure_sql_memory.py
index c2a1cfafee..298a209fb2 100644
--- a/tests/unit/memory/test_azure_sql_memory.py
+++ b/tests/unit/memory/test_azure_sql_memory.py
@@ -8,11 +8,12 @@
 from unittest.mock import MagicMock, patch
 
 import pytest
-from sqlalchemy import inspect, text
+from sqlalchemy import inspect, or_, select, text
 
 from pyrit.common.singleton import Singleton
 from pyrit.converter.base64_converter import Base64Converter
 from pyrit.memory import AzureSQLMemory, EmbeddingDataEntry, PromptMemoryEntry
+from pyrit.memory.memory_models import ScenarioResultEntry
 from pyrit.memory.storage.serializers import set_message_piece_sha256_async
 from pyrit.models import Conversation, MessagePiece
 from pyrit.prompt_target.text_target import TextTarget
@@ -437,6 +438,39 @@ def test_get_attack_result_label_condition_empty_labels_dict(memory_interface: A
     assert not any("label_" in k for k in params)
 
 
+def test_scenario_history_conditions_bind_or_within_label_and_registry_values(
+    memory_interface: AzureSQLMemory,
+) -> None:
+    """Scenario-history SQL Server conditions bind repeated values without interpolation."""
+    label_condition = memory_interface._get_scenario_result_label_condition(
+        labels={"team.name": ["alice", "bob"], "operation": "nightly"}
+    )
+    registry_condition = memory_interface._get_scenario_registry_name_condition(
+        scenario_names=["first.scenario", "second.scenario"]
+    )
+
+    assert label_condition.compile().params == {
+        "scenario_label_path_0": '$."team.name"',
+        "scenario_label_value_0_0": "alice",
+        "scenario_label_value_0_1": "bob",
+        "scenario_label_path_1": '$."operation"',
+        "scenario_label_value_1_0": "nightly",
+    }
+    assert registry_condition.compile().params == {
+        "scenario_registry_name_0": "first.scenario",
+        "scenario_registry_name_1": "second.scenario",
+    }
+    assert " IN (" in str(label_condition)
+    assert " AND " in str(label_condition)
+    combined_statement = select(ScenarioResultEntry.id).where(
+        or_(
+            ScenarioResultEntry.scenario_name.in_(["first.scenario", "second.scenario"]),
+            registry_condition,
+        )
+    )
+    assert "scenario_registry_name_1" in combined_statement.compile().params
+
+
 @pytest.mark.parametrize(
     "case_sensitive, partial_match, expected_sql_fragment",
     [
diff --git a/tests/unit/scenario/airt/test_jailbreak.py b/tests/unit/scenario/airt/test_jailbreak.py
index 412e8177e9..284736b104 100644
--- a/tests/unit/scenario/airt/test_jailbreak.py
+++ b/tests/unit/scenario/airt/test_jailbreak.py
@@ -182,6 +182,13 @@ def test_declares_run_parameters(self):
         assert names == {"num_jailbreaks", "num_jailbreak_attempts", "jailbreak_names"}
         assert set(names).issubset({p.name for p in Jailbreak.supported_parameters()})
 
+    @pytest.mark.parametrize("num_attempts", [0, -1])
+    def test_rejects_non_positive_num_jailbreak_attempts(self, mock_objective_scorer, num_attempts: int) -> None:
+        scenario = Jailbreak(objective_scorer=mock_objective_scorer)
+
+        with pytest.raises(ValueError, match="num_jailbreak_attempts must be at least 1"):
+            scenario.set_params_from_args(args={"num_jailbreak_attempts": num_attempts})
+
     async def test_default_draws_random_template_sample(
         self, mock_objective_target, mock_objective_scorer, mock_memory_seed_groups
     ):

From ad2c9db92178d17d8ac27c7ee357057d3a20c89f Mon Sep 17 00:00:00 2001
From: Richard Lundeen <rlundeen@microsoft.com>
Date: Tue, 1 Sep 2026 14:09:16 -0700
Subject: [PATCH 02/12] FIX: Linearize scenario history migration

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 4c3dcf30-9f5f-4c03-97bb-cc20d7d04cab
---
 .../alembic/versions/8d1e3f5a7b9c_index_scenario_history.py   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyrit/memory/alembic/versions/8d1e3f5a7b9c_index_scenario_history.py b/pyrit/memory/alembic/versions/8d1e3f5a7b9c_index_scenario_history.py
index f5747554ff..2266b155e7 100644
--- a/pyrit/memory/alembic/versions/8d1e3f5a7b9c_index_scenario_history.py
+++ b/pyrit/memory/alembic/versions/8d1e3f5a7b9c_index_scenario_history.py
@@ -5,7 +5,7 @@
 Index scenario results for descending history keyset pagination.
 
 Revision ID: 8d1e3f5a7b9c
-Revises: 6b8d0f2a4c1e
+Revises: 8e2c4a6b0d13
 Create Date: 2026-08-06 22:40:00.000000
 """
 
@@ -14,7 +14,7 @@
 from alembic import op
 
 revision: str = "8d1e3f5a7b9c"
-down_revision: str | None = "6b8d0f2a4c1e"
+down_revision: str | None = "8e2c4a6b0d13"
 branch_labels: str | Sequence[str] | None = None
 depends_on: str | Sequence[str] | None = None
 

From ff8473165cb3b37ab64dfa5c5ed2b3e49db8cb86 Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Wed, 12 Aug 2026 03:20:44 -0700
Subject: [PATCH 03/12] FEAT: Add FIFO scenario scheduling

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 5d02c2d5-b499-4f78-a04d-03bffa750817
---
 frontend/e2e/scenario-history.spec.ts         | 103 +++
 .../History/ScenarioHistory.styles.ts         |   3 +
 .../History/ScenarioHistory.test.tsx          |  96 +++
 .../components/History/ScenarioHistory.tsx    |  19 +-
 .../Scenarios/ScenarioQueue.styles.ts         |  76 ++
 .../Scenarios/ScenarioQueue.test.tsx          | 138 ++++
 .../components/Scenarios/ScenarioQueue.tsx    |  94 +++
 .../Scenarios/ScenarioRunPage.styles.ts       |   3 +
 .../Scenarios/ScenarioRunPage.test.tsx        |  68 +-
 .../components/Scenarios/ScenarioRunPage.tsx  |  79 +-
 frontend/src/hooks/useScenarioQueue.test.tsx  | 148 ++++
 frontend/src/hooks/useScenarioQueue.ts        |  82 ++
 frontend/src/services/api.ts                  |   6 +
 frontend/src/types/index.ts                   |  37 +
 .../src/utils/scenarioRunProgress.test.ts     |  97 ++-
 frontend/src/utils/scenarioRunProgress.ts     |  45 +-
 pyrit/backend/main.py                         |   9 +-
 pyrit/backend/routes/scenarios.py             |  23 +-
 .../backend/services/scenario_run_service.py  | 747 ++++++++++++++++--
 pyrit/exceptions/retry_collector.py           |   7 +
 pyrit/memory/__init__.py                      |   4 +
 pyrit/memory/azure_sql_memory.py              |  24 +-
 pyrit/memory/memory_interface.py              | 174 +++-
 pyrit/memory/sqlite_memory.py                 |  19 +-
 pyrit/models/__init__.py                      |   6 +
 pyrit/models/catalog/scenario.py              |  24 +-
 pyrit/models/results/scenario_result.py       |   1 +
 pyrit/models/retry_event.py                   |   1 +
 pyrit/models/scenario_progress.py             |  29 +-
 .../registry/components/scenario_registry.py  |   6 +
 pyrit/scenario/core/scenario.py               |  12 +-
 tests/unit/backend/test_main.py               |  56 +-
 .../unit/backend/test_scenario_run_routes.py  |  58 +-
 .../unit/backend/test_scenario_run_service.py | 568 ++++++++++++-
 tests/unit/backend/test_scenario_service.py   |  12 +-
 tests/unit/exceptions/test_retry_collector.py |  19 +
 .../test_interface_scenario_history.py        | 113 ++-
 tests/unit/memory/test_azure_sql_memory.py    |   2 +-
 tests/unit/registry/test_scenario_registry.py |   2 +
 tests/unit/scenario/core/test_scenario.py     |  20 +
 40 files changed, 2867 insertions(+), 163 deletions(-)
 create mode 100644 frontend/src/components/Scenarios/ScenarioQueue.styles.ts
 create mode 100644 frontend/src/components/Scenarios/ScenarioQueue.test.tsx
 create mode 100644 frontend/src/components/Scenarios/ScenarioQueue.tsx
 create mode 100644 frontend/src/hooks/useScenarioQueue.test.tsx
 create mode 100644 frontend/src/hooks/useScenarioQueue.ts

diff --git a/frontend/e2e/scenario-history.spec.ts b/frontend/e2e/scenario-history.spec.ts
index 90f0c4a7ec..21669515b7 100644
--- a/frontend/e2e/scenario-history.spec.ts
+++ b/frontend/e2e/scenario-history.spec.ts
@@ -1,6 +1,8 @@
 import { expect, test, type Page } from "@playwright/test";
 
 const RUN_ID = "123e4567-e89b-12d3-a456-426614174000";
+const ACTIVE_RUN_ID = "123e4567-e89b-12d3-a456-426614174001";
+const QUEUED_RUN_ID = "123e4567-e89b-12d3-a456-426614174002";
 const ATTACK_ID = "attack-result-1";
 const SCENARIO_NAME = "airt.jailbreak";
 const RAW_IMAGE_HTML = '<img src=x onerror="alert(1)">unsafe';
@@ -585,4 +587,105 @@ test.describe("Scenario catalog, history, and live run routing", () => {
     expect((await refresh.boundingBox())?.height).toBeGreaterThanOrEqual(44);
     expect((await row.boundingBox())?.height).toBeGreaterThanOrEqual(44);
   });
+
+  test("renders deterministic FIFO position changes and queued-to-completed handoff", async ({ page }) => {
+    await mockScenarioAPIs(page);
+    let progressRequests = 0;
+    let queueRequests = 0;
+
+    await page.route(new RegExp(`/api/scenarios/runs/${QUEUED_RUN_ID}/progress(?:\\?|$)`), async (route) => {
+      progressRequests += 1;
+      const statuses = ["QUEUED", "QUEUED", "IN_PROGRESS", "COMPLETED"] as const;
+      const status = statuses[Math.min(progressRequests - 1, statuses.length - 1)];
+      const queuePosition = status === "QUEUED" ? (progressRequests === 1 ? 2 : 1) : null;
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          run: {
+            ...runSummary,
+            scenario_result_id: QUEUED_RUN_ID,
+            status,
+            completed_at: status === "COMPLETED" ? runSummary.completed_at : null,
+            queue_position: queuePosition,
+            active_scenario_result_id: status === "QUEUED" ? ACTIVE_RUN_ID : QUEUED_RUN_ID,
+            overload_summaries: [{
+              component_role: "objective_target",
+              count: 2,
+              rate_limit_count: 1,
+              server_error_count: 1,
+              status_codes: [429, 503],
+              latest_timestamp: "2026-08-07T00:00:45Z",
+            }],
+          },
+          plan: progressRequests === 1 ? plan : null,
+          reset: progressRequests === 1,
+          active_atomic_group_ids: status === "IN_PROGRESS" ? ["group-1"] : [],
+          results: status === "COMPLETED" ? [progressAttempt] : [],
+          next_cursor: `queue-progress-${progressRequests}`,
+          has_more: false,
+          plan_complete: true,
+        }),
+      });
+    });
+
+    await page.route(/\/api\/scenarios\/runs\/queue(?:\?|$)/, async (route) => {
+      queueRequests += 1;
+      const active = {
+        scenario_result_id: ACTIVE_RUN_ID,
+        scenario_name: "Active scenario",
+        scenario_registry_name: "active.scenario",
+        state: "IN_PROGRESS",
+        created_at: "2026-08-07T00:00:00Z",
+        enqueued_at: "2026-08-07T00:00:00Z",
+        started_at: "2026-08-07T00:00:01Z",
+      };
+      const queued = {
+        scenario_result_id: QUEUED_RUN_ID,
+        scenario_name: "Jailbreak",
+        scenario_registry_name: SCENARIO_NAME,
+        state: "QUEUED",
+        position: queueRequests === 1 ? 2 : 1,
+        created_at: runSummary.created_at,
+        enqueued_at: runSummary.created_at,
+      };
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          revision: queueRequests,
+          snapshot_at: `2026-08-07T00:00:0${Math.min(queueRequests, 9)}Z`,
+          active: queueRequests < 3 ? active : queueRequests === 3 ? { ...queued, state: "IN_PROGRESS", position: null } : null,
+          queued: queueRequests < 3
+            ? [
+                ...(queueRequests === 1 ? [{ ...queued, scenario_result_id: RUN_ID, position: 1 }] : []),
+                queued,
+              ]
+            : [],
+        }),
+      });
+    });
+
+    await page.goto(`/scenario-history/${QUEUED_RUN_ID}`);
+
+    await expect(page.getByTestId("run-state-badge")).toHaveText("Queued");
+    await expect(page.getByTestId("queued-run-progress")).toContainText("Position 2");
+    await expect(page.getByTestId("queued-run-progress")).not.toContainText("%");
+    await expect(page.getByRole("link", { name: new RegExp(ACTIVE_RUN_ID) })).toHaveAttribute(
+      "href",
+      `/scenario-history/${ACTIVE_RUN_ID}`,
+    );
+    const warning = page.getByTestId("scenario-overload-warning");
+    await expect(warning).toContainText("Objective target");
+    await expect(warning).toContainText("2 × HTTP 429/503");
+    await expect(warning).toContainText("without adaptive throttling");
+    await page.setViewportSize({ width: 390, height: 844 });
+    expect((await page.getByRole("button", { name: "Cancel run" }).boundingBox())?.height).toBeGreaterThanOrEqual(44);
+    await expect(page.getByTestId("queued-run-progress")).toContainText("Position 1", { timeout: 6_000 });
+    await expect(page.getByTestId("run-state-badge")).toHaveText("In progress", { timeout: 6_000 });
+    await expect(page.getByTestId("run-state-badge")).toHaveText("Completed", { timeout: 6_000 });
+    expect(progressRequests).toBe(4);
+
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBeLessThanOrEqual(390);
+  });
 });
diff --git a/frontend/src/components/History/ScenarioHistory.styles.ts b/frontend/src/components/History/ScenarioHistory.styles.ts
index 5d83d5776a..088650a03d 100644
--- a/frontend/src/components/History/ScenarioHistory.styles.ts
+++ b/frontend/src/components/History/ScenarioHistory.styles.ts
@@ -46,6 +46,9 @@ export const useScenarioHistoryStyles = makeStyles({
     flex: 1,
     overflow: 'auto',
   },
+  queue: {
+    padding: `${tokens.spacingVerticalM} ${tokens.spacingHorizontalXXL} 0`,
+  },
   table: {
     minWidth: '1120px',
   },
diff --git a/frontend/src/components/History/ScenarioHistory.test.tsx b/frontend/src/components/History/ScenarioHistory.test.tsx
index faf7f43b04..c8ec9ce51f 100644
--- a/frontend/src/components/History/ScenarioHistory.test.tsx
+++ b/frontend/src/components/History/ScenarioHistory.test.tsx
@@ -2,6 +2,7 @@ import { FluentProvider, webLightTheme } from '@fluentui/react-components'
 import { render, screen, waitFor } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 
+import { useScenarioQueue } from '@/hooks/useScenarioQueue'
 import { labelsApi, scenariosApi } from '@/services/api'
 import type { ScenarioRunListItem } from '@/types'
 
@@ -18,8 +19,13 @@ jest.mock('@/services/api', () => ({
   },
 }))
 
+jest.mock('@/hooks/useScenarioQueue', () => ({
+  useScenarioQueue: jest.fn(),
+}))
+
 const mockedScenariosApi = scenariosApi as jest.Mocked<typeof scenariosApi>
 const mockedLabelsApi = labelsApi as jest.Mocked<typeof labelsApi>
+const mockUseScenarioQueue = useScenarioQueue as jest.Mock
 
 const RUN: ScenarioRunListItem = {
   scenario_result_id: 'run-1',
@@ -28,6 +34,7 @@ const RUN: ScenarioRunListItem = {
   scenario_version: 3,
   status: 'COMPLETED',
   created_at: '2026-01-01T00:00:00Z',
+  started_at: '2026-01-01T00:00:05Z',
   updated_at: '2026-01-01T00:01:00Z',
   completed_at: '2026-01-01T00:01:00Z',
   techniques_used: ['prompt injection'],
@@ -68,6 +75,13 @@ function renderHistory(props = defaultProps) {
 describe('ScenarioHistory', () => {
   beforeEach(() => {
     jest.clearAllMocks()
+    mockUseScenarioQueue.mockReturnValue({
+      snapshot: { revision: 0, snapshot_at: '2026-01-01T00:00:00Z', active: null, queued: [] },
+      loading: false,
+      stale: false,
+      error: null,
+      retry: jest.fn(),
+    })
     mockedScenariosApi.listCatalog.mockResolvedValue({
       items: [{ scenario_name: 'foundry.red_team' }] as Awaited<ReturnType<typeof scenariosApi.listCatalog>>['items'],
       pagination: { limit: 100, has_more: false },
@@ -78,6 +92,10 @@ describe('ScenarioHistory', () => {
     })
   })
 
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
   it('renders safe run metadata and opens rows by click or keyboard', async () => {
     const user = userEvent.setup()
     const onOpenRun = jest.fn()
@@ -127,6 +145,84 @@ describe('ScenarioHistory', () => {
     expect(screen.queryByText('1/1 (100%)')).not.toBeInTheDocument()
   })
 
+  it('renders safe fallbacks when optional run metadata is unavailable', async () => {
+    jest.spyOn(Date, 'now').mockReturnValue(Date.parse('2026-01-01T00:00:30Z'))
+    mockedScenariosApi.listRuns.mockResolvedValue({
+      items: [{
+        ...RUN,
+        scenario_name: 'LegacyScenario',
+        scenario_registry_name: null,
+        scenario_version: 1,
+        status: 'IN_PROGRESS',
+        started_at: '2026-01-01T00:00:20Z',
+        completed_at: null,
+        total_attacks: 0,
+        completed_attacks: 0,
+        successful_attacks: undefined,
+        objective_achieved_rate: 0,
+        failed_attacks: [{
+          atomic_attack_name: 'legacy-attack',
+          objective: 'Legacy objective',
+          total_retries: 0,
+        }],
+        error_attacks: undefined,
+        total_retries: 0,
+        labels: {},
+        target: {
+          target_type: 'TextTarget',
+          endpoint: null,
+          model_name: null,
+        },
+      }],
+      pagination: { limit: 25, has_more: false },
+    })
+
+    renderHistory()
+
+    expect(await screen.findByRole('link', {
+      name: 'Open LegacyScenario scenario run',
+    })).toBeInTheDocument()
+    expect(screen.getByText('v1')).toBeInTheDocument()
+    expect(screen.getAllByText('TextTarget')).toHaveLength(2)
+    expect(screen.getByText('Not yet')).toBeInTheDocument()
+    expect(screen.getByText('10s elapsed')).toBeInTheDocument()
+    expect(screen.getAllByText('0/0')).toHaveLength(2)
+    expect(screen.getByText('1 / 0')).toBeInTheDocument()
+  })
+
+  it('does not display queue wait as execution elapsed time', async () => {
+    mockedScenariosApi.listRuns.mockResolvedValue({
+      items: [{
+        ...RUN,
+        status: 'QUEUED',
+        started_at: null,
+        completed_at: null,
+      }],
+      pagination: { limit: 25, has_more: false },
+    })
+
+    renderHistory()
+
+    expect(await screen.findByText('Not started')).toBeInTheDocument()
+    expect(screen.queryByText(/\d+(?:s|m|h).*elapsed$/)).not.toBeInTheDocument()
+  })
+
+  it('does not display queue wait for a terminal run that never started', async () => {
+    mockedScenariosApi.listRuns.mockResolvedValue({
+      items: [{
+        ...RUN,
+        status: 'CANCELLED',
+        started_at: null,
+      }],
+      pagination: { limit: 25, has_more: false },
+    })
+
+    renderHistory()
+
+    expect(await screen.findByText('Execution time unavailable')).toBeInTheDocument()
+    expect(screen.queryByText(/\d+(?:s|m|h).*elapsed$/)).not.toBeInTheDocument()
+  })
+
   it('isolates option-loading failures from the primary history request', async () => {
     mockedScenariosApi.listCatalog.mockRejectedValueOnce(new Error('catalog unavailable'))
     mockedScenariosApi.listRuns.mockResolvedValue({
diff --git a/frontend/src/components/History/ScenarioHistory.tsx b/frontend/src/components/History/ScenarioHistory.tsx
index 55c3af498e..130c8998ad 100644
--- a/frontend/src/components/History/ScenarioHistory.tsx
+++ b/frontend/src/components/History/ScenarioHistory.tsx
@@ -27,6 +27,8 @@ import {
   ScriptRegular,
 } from '@fluentui/react-icons'
 
+import ScenarioQueue from '@/components/Scenarios/ScenarioQueue'
+import { useScenarioQueue } from '@/hooks/useScenarioQueue'
 import { labelsApi, scenariosApi } from '@/services/api'
 import { toApiError } from '@/services/errors'
 import type { ScenarioRunListItem, ScenarioRunState } from '@/types'
@@ -91,6 +93,7 @@ export default function ScenarioHistory({
   onNavigate,
 }: ScenarioHistoryProps) {
   const styles = useScenarioHistoryStyles()
+  const queue = useScenarioQueue()
   const [runs, setRuns] = useState<ScenarioRunListItem[]>([])
   const [loading, setLoading] = useState(true)
   const [error, setError] = useState<string | null>(null)
@@ -295,6 +298,15 @@ export default function ScenarioHistory({
         )}
       </header>
 
+      <div className={styles.queue}>
+        <ScenarioQueue
+          snapshot={queue.snapshot}
+          loading={queue.loading}
+          stale={queue.stale}
+          error={queue.error}
+        />
+      </div>
+
       <div className={styles.content}>
         {displayLoading ? (
           <div className={styles.emptyState}><Spinner label="Loading scenario history..." /></div>
@@ -465,7 +477,12 @@ function formatTimestamp(value: string): string {
 }
 
 function formatElapsed(run: ScenarioRunListItem): string {
-  const start = Date.parse(run.created_at)
+  if (!run.started_at) {
+    return run.status === 'CREATED' || run.status === 'QUEUED'
+      ? 'Not started'
+      : 'Execution time unavailable'
+  }
+  const start = Date.parse(run.started_at)
   const end = run.completed_at ? Date.parse(run.completed_at) : Date.now()
   const seconds = Math.max(0, Math.floor((end - start) / 1000))
   if (seconds < 60) return `${seconds}s elapsed`
diff --git a/frontend/src/components/Scenarios/ScenarioQueue.styles.ts b/frontend/src/components/Scenarios/ScenarioQueue.styles.ts
new file mode 100644
index 0000000000..c5d614dc45
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScenarioQueue.styles.ts
@@ -0,0 +1,76 @@
+import { makeStyles, tokens } from '@fluentui/react-components'
+
+import { MINIMUM_TOUCH_TARGET_SIZE, NARROW_VIEWPORT_QUERY } from '@/styles/touchTargets'
+
+export const useScenarioQueueStyles = makeStyles({
+  root: {
+    display: 'flex',
+    flexDirection: 'column',
+    gap: tokens.spacingVerticalM,
+    padding: tokens.spacingVerticalL,
+    border: `1px solid ${tokens.colorNeutralStroke2}`,
+    borderRadius: tokens.borderRadiusLarge,
+    backgroundColor: tokens.colorNeutralBackground1,
+  },
+  heading: {
+    display: 'flex',
+    alignItems: 'baseline',
+    justifyContent: 'space-between',
+    flexWrap: 'wrap',
+    gap: tokens.spacingHorizontalM,
+  },
+  hint: {
+    color: tokens.colorNeutralForeground3,
+  },
+  list: {
+    display: 'flex',
+    flexDirection: 'column',
+    gap: tokens.spacingVerticalXS,
+    margin: 0,
+    padding: 0,
+    listStyleType: 'none',
+  },
+  entry: {
+    display: 'grid',
+    gridTemplateColumns: 'auto minmax(0, 1fr) auto',
+    alignItems: 'center',
+    gap: tokens.spacingHorizontalM,
+    padding: `${tokens.spacingVerticalXS} ${tokens.spacingHorizontalS}`,
+    borderTop: `1px solid ${tokens.colorNeutralStroke2}`,
+    [NARROW_VIEWPORT_QUERY]: {
+      gridTemplateColumns: 'auto minmax(0, 1fr)',
+    },
+  },
+  link: {
+    display: 'flex',
+    flexDirection: 'column',
+    justifyContent: 'center',
+    minHeight: MINIMUM_TOUCH_TARGET_SIZE,
+    minWidth: 0,
+    color: tokens.colorBrandForegroundLink,
+    textDecorationLine: 'none',
+    ':hover': {
+      textDecorationLine: 'underline',
+    },
+    ':focus-visible': {
+      outline: `2px solid ${tokens.colorStrokeFocus2}`,
+      outlineOffset: '2px',
+    },
+  },
+  runId: {
+    overflow: 'hidden',
+    textOverflow: 'ellipsis',
+    whiteSpace: 'nowrap',
+    color: tokens.colorNeutralForeground3,
+  },
+  timestamp: {
+    color: tokens.colorNeutralForeground3,
+    whiteSpace: 'nowrap',
+    [NARROW_VIEWPORT_QUERY]: {
+      gridColumn: '2',
+    },
+  },
+  empty: {
+    color: tokens.colorNeutralForeground3,
+  },
+})
diff --git a/frontend/src/components/Scenarios/ScenarioQueue.test.tsx b/frontend/src/components/Scenarios/ScenarioQueue.test.tsx
new file mode 100644
index 0000000000..24cfc5fd0c
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScenarioQueue.test.tsx
@@ -0,0 +1,138 @@
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+
+import type { ScenarioQueueSnapshot } from '@/types'
+
+import ScenarioQueue from './ScenarioQueue'
+
+const SNAPSHOT: ScenarioQueueSnapshot = {
+  revision: 3,
+  snapshot_at: '2026-01-01T00:00:03Z',
+  active: {
+    scenario_result_id: 'run-active',
+    scenario_name: 'ActiveScenario',
+    scenario_registry_name: 'active.scenario',
+    state: 'IN_PROGRESS',
+    created_at: '2026-01-01T00:00:00Z',
+    enqueued_at: '2026-01-01T00:00:00Z',
+    started_at: '2026-01-01T00:00:01Z',
+  },
+  queued: [{
+    scenario_result_id: 'run-waiting',
+    scenario_name: 'WaitingScenario',
+    scenario_registry_name: 'waiting.scenario',
+    state: 'QUEUED',
+    position: 1,
+    created_at: '2026-01-01T00:00:02Z',
+    enqueued_at: '2026-01-01T00:00:02Z',
+  }],
+}
+
+interface RenderQueueOptions {
+  readonly currentScenarioResultId?: string
+  readonly loading?: boolean
+  readonly stale?: boolean
+  readonly error?: string | null
+}
+
+function renderQueue(
+  snapshot: ScenarioQueueSnapshot | null,
+  {
+    currentScenarioResultId,
+    loading = false,
+    stale = false,
+    error = null,
+  }: RenderQueueOptions = {},
+) {
+  return render(
+    <FluentProvider theme={webLightTheme}>
+      <ScenarioQueue
+        snapshot={snapshot}
+        loading={loading}
+        stale={stale}
+        error={error}
+        currentScenarioResultId={currentScenarioResultId}
+      />
+    </FluentProvider>,
+  )
+}
+
+describe('ScenarioQueue', () => {
+  it('renders active and FIFO queued entries as native deep links', () => {
+    renderQueue(SNAPSHOT, { currentScenarioResultId: 'run-waiting' })
+
+    const activeLink = screen.getByRole('link', { name: /active\.scenario/i })
+    const waitingLink = screen.getByRole('link', { name: /waiting\.scenario/i })
+    expect(activeLink).toHaveAttribute('href', '/scenario-history/run-active')
+    expect(waitingLink).toHaveAttribute('href', '/scenario-history/run-waiting')
+    expect(waitingLink).toHaveAttribute('aria-current', 'page')
+    expect(screen.getByText('Active')).toBeInTheDocument()
+    expect(screen.getByText('Position 1')).toBeInTheDocument()
+  })
+
+  it('renders a concise empty state', () => {
+    renderQueue({ revision: 0, snapshot_at: '2026-01-01T00:00:00Z', active: null, queued: [] })
+
+    expect(screen.getByText('No active or queued scenarios.')).toBeInTheDocument()
+  })
+
+  it('keeps queue links keyboard reachable', async () => {
+    const user = userEvent.setup()
+    renderQueue(SNAPSHOT)
+
+    await user.tab()
+
+    expect(screen.getByRole('link', { name: /active\.scenario/i })).toHaveFocus()
+  })
+
+  it('renders initial loading and error states without an empty-state flash', () => {
+    const { rerender } = renderQueue(null, { loading: true })
+
+    expect(screen.getByText('Loading scenario queue...')).toBeInTheDocument()
+    expect(screen.queryByText('No active or queued scenarios.')).not.toBeInTheDocument()
+
+    rerender(
+      <FluentProvider theme={webLightTheme}>
+        <ScenarioQueue
+          snapshot={null}
+          loading={false}
+          stale={false}
+          error="Queue unavailable."
+        />
+      </FluentProvider>,
+    )
+    expect(screen.getByText('Queue unavailable.')).toBeInTheDocument()
+  })
+
+  it('keeps the last known queue visible when polling becomes stale', () => {
+    renderQueue(SNAPSHOT, { stale: true, error: 'Temporary failure.' })
+
+    expect(screen.getByText(
+      'Queue updates paused. Showing the last known order. Temporary failure.',
+    )).toBeInTheDocument()
+    expect(screen.getByRole('link', { name: /active\.scenario/i })).toBeInTheDocument()
+  })
+
+  it('falls back to scenario names, unknown positions, and enqueue time', () => {
+    renderQueue({
+      revision: 4,
+      snapshot_at: '2026-01-01T00:00:03Z',
+      active: {
+        ...SNAPSHOT.active!,
+        scenario_registry_name: '',
+        started_at: null,
+      },
+      queued: [{
+        ...SNAPSHOT.queued[0],
+        scenario_registry_name: '',
+        position: null,
+      }],
+    })
+
+    expect(screen.getByRole('link', { name: /ActiveScenario/i })).toBeInTheDocument()
+    expect(screen.getByRole('link', { name: /WaitingScenario/i })).toBeInTheDocument()
+    expect(screen.getByText('Position —')).toBeInTheDocument()
+    expect(screen.getAllByText(/^Queued /)).toHaveLength(2)
+  })
+})
diff --git a/frontend/src/components/Scenarios/ScenarioQueue.tsx b/frontend/src/components/Scenarios/ScenarioQueue.tsx
new file mode 100644
index 0000000000..ba122e37b1
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScenarioQueue.tsx
@@ -0,0 +1,94 @@
+import { Badge, MessageBar, MessageBarBody, Spinner, Text } from '@fluentui/react-components'
+
+import type { ScenarioQueueEntry, ScenarioQueueSnapshot } from '@/types'
+
+import { useScenarioQueueStyles } from './ScenarioQueue.styles'
+
+interface ScenarioQueueProps {
+  readonly snapshot: ScenarioQueueSnapshot | null
+  readonly loading: boolean
+  readonly stale: boolean
+  readonly error: string | null
+  readonly currentScenarioResultId?: string
+}
+
+export default function ScenarioQueue({
+  snapshot,
+  loading,
+  stale,
+  error,
+  currentScenarioResultId,
+}: ScenarioQueueProps) {
+  const styles = useScenarioQueueStyles()
+  const entries = snapshot
+    ? [
+        ...(snapshot.active ? [snapshot.active] : []),
+        ...snapshot.queued,
+      ]
+    : []
+
+  return (
+    <section className={styles.root} aria-labelledby="scenario-queue-heading" data-testid="scenario-queue">
+      <div className={styles.heading}>
+        <Text as="h2" id="scenario-queue-heading" size={500} weight="semibold">Scenario queue</Text>
+        <Text className={styles.hint}>One scenario executes at a time; waiting runs start FIFO.</Text>
+      </div>
+      {stale && error && (
+        <MessageBar intent="warning">
+          <MessageBarBody>Queue updates paused. Showing the last known order. {error}</MessageBarBody>
+        </MessageBar>
+      )}
+      {loading && !snapshot ? (
+        <Spinner size="tiny" label="Loading scenario queue..." />
+      ) : error && !snapshot ? (
+        <MessageBar intent="error"><MessageBarBody>{error}</MessageBarBody></MessageBar>
+      ) : entries.length === 0 ? (
+        <Text className={styles.empty}>No active or queued scenarios.</Text>
+      ) : (
+        <ol className={styles.list} aria-label="Scenario queue order">
+          {entries.map((entry) => (
+            <ScenarioQueueItem
+              key={entry.scenario_result_id}
+              entry={entry}
+              current={entry.scenario_result_id === currentScenarioResultId}
+            />
+          ))}
+        </ol>
+      )}
+    </section>
+  )
+}
+
+interface ScenarioQueueItemProps {
+  readonly entry: ScenarioQueueEntry
+  readonly current: boolean
+}
+
+function ScenarioQueueItem({ entry, current }: ScenarioQueueItemProps) {
+  const styles = useScenarioQueueStyles()
+  const active = entry.state === 'IN_PROGRESS'
+  const label = active ? 'Active' : `Position ${entry.position ?? '—'}`
+  return (
+    <li className={styles.entry}>
+      <Badge appearance="tint" color={active ? 'brand' : 'informative'}>{label}</Badge>
+      <a
+        href={`/scenario-history/${encodeURIComponent(entry.scenario_result_id)}`}
+        className={styles.link}
+        aria-current={current ? 'page' : undefined}
+      >
+        <Text weight="semibold">{entry.scenario_registry_name || entry.scenario_name}</Text>
+        <Text size={200} className={styles.runId}>{entry.scenario_result_id}</Text>
+      </a>
+      <Text size={200} className={styles.timestamp}>
+        {active && entry.started_at ? `Started ${formatTimestamp(entry.started_at)}` : `Queued ${formatTimestamp(entry.enqueued_at)}`}
+      </Text>
+    </li>
+  )
+}
+
+function formatTimestamp(timestamp: string): string {
+  return new Date(timestamp).toLocaleTimeString(undefined, {
+    hour: '2-digit',
+    minute: '2-digit',
+  })
+}
diff --git a/frontend/src/components/Scenarios/ScenarioRunPage.styles.ts b/frontend/src/components/Scenarios/ScenarioRunPage.styles.ts
index 4620bffa77..e0cbbbe5e7 100644
--- a/frontend/src/components/Scenarios/ScenarioRunPage.styles.ts
+++ b/frontend/src/components/Scenarios/ScenarioRunPage.styles.ts
@@ -83,6 +83,9 @@ export const useScenarioRunPageStyles = makeStyles({
   touchTarget: {
     ...mobileTouchTarget,
   },
+  cancelButton: {
+    minHeight: MINIMUM_TOUCH_TARGET_SIZE,
+  },
   wideButton: {
     [NARROW_VIEWPORT_QUERY]: {
       flexGrow: 1,
diff --git a/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx b/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx
index 3d34013d48..6e41b8f8dd 100644
--- a/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx
@@ -10,6 +10,7 @@ import {
 } from 'react-router'
 
 import { useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
+import { useScenarioQueue } from '@/hooks/useScenarioQueue'
 import { scenariosApi } from '@/services/api'
 import type {
   ScenarioProgressResult,
@@ -26,6 +27,10 @@ jest.mock('@/hooks/useScenarioRunProgress', () => ({
   useScenarioRunProgress: jest.fn(),
 }))
 
+jest.mock('@/hooks/useScenarioQueue', () => ({
+  useScenarioQueue: jest.fn(),
+}))
+
 jest.mock('@/services/api', () => ({
   scenariosApi: {
     cancelRun: jest.fn(),
@@ -33,6 +38,7 @@ jest.mock('@/services/api', () => ({
 }))
 
 const mockUseScenarioRunProgress = useScenarioRunProgress as jest.Mock
+const mockUseScenarioQueue = useScenarioQueue as jest.Mock
 const mockCancelRun = scenariosApi.cancelRun as jest.Mock
 const mockRetry = jest.fn()
 const mockApplyRunSummary = jest.fn()
@@ -122,6 +128,13 @@ function renderPage(path = `/scenario-history/${SCENARIO_RESULT_ID}`) {
 describe('ScenarioRunPage', () => {
   beforeEach(() => {
     jest.clearAllMocks()
+    mockUseScenarioQueue.mockReturnValue({
+      snapshot: { revision: 0, snapshot_at: '2026-01-01T00:00:00Z', active: null, queued: [] },
+      loading: false,
+      stale: false,
+      error: null,
+      retry: jest.fn(),
+    })
     mockHookState(makeState())
   })
 
@@ -196,7 +209,7 @@ describe('ScenarioRunPage', () => {
     expect(screen.getByText(/showing the last successfully loaded progress/i)).toBeInTheDocument()
   })
 
-  it('cancels after confirmation and immediately applies the returned terminal state', async () => {
+  it('cancels a queued run after confirmation and immediately applies the terminal state', async () => {
     const user = userEvent.setup()
     const cancelledRun = {
       scenario_result_id: 'run-1',
@@ -217,10 +230,21 @@ describe('ScenarioRunPage', () => {
       labels: {},
     }
     mockCancelRun.mockResolvedValueOnce(cancelledRun)
+    mockHookState(makeState({
+      run: {
+        ...makeState().run!,
+        status: 'QUEUED',
+        queue_position: 1,
+        active_scenario_result_id: 'active-run',
+      },
+      results: [],
+      activeAtomicGroupIds: [],
+    }))
 
     renderPage()
     await user.click(screen.getByRole('button', { name: 'Cancel run' }))
     const dialog = screen.getByRole('dialog', { name: 'Cancel this scenario run?' })
+    expect(within(dialog).getByText(/removed from the queue and will never execute/i)).toBeInTheDocument()
     await user.click(within(dialog).getByRole('button', { name: 'Cancel run' }))
 
     await waitFor(() => expect(mockApplyRunSummary).toHaveBeenCalledWith(cancelledRun))
@@ -352,6 +376,7 @@ describe('ScenarioRunPage', () => {
       loadStatus: 'not-found',
       error: 'Run not found',
     })
+
     const notFound = renderPage()
     expect(screen.getByRole('heading', { name: 'Scenario run not found' })).toBeInTheDocument()
     expect(screen.getByRole('button', { name: 'Retry' })).toBeInTheDocument()
@@ -367,6 +392,47 @@ describe('ScenarioRunPage', () => {
     expect(screen.getByText('Backend unavailable')).toBeInTheDocument()
   })
 
+  it('renders queued position without progress percentage or ETA', () => {
+    mockHookState(makeState({
+      run: {
+        ...makeState().run!,
+        status: 'QUEUED',
+        queue_position: 2,
+        active_scenario_result_id: 'active-run',
+      },
+      results: [],
+      activeAtomicGroupIds: [],
+    }))
+
+    renderPage()
+
+    expect(screen.getByTestId('run-state-badge')).toHaveTextContent('Queued')
+    expect(screen.getByTestId('queued-run-progress')).toHaveTextContent('Position 2')
+    expect(screen.getByText(/waiting for active run active-run/i)).toBeInTheDocument()
+    expect(screen.queryByRole('progressbar')).not.toBeInTheDocument()
+    expect(screen.getByText('Available after start')).toBeInTheDocument()
+  })
+
+  it('shows structured overload roles, counts, and non-adaptive retry guidance', () => {
+    mockHookState(makeState({
+      overloadSummaries: [{
+        component_role: 'adversarial_chat',
+        count: 3,
+        rate_limit_count: 2,
+        server_error_count: 1,
+        status_codes: [429, 503],
+        latest_timestamp: '2026-01-01T00:00:06Z',
+      }],
+    }))
+
+    renderPage()
+
+    const warning = screen.getByTestId('scenario-overload-warning')
+    expect(warning).toHaveTextContent('Adversarial chat')
+    expect(warning).toHaveTextContent('3 × HTTP 429/503')
+    expect(warning).toHaveTextContent(/without adaptive throttling/i)
+  })
+
   it('decodes route IDs and does not offer cancellation for terminal runs', () => {
     mockHookState(makeState({
       run: {
diff --git a/frontend/src/components/Scenarios/ScenarioRunPage.tsx b/frontend/src/components/Scenarios/ScenarioRunPage.tsx
index fa21c5dee4..27fe5c2b49 100644
--- a/frontend/src/components/Scenarios/ScenarioRunPage.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunPage.tsx
@@ -36,6 +36,7 @@ import {
 import { Link, useLocation, useNavigate, useParams } from 'react-router'
 
 import { useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
+import { useScenarioQueue } from '@/hooks/useScenarioQueue'
 import { scenariosApi } from '@/services/api'
 import { toApiError } from '@/services/errors'
 import type {
@@ -57,6 +58,7 @@ import {
 } from '@/utils/scenarioRunProgress'
 
 import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+import ScenarioQueue from './ScenarioQueue'
 
 const CLOCK_REFRESH_INTERVAL_MS = 1_000
 const OBJECTIVE_PREVIEW_LENGTH = 96
@@ -92,6 +94,7 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
   const location = useLocation()
   const navigate = useNavigate()
   const { state, retry, applyRunSummary } = useScenarioRunProgress(scenarioResultId)
+  const queue = useScenarioQueue()
   const [nowMilliseconds, setNowMilliseconds] = useState(() => Date.now())
   const [cancelDialogOpen, setCancelDialogOpen] = useState(false)
   const [cancelling, setCancelling] = useState(false)
@@ -227,10 +230,13 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
   }
 
   const run = state.run
-  const canCancel = run.status === 'CREATED' || run.status === 'IN_PROGRESS'
+  const queued = run.status === 'QUEUED'
+  const canCancel = run.status === 'CREATED' || queued || run.status === 'IN_PROGRESS'
   const elapsed = getElapsedMilliseconds(run, nowMilliseconds)
   const eta = getEtaMilliseconds(state, nowMilliseconds)
-  const progressText = overall.planned === null
+  const progressText = queued
+    ? `Queued${run.queue_position ? ` · Position ${run.queue_position}` : ''}`
+    : overall.planned === null
     ? `${overall.completed} known completed units; planned total unavailable`
     : `${overall.completed} of ${overall.planned} executable units completed`
 
@@ -267,7 +273,7 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
             <div className={styles.headerActions}>
               <Button
                 appearance="secondary"
-                className={mergeClasses(styles.touchTarget, styles.wideButton)}
+                className={mergeClasses(styles.touchTarget, styles.cancelButton, styles.wideButton)}
                 icon={<StopRegular />}
                 onClick={() => {
                   setCancelError(null)
@@ -306,6 +312,12 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
               <Text weight="semibold">{run.pyrit_version}</Text>
             </div>
           )}
+          {queued && (
+            <div className={styles.metadataItem}>
+              <Text size={200} className={styles.metadataLabel}>Waiting position</Text>
+              <Text weight="semibold">{run.queue_position ?? 'Updating'}</Text>
+            </div>
+          )}
         </div>
 
         <section className={styles.section} aria-labelledby="run-configuration-heading">
@@ -352,6 +364,23 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
           </MessageBar>
         )}
 
+        <ScenarioQueue
+          snapshot={queue.snapshot}
+          loading={queue.loading}
+          stale={queue.stale}
+          error={queue.error}
+          currentScenarioResultId={scenarioResultId}
+        />
+
+        {(state.overloadSummaries?.length ?? 0) > 0 && (
+          <MessageBar intent="warning" data-testid="scenario-overload-warning">
+            <MessageBarBody>
+              Recent target overload detected: {formatOverloadSummaries(state.overloadSummaries ?? [])}.
+              {' '}PyRIT is retrying these requests without adaptive throttling; concurrency is not automatically reduced yet.
+            </MessageBarBody>
+          </MessageBar>
+        )}
+
         {run.status === 'FAILED' && (
           <MessageBar intent="error">
             <MessageBarBody>
@@ -375,6 +404,28 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
             </Text>
             <Text className={styles.sectionHint}>{progressText}</Text>
           </div>
+          {queued ? (
+            <div className={styles.progressSurface} data-testid="queued-run-progress">
+              <div className={styles.progressPrimary}>
+                <Text size={500} weight="semibold">
+                  Queued{run.queue_position ? ` · Position ${run.queue_position}` : ''}
+                </Text>
+                <Text className={styles.sectionHint}>
+                  {run.active_scenario_result_id
+                    ? `Waiting for active run ${run.active_scenario_result_id} to finish.`
+                    : 'Waiting for the scheduler to start this run.'}
+                </Text>
+              </div>
+              <div className={styles.metric}>
+                <Text size={200} className={styles.metricLabel}>Execution progress</Text>
+                <Text weight="semibold">Not started</Text>
+              </div>
+              <div className={styles.metric}>
+                <Text size={200} className={styles.metricLabel}>Estimated remaining</Text>
+                <Text weight="semibold">Available after start</Text>
+              </div>
+            </div>
+          ) : (
           <div className={styles.progressSurface}>
             <div className={styles.progressPrimary}>
               <div className={styles.progressText}>
@@ -404,8 +455,9 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
               </Text>
             </div>
           </div>
+          )}
           <span className={styles.liveStatus} aria-live="polite">
-            {isTerminalRunState(run.status) ? `Run ${formatRunState(run.status)}` : ''}
+            {queued ? progressText : isTerminalRunState(run.status) ? `Run ${formatRunState(run.status)}` : ''}
           </span>
         </section>
 
@@ -645,7 +697,9 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
             <DialogTitle>Cancel this scenario run?</DialogTitle>
             <DialogContent className={styles.dialogContent}>
               <Text>
-                In-flight work will be stopped. Attempts already persisted will remain available in this dashboard.
+                {queued
+                  ? 'This run will be removed from the queue and will never execute.'
+                  : 'In-flight work will be stopped. Attempts already persisted will remain available in this dashboard.'}
               </Text>
               {cancelError && (
                 <MessageBar intent="error">
@@ -657,6 +711,7 @@ function ScenarioRunPageContent({ scenarioResultId }: ScenarioRunPageContentProp
               <Button disabled={cancelling} onClick={() => setCancelDialogOpen(false)}>Keep running</Button>
               <Button
                 appearance="primary"
+                className={styles.cancelButton}
                 disabled={cancelling}
                 icon={<StopRegular />}
                 onClick={() => void handleCancel()}
@@ -851,12 +906,26 @@ function objectivePreview(objective: string | null, fallbackId: string): string
   if (!objective) {
     return `Objective unavailable (${fallbackId})`
   }
+
   if (objective.length <= OBJECTIVE_PREVIEW_LENGTH) {
     return objective
   }
   return `${objective.slice(0, OBJECTIVE_PREVIEW_LENGTH - 1)}…`
 }
 
+function formatOverloadSummaries(
+  summaries: import('@/types').ScenarioOverloadSummary[],
+): string {
+  return summaries.map((summary) => {
+    const codes = summary.status_codes.join('/')
+    return `${formatRole(summary.component_role)} (${summary.count} × HTTP ${codes}, latest ${formatTimestamp(summary.latest_timestamp)})`
+  }).join('; ')
+}
+
+function formatRole(role: string): string {
+  return role.replace(/_/g, ' ').replace(/^\w/, (letter: string) => letter.toUpperCase())
+}
+
 function shouldIgnoreAttemptRowClick(event: React.MouseEvent<HTMLTableRowElement>): boolean {
   return event.button !== 0
     || hasActivationModifier(event)
diff --git a/frontend/src/hooks/useScenarioQueue.test.tsx b/frontend/src/hooks/useScenarioQueue.test.tsx
new file mode 100644
index 0000000000..f4d4ce3fae
--- /dev/null
+++ b/frontend/src/hooks/useScenarioQueue.test.tsx
@@ -0,0 +1,148 @@
+import { act, renderHook, waitFor } from '@testing-library/react'
+
+import { scenariosApi } from '@/services/api'
+import type { ScenarioQueueSnapshot } from '@/types'
+
+import { SCENARIO_QUEUE_POLL_INTERVAL_MS, useScenarioQueue } from './useScenarioQueue'
+
+jest.mock('@/services/api', () => ({
+  scenariosApi: {
+    getQueue: jest.fn(),
+  },
+}))
+
+const mockGetQueue = scenariosApi.getQueue as jest.Mock
+const FIRST_SNAPSHOT: ScenarioQueueSnapshot = {
+  revision: 1,
+  snapshot_at: '2026-01-01T00:00:00Z',
+  active: null,
+  queued: [],
+}
+const SECOND_SNAPSHOT: ScenarioQueueSnapshot = {
+  ...FIRST_SNAPSHOT,
+  revision: 2,
+  queued: [{
+    scenario_result_id: 'run-2',
+    scenario_name: 'QueuedScenario',
+    scenario_registry_name: 'queued.scenario',
+    state: 'QUEUED',
+    position: 1,
+    created_at: '2026-01-01T00:00:01Z',
+    enqueued_at: '2026-01-01T00:00:01Z',
+  }],
+}
+
+describe('useScenarioQueue', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.useFakeTimers()
+  })
+
+  afterEach(() => {
+    jest.useRealTimers()
+  })
+
+  it('polls and applies position changes', async () => {
+    mockGetQueue
+      .mockResolvedValueOnce(FIRST_SNAPSHOT)
+      .mockResolvedValueOnce(SECOND_SNAPSHOT)
+
+    const { result, unmount } = renderHook(() => useScenarioQueue())
+    await waitFor(() => expect(result.current.snapshot?.revision).toBe(1))
+    await act(async () => {
+      await jest.advanceTimersByTimeAsync(SCENARIO_QUEUE_POLL_INTERVAL_MS)
+    })
+
+    expect(result.current.snapshot?.queued[0].position).toBe(1)
+    unmount()
+  })
+
+  it('keeps the last good snapshot across a transient failure', async () => {
+    mockGetQueue
+      .mockResolvedValueOnce(FIRST_SNAPSHOT)
+      .mockRejectedValueOnce(new Error('temporary queue failure'))
+
+    const { result, unmount } = renderHook(() => useScenarioQueue())
+    await waitFor(() => expect(result.current.snapshot?.revision).toBe(1))
+    await act(async () => {
+      await jest.advanceTimersByTimeAsync(SCENARIO_QUEUE_POLL_INTERVAL_MS)
+    })
+
+    expect(result.current.snapshot).toEqual(FIRST_SNAPSHOT)
+    expect(result.current.stale).toBe(true)
+    expect(result.current.error).toBe('temporary queue failure')
+    unmount()
+  })
+
+  it('retries an initial failure without presenting stale queue data', async () => {
+    mockGetQueue
+      .mockRejectedValueOnce(new Error('queue unavailable'))
+      .mockResolvedValueOnce(FIRST_SNAPSHOT)
+
+    const { result, unmount } = renderHook(() => useScenarioQueue())
+    await waitFor(() => expect(result.current.error).toBe('queue unavailable'))
+
+    expect(result.current.snapshot).toBeNull()
+    expect(result.current.loading).toBe(false)
+    expect(result.current.stale).toBe(false)
+
+    act(() => result.current.retry())
+    expect(result.current.loading).toBe(true)
+    expect(result.current.error).toBeNull()
+    await waitFor(() => expect(result.current.snapshot).toEqual(FIRST_SNAPSHOT))
+    unmount()
+  })
+
+  it('keeps existing queue data visible while a manual retry is pending', async () => {
+    let resolveRetry: ((snapshot: ScenarioQueueSnapshot) => void) | undefined
+    mockGetQueue
+      .mockResolvedValueOnce(FIRST_SNAPSHOT)
+      .mockImplementationOnce(() => new Promise((resolve) => {
+        resolveRetry = resolve
+      }))
+
+    const { result, unmount } = renderHook(() => useScenarioQueue())
+    await waitFor(() => expect(result.current.snapshot).toEqual(FIRST_SNAPSHOT))
+
+    act(() => result.current.retry())
+
+    expect(result.current.loading).toBe(false)
+    expect(result.current.snapshot).toEqual(FIRST_SNAPSHOT)
+    await act(async () => {
+      resolveRetry?.(SECOND_SNAPSHOT)
+    })
+    unmount()
+  })
+
+  it('ignores a request that resolves after unmount', async () => {
+    let resolveRequest: ((snapshot: ScenarioQueueSnapshot) => void) | undefined
+    mockGetQueue.mockImplementationOnce(() => new Promise((resolve) => {
+      resolveRequest = resolve
+    }))
+
+    const { result, unmount } = renderHook(() => useScenarioQueue())
+    await waitFor(() => expect(mockGetQueue).toHaveBeenCalledTimes(1))
+    unmount()
+
+    await act(async () => {
+      resolveRequest?.(FIRST_SNAPSHOT)
+    })
+    expect(result.current.snapshot).toBeNull()
+  })
+
+  it('ignores a request that rejects after unmount', async () => {
+    let rejectRequest: ((reason?: unknown) => void) | undefined
+    mockGetQueue.mockImplementationOnce(() => new Promise((_resolve, reject) => {
+      rejectRequest = reject
+    }))
+
+    const { result, unmount } = renderHook(() => useScenarioQueue())
+    await waitFor(() => expect(mockGetQueue).toHaveBeenCalledTimes(1))
+    unmount()
+
+    await act(async () => {
+      rejectRequest?.(new Error('late failure'))
+    })
+    expect(result.current.error).toBeNull()
+  })
+})
diff --git a/frontend/src/hooks/useScenarioQueue.ts b/frontend/src/hooks/useScenarioQueue.ts
new file mode 100644
index 0000000000..3586ec3128
--- /dev/null
+++ b/frontend/src/hooks/useScenarioQueue.ts
@@ -0,0 +1,82 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import { scenariosApi } from '@/services/api'
+import { toApiError } from '@/services/errors'
+import type { ScenarioQueueSnapshot } from '@/types'
+
+export const SCENARIO_QUEUE_POLL_INTERVAL_MS = 2_500
+
+export interface ScenarioQueueState {
+  readonly snapshot: ScenarioQueueSnapshot | null
+  readonly loading: boolean
+  readonly stale: boolean
+  readonly error: string | null
+}
+
+export interface UseScenarioQueueResult extends ScenarioQueueState {
+  readonly retry: () => void
+}
+
+export function useScenarioQueue(): UseScenarioQueueResult {
+  const [state, setState] = useState<ScenarioQueueState>({
+    snapshot: null,
+    loading: true,
+    stale: false,
+    error: null,
+  })
+  const [retryEpoch, setRetryEpoch] = useState(0)
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+  useEffect(() => {
+    let active = true
+    const controller = new AbortController()
+
+    const fetchQueueAsync = async (): Promise<void> => {
+      if (!active) {
+        return
+      }
+      try {
+        const snapshot = await scenariosApi.getQueue(controller.signal)
+        if (!active) {
+          return
+        }
+        setState({ snapshot, loading: false, stale: false, error: null })
+      } catch (error: unknown) {
+        if (!active || controller.signal.aborted) {
+          return
+        }
+        const message = toApiError(error).detail
+        setState((previous) => ({
+          ...previous,
+          loading: false,
+          stale: previous.snapshot !== null,
+          error: message,
+        }))
+      } finally {
+        if (active) {
+          timerRef.current = setTimeout(() => {
+            timerRef.current = null
+            void fetchQueueAsync()
+          }, SCENARIO_QUEUE_POLL_INTERVAL_MS)
+        }
+      }
+    }
+
+    void fetchQueueAsync()
+    return () => {
+      active = false
+      controller.abort()
+      if (timerRef.current !== null) {
+        clearTimeout(timerRef.current)
+        timerRef.current = null
+      }
+    }
+  }, [retryEpoch])
+
+  const retry = useCallback((): void => {
+    setState((previous) => ({ ...previous, loading: previous.snapshot === null, stale: false, error: null }))
+    setRetryEpoch((epoch) => epoch + 1)
+  }, [])
+
+  return { ...state, retry }
+}
diff --git a/frontend/src/services/api.ts b/frontend/src/services/api.ts
index e8d92de2c4..6cf66da4c6 100644
--- a/frontend/src/services/api.ts
+++ b/frontend/src/services/api.ts
@@ -38,6 +38,7 @@ import type {
   ScenarioRunSummary,
   ScenarioRunListResponse,
   ScenarioRunProgress,
+  ScenarioQueueSnapshot,
   ScenarioRunState,
   ConfigurationFileContent,
   EnvironmentFileContent,
@@ -486,6 +487,11 @@ export const scenariosApi = {
     return response.data
   },
 
+  getQueue: async (signal?: AbortSignal): Promise<ScenarioQueueSnapshot> => {
+    const response = await apiClient.get('/scenarios/runs/queue', { signal })
+    return response.data
+  },
+
   cancelRun: async (scenarioResultId: string, signal?: AbortSignal): Promise<ScenarioRunSummary> => {
     const response = await apiClient.post(
       `/scenarios/runs/${encodeURIComponent(scenarioResultId)}/cancel`,
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 0bfba6837a..da3a6e668e 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -670,6 +670,7 @@ export interface RetryEvent {
   component_role: string
   component_name?: string | null
   endpoint?: string | null
+  status_code?: number | null
   elapsed_seconds: number
 }
 
@@ -681,6 +682,15 @@ export interface AttackRetrySummary {
 
 export type ScenarioRunState = 'CREATED' | 'QUEUED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'CANCELLED'
 
+export interface ScenarioOverloadSummary {
+  component_role: string
+  count: number
+  rate_limit_count: number
+  server_error_count: number
+  status_codes: number[]
+  latest_timestamp: string
+}
+
 export interface ScenarioRunSummary {
   scenario_result_id: string
   scenario_name: string
@@ -688,6 +698,7 @@ export interface ScenarioRunSummary {
   scenario_version: number
   status: ScenarioRunState
   created_at: string
+  started_at?: string | null
   updated_at: string
   error?: string | null
   error_type?: string | null
@@ -708,6 +719,9 @@ export interface ScenarioRunSummary {
   successful_attacks?: number
   error_attacks?: number
   attack_details_available?: boolean
+  queue_position?: number | null
+  active_scenario_result_id?: string | null
+  overload_summaries?: ScenarioOverloadSummary[]
 }
 
 export interface ScenarioTargetSummary {
@@ -724,6 +738,7 @@ export interface ScenarioRunListItem {
   scenario_version: number
   status: ScenarioRunState
   created_at: string
+  started_at?: string | null
   updated_at: string
   error?: string | null
   error_type?: string | null
@@ -757,6 +772,7 @@ export interface ScenarioProgressHeader {
   scenario_version: number
   status: ScenarioRunState
   created_at: string
+  started_at?: string | null
   completed_at?: string | null
   pyrit_version?: string | null
   target?: ScenarioTargetSummary | null
@@ -764,6 +780,27 @@ export interface ScenarioProgressHeader {
   datasets_used?: string[]
   scenario_parameters?: Record<string, unknown>
   labels?: Record<string, string>
+  queue_position?: number | null
+  active_scenario_result_id?: string | null
+  overload_summaries?: ScenarioOverloadSummary[]
+}
+
+export interface ScenarioQueueEntry {
+  scenario_result_id: string
+  scenario_name: string
+  scenario_registry_name: string
+  created_at: string
+  enqueued_at: string
+  started_at?: string | null
+  state: ScenarioRunState
+  position?: number | null
+}
+
+export interface ScenarioQueueSnapshot {
+  revision: number
+  snapshot_at: string
+  active?: ScenarioQueueEntry | null
+  queued: ScenarioQueueEntry[]
 }
 
 /** One persisted attack attempt in ascending progress order. */
diff --git a/frontend/src/utils/scenarioRunProgress.test.ts b/frontend/src/utils/scenarioRunProgress.test.ts
index 414b35bd17..b9ac1fbacd 100644
--- a/frontend/src/utils/scenarioRunProgress.test.ts
+++ b/frontend/src/utils/scenarioRunProgress.test.ts
@@ -72,6 +72,7 @@ function makePage(overrides: Partial<ScenarioRunProgress> = {}): ScenarioRunProg
       scenario_version: 1,
       status: 'IN_PROGRESS',
       created_at: '2026-01-01T00:00:00Z',
+      started_at: '2026-01-01T00:00:00Z',
     },
     plan: PLAN,
     reset: false,
@@ -119,6 +120,63 @@ describe('scenarioRunProgressReducer', () => {
     expect(reset.cursor).toBe('cursor-2')
   })
 
+  it('does not double-count overload evidence during cancellation catch-up', () => {
+    const overload = {
+      component_role: 'objective_target',
+      count: 1,
+      rate_limit_count: 1,
+      server_error_count: 0,
+      status_codes: [429],
+      latest_timestamp: '2026-01-01T00:01:00Z',
+    }
+    const first = scenarioRunProgressReducer(INITIAL_SCENARIO_RUN_PROGRESS_STATE, {
+      type: 'apply-page',
+      page: makePage({ run: { ...makePage().run, overload_summaries: [overload] } }),
+      fresh: true,
+    })
+    const cancelled = scenarioRunProgressReducer(first, {
+      type: 'apply-run-summary',
+      run: {
+        scenario_result_id: 'run-1',
+        scenario_name: 'TestScenario',
+        scenario_registry_name: 'test.scenario',
+        scenario_version: 1,
+        status: 'CANCELLED',
+        created_at: '2026-01-01T00:00:00Z',
+        started_at: '2026-01-01T00:00:30Z',
+        updated_at: '2026-01-01T00:02:00Z',
+        techniques_used: [],
+        total_attacks: 2,
+        completed_attacks: 2,
+        objective_achieved_rate: 0,
+        failed_attacks: [],
+        attack_retries: [],
+        total_retries: 2,
+        labels: {},
+        overload_summaries: [{ ...overload, count: 2, rate_limit_count: 2 }],
+      },
+    })
+    const caughtUp = scenarioRunProgressReducer(cancelled, {
+      type: 'apply-page',
+      page: makePage({
+        plan: null,
+        run: {
+          ...makePage().run,
+          status: 'CANCELLED',
+          overload_summaries: [{
+            ...overload,
+            latest_timestamp: '2026-01-01T00:02:00Z',
+          }],
+        },
+      }),
+      fresh: false,
+    })
+
+    expect(cancelled.overloadSummaries[0].count).toBe(1)
+    expect(cancelled.run?.started_at).toBe('2026-01-01T00:00:30Z')
+    expect(caughtUp.overloadSummaries[0].count).toBe(2)
+  })
+
   it('retains last-good data and marks it stale after a transient failure', () => {
     const first = readyState([makeResult('attempt-1', 'group-a', 'seed-1', 'success', 1)])
     const failed = scenarioRunProgressReducer(first, {
@@ -240,16 +298,45 @@ describe('scenario run progress calculations', () => {
     ])
   })
 
-  it('uses now for active elapsed time and completed_at for terminal elapsed time', () => {
-    const active = makePage().run
-    expect(getElapsedMilliseconds(active, Date.parse('2026-01-01T00:05:00Z'))).toBe(300_000)
+  it('uses execution start for elapsed time and excludes a long queue delay from active ETA', () => {
+    const active = {
+      ...makePage().run,
+      created_at: '2026-01-01T00:00:00Z',
+      started_at: '2026-01-01T01:00:00Z',
+    }
+    expect(getElapsedMilliseconds(active, Date.parse('2026-01-01T01:05:00Z'))).toBe(300_000)
 
     const terminal = {
       ...active,
       status: 'COMPLETED' as const,
-      completed_at: '2026-01-01T00:03:00Z',
+      completed_at: '2026-01-01T01:03:00Z',
     }
-    expect(getElapsedMilliseconds(terminal, Date.parse('2026-01-01T00:05:00Z'))).toBe(180_000)
+    expect(getElapsedMilliseconds(terminal, Date.parse('2026-01-01T01:05:00Z'))).toBe(180_000)
+
+    const state = readyState([makeResult('a-1', 'group-a', 'seed-1', 'success', 1)])
+    state.run = active
+    expect(getEtaMilliseconds(state, Date.parse('2026-01-01T01:02:00Z'))).toBe(240_000)
+  })
+
+  it('does not count queue wait as elapsed time or fabricate a queued ETA', () => {
+    const queued = {
+      ...makePage().run,
+      status: 'QUEUED' as const,
+      created_at: '2026-01-01T00:00:00Z',
+      started_at: null,
+    }
+    const now = Date.parse('2026-01-01T01:00:00Z')
+
+    expect(getElapsedMilliseconds(queued, now)).toBe(0)
+
+    const state = readyState([makeResult('a-1', 'group-a', 'seed-1', 'success', 1)])
+    state.run = queued
+    expect(getEtaMilliseconds(state, now)).toBeNull()
+
+    expect(getElapsedMilliseconds(
+      { ...queued, status: 'CANCELLED', completed_at: '2026-01-01T00:30:00Z' },
+      now,
+    )).toBe(0)
   })
 
   it('calculates ETA from observed wall-clock completion rate and hides unsafe estimates', () => {
diff --git a/frontend/src/utils/scenarioRunProgress.ts b/frontend/src/utils/scenarioRunProgress.ts
index bac819f9c6..c442dc6cd9 100644
--- a/frontend/src/utils/scenarioRunProgress.ts
+++ b/frontend/src/utils/scenarioRunProgress.ts
@@ -1,6 +1,7 @@
 import type {
   ScenarioProgressHeader,
   ScenarioProgressResult,
+  ScenarioOverloadSummary,
   ScenarioRunPlan,
   ScenarioRunPlanAtomicGroup,
   ScenarioRunState,
@@ -21,6 +22,7 @@ export interface ScenarioRunProgressState {
   readonly hasMore: boolean
   readonly error: string | null
   readonly stale: boolean
+  readonly overloadSummaries: ScenarioOverloadSummary[]
 }
 
 export type ScenarioRunProgressAction =
@@ -90,6 +92,7 @@ export const INITIAL_SCENARIO_RUN_PROGRESS_STATE: ScenarioRunProgressState = {
   hasMore: false,
   error: null,
   stale: false,
+  overloadSummaries: [],
 }
 
 export function isTerminalRunState(status: ScenarioRunState): boolean {
@@ -131,6 +134,7 @@ export function scenarioRunProgressReducer(
         scenario_version: action.run.scenario_version,
         status: action.run.status,
         created_at: action.run.created_at,
+        started_at: action.run.started_at,
         completed_at: action.run.completed_at,
         pyrit_version: action.run.pyrit_version,
         target: action.run.target,
@@ -138,11 +142,15 @@ export function scenarioRunProgressReducer(
         datasets_used: action.run.datasets_used ?? [],
         scenario_parameters: action.run.scenario_parameters ?? {},
         labels: action.run.labels,
+        queue_position: action.run.queue_position,
+        active_scenario_result_id: action.run.active_scenario_result_id,
+        overload_summaries: action.run.overload_summaries ?? [],
       },
       activeAtomicGroupIds: [],
       error: null,
       stale: false,
       hasMore: false,
+      overloadSummaries: state.overloadSummaries,
     }
   }
 
@@ -158,6 +166,10 @@ export function scenarioRunProgressReducer(
   }
 
   const results = [...resultsById.values()].sort(compareAttempts)
+  const overloadSummaries = mergeOverloadSummaries(
+    shouldReset ? [] : state.overloadSummaries,
+    action.page.run.overload_summaries ?? [],
+  )
   return {
     loadStatus: 'ready',
     run: action.page.run,
@@ -169,9 +181,33 @@ export function scenarioRunProgressReducer(
     hasMore: action.page.has_more,
     error: null,
     stale: false,
+    overloadSummaries,
   }
 }
 
+function mergeOverloadSummaries(
+  existing: ScenarioOverloadSummary[],
+  incoming: ScenarioOverloadSummary[],
+): ScenarioOverloadSummary[] {
+  const byRole = new Map(existing.map((summary) => [summary.component_role, summary]))
+  for (const summary of incoming) {
+    const previous = byRole.get(summary.component_role)
+    byRole.set(summary.component_role, previous ? {
+      component_role: summary.component_role,
+      count: previous.count + summary.count,
+      rate_limit_count: previous.rate_limit_count + summary.rate_limit_count,
+      server_error_count: previous.server_error_count + summary.server_error_count,
+      status_codes: [...new Set([...previous.status_codes, ...summary.status_codes])].sort((left, right) => left - right),
+      latest_timestamp: Date.parse(summary.latest_timestamp) >= Date.parse(previous.latest_timestamp)
+        ? summary.latest_timestamp
+        : previous.latest_timestamp,
+    } : summary)
+  }
+  return [...byRole.values()].sort(
+    (left, right) => Date.parse(right.latest_timestamp) - Date.parse(left.latest_timestamp),
+  )
+}
+
 export function getOverallProgress(state: ScenarioRunProgressState): OverallProgress {
   const units = buildUnitAttempts(state.results)
   const completed = [...units.values()].filter((unit) => unit.latestNonError !== null).length
@@ -198,15 +234,18 @@ export function getElapsedMilliseconds(
   run: ScenarioProgressHeader,
   nowMilliseconds: number,
 ): number {
-  const created = Date.parse(run.created_at)
+  if (!run.started_at) {
+    return 0
+  }
+  const started = Date.parse(run.started_at)
   const terminalEnd = run.completed_at ? Date.parse(run.completed_at) : Number.NaN
   const end = isTerminalRunState(run.status) && Number.isFinite(terminalEnd)
     ? terminalEnd
     : nowMilliseconds
-  if (!Number.isFinite(created) || !Number.isFinite(end)) {
+  if (!Number.isFinite(started) || !Number.isFinite(end)) {
     return 0
   }
-  return Math.max(0, end - created)
+  return Math.max(0, end - started)
 }
 
 export function getEtaMilliseconds(
diff --git a/pyrit/backend/main.py b/pyrit/backend/main.py
index 68721a731e..169f0b2b4a 100644
--- a/pyrit/backend/main.py
+++ b/pyrit/backend/main.py
@@ -40,6 +40,7 @@
 from pyrit.backend.services.configuration_file_service import ConfigurationFileService
 from pyrit.backend.services.environment_file_service import EnvironmentFileService
 from pyrit.backend.services.initializer_service import get_initializer_service
+from pyrit.backend.services.scenario_run_service import get_scenario_run_service
 from pyrit.common.path import CONFIGURATION_DIRECTORY_PATH
 from pyrit.registry import InitializerRegistry
 from pyrit.setup.configuration_loader import ConfigurationLoader
@@ -107,12 +108,18 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     if config.allow_custom_initializers:
         logger.warning("Custom initializer registration is ENABLED (allow_custom_initializers: true).")
 
+    scenario_run_service = get_scenario_run_service()
+    await scenario_run_service.reconcile_interrupted_runs_async()
+
     # Mount the bundled frontend (or print a dev/missing-frontend notice).
     # Done here rather than at module load so test imports of `pyrit.backend.main`
     # don't emit noise and don't perform filesystem side effects.
     setup_frontend()
 
-    yield
+    try:
+        yield
+    finally:
+        await scenario_run_service.shutdown_async()
 
 
 app = FastAPI(
diff --git a/pyrit/backend/routes/scenarios.py b/pyrit/backend/routes/scenarios.py
index 34e1372dbc..d96b3bd466 100644
--- a/pyrit/backend/routes/scenarios.py
+++ b/pyrit/backend/routes/scenarios.py
@@ -22,15 +22,14 @@
 )
 from pyrit.backend.services.scenario_run_service import get_scenario_run_service
 from pyrit.backend.services.scenario_service import get_scenario_service
-from pyrit.models import ScenarioResult, ScenarioRunState
-from pyrit.models.catalog.scenario import (
+from pyrit.models import ScenarioQueueSnapshot, ScenarioResult, ScenarioRunProgress, ScenarioRunState
+from pyrit.models.catalog import (
     RegisteredScenario,
     RunScenarioRequest,
     ScenarioRunSizeEstimate,
     ScenarioRunSizeEstimateRequest,
     ScenarioRunSummary,
 )
-from pyrit.models.scenario_progress import ScenarioRunProgress
 
 router = APIRouter(prefix="/scenarios", tags=["scenarios"])
 
@@ -233,6 +232,20 @@ async def list_scenario_runs(  # pyrit-async-suffix-exempt
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from None
 
 
+@router.get(
+    "/runs/queue",
+    response_model=ScenarioQueueSnapshot,
+)
+async def get_scenario_run_queue() -> ScenarioQueueSnapshot:  # pyrit-async-suffix-exempt
+    """
+    Get the active scenario and ordered FIFO waiting queue.
+
+    Returns:
+        ScenarioQueueSnapshot: Current in-process scheduler state.
+    """
+    return get_scenario_run_service().get_queue_snapshot()
+
+
 @router.get(
     "/runs/{scenario_result_id}",
     response_model=ScenarioRunSummary,
@@ -256,6 +269,8 @@ async def get_scenario_run(scenario_result_id: str) -> ScenarioRunSummary:  # py
         service.get_run_from_storage,
         scenario_result_id=scenario_result_id,
         active_error=active_snapshot.error,
+        queue_position=active_snapshot.queue_position,
+        active_scenario_result_id=active_snapshot.active_scenario_result_id,
     )
     if run is None:
         raise HTTPException(
@@ -294,6 +309,8 @@ async def get_scenario_run_progress(  # pyrit-async-suffix-exempt
             since=since,
             limit=limit,
             active_group_ids=active_snapshot.active_group_ids,
+            queue_position=active_snapshot.queue_position,
+            active_scenario_result_id=active_snapshot.active_scenario_result_id,
         )
     except ValueError as exc:
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from None
diff --git a/pyrit/backend/services/scenario_run_service.py b/pyrit/backend/services/scenario_run_service.py
index eca4d095af..872370d77a 100644
--- a/pyrit/backend/services/scenario_run_service.py
+++ b/pyrit/backend/services/scenario_run_service.py
@@ -16,19 +16,25 @@
 import json
 import logging
 import uuid
+from collections import OrderedDict, deque
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import Any
 from urllib.parse import urlsplit, urlunsplit
 
+try:
+    from builtins import ExceptionGroup  # type: ignore[attr-defined,ty:unresolved-import]
+except ImportError:  # pragma: no cover - exercised only on 3.10
+    from exceptiongroup import ExceptionGroup  # type: ignore[no-redef,ty:unresolved-import]
+
 from pydantic import TypeAdapter, ValidationError
 
 from pyrit.backend.models.common import PaginationInfo, filter_sensitive_fields
 from pyrit.backend.models.scenarios import ScenarioRunListResponse
 from pyrit.backend.services.scenario_configuration_resolver import ScenarioConfigurationResolver
 from pyrit.common.utils import to_sha256
-from pyrit.memory import AttackResultKeysetCursor, CentralMemory
+from pyrit.memory import AttackResultKeysetCursor, CentralMemory, SQLiteMemory
 from pyrit.memory.memory_interface import (
     ScenarioHistoryKeysetCursor,
     ScenarioHistoryRunRecord,
@@ -36,6 +42,7 @@
 )
 from pyrit.models import (
     SCENARIO_RUN_PLAN_METADATA_KEY,
+    SCENARIO_RUN_STARTED_AT_METADATA_KEY,
     AtomicAttackIdentifier,
     AttackOutcome,
     AttackResult,
@@ -44,6 +51,8 @@
     ScenarioIdentifier,
     ScenarioProgressHeader,
     ScenarioProgressResult,
+    ScenarioQueueEntry,
+    ScenarioQueueSnapshot,
     ScenarioResult,
     ScenarioRunPlan,
     ScenarioRunPlanAtomicGroup,
@@ -58,6 +67,7 @@
     AttackRetrySummary,
     RunScenarioRequest,
     ScenarioRunListItem,
+    ScenarioOverloadSummary,
     ScenarioRunSummary,
     ScenarioTargetSummary,
 )
@@ -66,7 +76,21 @@
 
 logger = logging.getLogger(__name__)
 
-_DEFAULT_MAX_CONCURRENT_RUNS = 3
+_DEFAULT_MAX_CONCURRENT_RUNS = 1
+_MAX_OVERLOAD_EVENTS = 500
+_MAX_OVERLOAD_ROLES = 16
+_MAX_TERMINAL_ERRORS = 100
+_SCHEDULER_RETRY_INITIAL_SECONDS = 0.05
+_SCHEDULER_RETRY_MAX_SECONDS = 1.0
+_SCHEDULER_METADATA_KEY = "scheduler_managed_by"
+_SCHEDULER_METADATA_VALUE = "ScenarioRunService.process_local_fifo"
+_INTERRUPTED_ERROR_TYPE = "ScenarioInterruptedError"
+_RESTART_INTERRUPTION_REASON = (
+    "The backend process restarted before this scenario run completed; "
+    "its executable scenario objects could not be recovered safely."
+)
+_SHUTDOWN_INTERRUPTION_REASON = "The backend process shut down before this scenario run completed."
+_USER_CANCELLATION_REASON = "Run was cancelled by user"
 
 _SAFE_SCENARIO_PARAMETER_NAMES = frozenset(
     {
@@ -82,6 +106,7 @@
 )
 _HISTORY_ATOMIC_GROUPS_ADAPTER = TypeAdapter(list[ScenarioRunPlanAtomicGroup])
 _HISTORY_SEED_ID_MAP_ADAPTER = TypeAdapter(list[dict[str, str]])
+_STARTED_AT_ADAPTER = TypeAdapter(datetime)
 
 
 @dataclass
@@ -92,6 +117,15 @@ class _ActiveTask:
     task: asyncio.Task[None] | None = None
     scenario: Scenario | None = None
     error: str | None = None
+    scenario_name: str = ""
+    scenario_registry_name: str = ""
+    created_at: datetime | None = None
+    enqueued_at: datetime | None = None
+    started_at: datetime | None = None
+    cancellation_state: ScenarioRunState = ScenarioRunState.CANCELLED
+    cancellation_reason: str = _USER_CANCELLATION_REASON
+    cancellation_error_type: str = "CancelledError"
+    retain_error_on_terminalization: bool = False
 
 
 @dataclass(frozen=True, slots=True)
@@ -100,6 +134,8 @@ class _ActiveRunSnapshot:
 
     error: str | None = None
     active_group_ids: tuple[str, ...] = ()
+    queue_position: int | None = None
+    active_scenario_result_id: str | None = None
 
 
 @dataclass(frozen=True, slots=True)
@@ -188,46 +224,51 @@ class ScenarioRunService:
     Service for managing scenario run lifecycle.
 
     Uses CentralMemory (database) as the source of truth for run state.
-    Keeps an in-memory dict only for active asyncio tasks (cancellation support).
+    Keeps executable objects in a process-local single-active FIFO scheduler.
     """
 
     def __init__(self, *, max_concurrent_runs: int = _DEFAULT_MAX_CONCURRENT_RUNS) -> None:
-        """Initialize the scenario run service."""
-        self._max_concurrent_runs = max_concurrent_runs
+        """
+        Initialize the scenario run service.
+
+        ``max_concurrent_runs`` remains accepted for configuration compatibility;
+        scenario execution is always serialized to one active run.
+        """
+        if max_concurrent_runs < 1:
+            raise ValueError("max_concurrent_runs must be at least 1.")
         self._memory = CentralMemory.get_memory_instance()
         self._active_tasks: dict[str, _ActiveTask] = {}
-        self._run_semaphore = asyncio.Semaphore(max_concurrent_runs)
         self._configuration_resolver = ScenarioConfigurationResolver()
+        self._terminal_errors: OrderedDict[str, str] = OrderedDict()
+        self._active_scenario_result_id: str | None = None
+        self._queued_runs: deque[_ActiveTask] = deque()
+        self._handoff_retry_tasks: set[asyncio.Task[None]] = set()
+        self._scheduler_lock = asyncio.Lock()
+        self._launch_lock = asyncio.Lock()
+        self._queue_revision = 0
+        self._stopping = False
 
     async def start_run_async(self, *, request: RunScenarioRequest) -> ScenarioRunSummary:
         """
-        Start a new scenario run as a background task.
+        Initialize and schedule a scenario run.
 
         Performs all validation and initialization eagerly (initializers, target
         resolution, technique validation, scenario.initialize_async) so errors are
-        returned immediately. On success, spawns a background task that only
-        executes scenario.run_async.
+        returned immediately. On success, starts execution when idle or appends
+        the initialized run to the FIFO waiting queue.
 
         Args:
             request: The run request with scenario name, target, and options.
 
         Returns:
-            ScenarioRunResponse with run_id and RUNNING status.
+            ScenarioRunSummary with a stable ID and current active or queued state.
 
         Raises:
-            ValueError: If scenario, target, initializer, or technique cannot be found,
-                or concurrent limit exceeded.
+            ValueError: If scenario, target, initializer, or technique cannot be found.
         """
-        if self._run_semaphore.locked():
-            raise ValueError(
-                f"Maximum concurrent runs ({self._max_concurrent_runs}) reached. "
-                "Wait for an existing run to complete or cancel one."
-            )
-
-        await self._run_semaphore.acquire()
-
-        # Perform all initialization eagerly — errors propagate to caller
-        try:
+        async with self._launch_lock:
+            if self._stopping:
+                raise RuntimeError("Scenario run scheduling is stopping.")
             scenario_class = self._configuration_resolver.resolve_scenario_class(scenario_name=request.scenario_name)
             await self._run_initializers_async(request=request)
             objective_target = self._configuration_resolver.resolve_target(target_name=request.target_name)
@@ -245,24 +286,33 @@ async def start_run_async(self, *, request: RunScenarioRequest) -> ScenarioRunSu
                 memory_labels=request.labels,
             )
             scenario = await self._initialize_scenario_async(request=request, init_kwargs=init_kwargs)
-        except Exception:
-            self._run_semaphore.release()
-            raise
-
-        # scenario_result_id is set during initialize_async
-        scenario_result_id = scenario._scenario_result_id
-        if scenario_result_id is None:
-            raise ValueError("Scenario did not produce a scenario_result_id during initialization.")
-
-        # Track active task
-        active = _ActiveTask(scenario_result_id=scenario_result_id, scenario=scenario)
-        self._active_tasks[scenario_result_id] = active
-
-        # Spawn background task (only runs scenario.run_async)
-        task = asyncio.create_task(self._execute_run_async(scenario_result_id=scenario_result_id))
-        active.task = task
+            scenario_result_id = scenario._scenario_result_id
+            if scenario_result_id is None:
+                raise ValueError("Scenario did not produce a scenario_result_id during initialization.")
+            persisted = await asyncio.to_thread(
+                self._memory.get_scenario_results,
+                scenario_result_ids=[scenario_result_id],
+            )
+            if not persisted:
+                raise RuntimeError(f"Scenario run {scenario_result_id} was not persisted during initialization.")
+            scheduled = _ActiveTask(
+                scenario_result_id=scenario_result_id,
+                scenario=scenario,
+                scenario_name=persisted[0].scenario_name,
+                scenario_registry_name=request.scenario_name,
+                created_at=persisted[0].creation_time,
+                enqueued_at=datetime.now(timezone.utc),
+            )
+            await self._enqueue_run_async(scheduled=scheduled)
 
-        response = self.get_run(scenario_result_id=scenario_result_id)
+        snapshot = self.snapshot_active_run(scenario_result_id=scenario_result_id)
+        response = await asyncio.to_thread(
+            self.get_run_from_storage,
+            scenario_result_id=scenario_result_id,
+            active_error=snapshot.error,
+            queue_position=snapshot.queue_position,
+            active_scenario_result_id=snapshot.active_scenario_result_id,
+        )
         if response is None:
             raise RuntimeError(f"Scenario run {scenario_result_id} was not found in the database after initialization.")
         return response
@@ -278,13 +328,20 @@ def get_run(self, *, scenario_result_id: str) -> ScenarioRunSummary | None:
             ScenarioRunSummary if found, None otherwise.
         """
         snapshot = self.snapshot_active_run(scenario_result_id=scenario_result_id)
-        return self.get_run_from_storage(scenario_result_id=scenario_result_id, active_error=snapshot.error)
+        return self.get_run_from_storage(
+            scenario_result_id=scenario_result_id,
+            active_error=snapshot.error,
+            queue_position=snapshot.queue_position,
+            active_scenario_result_id=snapshot.active_scenario_result_id,
+        )
 
     def get_run_from_storage(
         self,
         *,
         scenario_result_id: str,
         active_error: str | None,
+        queue_position: int | None = None,
+        active_scenario_result_id: str | None = None,
     ) -> ScenarioRunSummary | None:
         """
         Build a run summary using database state plus an event-loop snapshot.
@@ -292,11 +349,18 @@ def get_run_from_storage(
         Args:
             scenario_result_id: The scenario result ID.
             active_error: Error copied from the active asyncio task, if any.
+            queue_position: Current 1-based waiting position, if queued.
+            active_scenario_result_id: Currently executing scenario result ID.
 
         Returns:
             ScenarioRunSummary | None: The run summary when found.
         """
-        return self._build_response(scenario_result_id=scenario_result_id, active_error=active_error)
+        return self._build_response(
+            scenario_result_id=scenario_result_id,
+            active_error=active_error,
+            queue_position=queue_position,
+            active_scenario_result_id=active_scenario_result_id,
+        )
 
     def list_runs(
         self,
@@ -423,33 +487,387 @@ async def cancel_run_async(self, *, scenario_result_id: str) -> ScenarioRunSumma
         Raises:
             ValueError: If the run is already in a terminal state or not active.
         """
-        # Verify run exists in DB
-        results = self._memory.get_scenario_results(scenario_result_ids=[scenario_result_id])
+        results = await asyncio.to_thread(
+            self._memory.get_scenario_results,
+            scenario_result_ids=[scenario_result_id],
+        )
         if not results:
             return None
 
-        scenario_result = results[0]
-        db_status = scenario_result.scenario_run_state
-
-        if db_status in (ScenarioRunState.COMPLETED, ScenarioRunState.FAILED, ScenarioRunState.CANCELLED):
+        db_status = results[0].scenario_run_state
+        if self._is_terminal_state(db_status):
             raise ValueError(f"Cannot cancel run in '{db_status}' state.")
 
-        # Cancel the asyncio task if active and wait for it to finish
-        active = self._active_tasks.get(scenario_result_id)
-        if active is not None and active.task is not None and not active.task.done():
-            active.task.cancel()
-            with contextlib.suppress(asyncio.CancelledError, asyncio.TimeoutError):
-                await asyncio.wait_for(active.task, timeout=5.0)
+        task: asyncio.Task[None] | None = None
+        async with self._scheduler_lock:
+            queued = next(
+                (run for run in self._queued_runs if run.scenario_result_id == scenario_result_id),
+                None,
+            )
+            if queued is not None:
+                await asyncio.to_thread(
+                    self._memory.update_scenario_run_state,
+                    scenario_result_id=scenario_result_id,
+                    scenario_run_state=ScenarioRunState.CANCELLED,
+                    error_message=_USER_CANCELLATION_REASON,
+                    error_type="CancelledError",
+                )
+                self._queued_runs.remove(queued)
+                self._queue_revision += 1
+            elif self._active_scenario_result_id == scenario_result_id:
+                active = self._active_tasks[scenario_result_id]
+                active.cancellation_state = ScenarioRunState.CANCELLED
+                active.cancellation_reason = _USER_CANCELLATION_REASON
+                active.cancellation_error_type = "CancelledError"
+                task = active.task
+            else:
+                latest = await asyncio.to_thread(
+                    self._memory.get_scenario_results,
+                    scenario_result_ids=[scenario_result_id],
+                )
+                if latest and self._is_terminal_state(latest[0].scenario_run_state):
+                    raise ValueError(f"Cannot cancel run in '{latest[0].scenario_run_state}' state.")
+                await asyncio.to_thread(
+                    self._memory.update_scenario_run_state,
+                    scenario_result_id=scenario_result_id,
+                    scenario_run_state=ScenarioRunState.CANCELLED,
+                    error_message=_USER_CANCELLATION_REASON,
+                    error_type="CancelledError",
+                )
 
-        # Persist cancelled state to DB
-        self._memory.update_scenario_run_state(
+        if task is not None and not task.done():
+            task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await task
+
+        snapshot = self.snapshot_active_run(scenario_result_id=scenario_result_id)
+        result = await asyncio.to_thread(
+            self.get_run_from_storage,
             scenario_result_id=scenario_result_id,
-            scenario_run_state=ScenarioRunState.CANCELLED,
-            error_message="Run was cancelled by user",
-            error_type="CancelledError",
+            active_error=snapshot.error,
+            queue_position=snapshot.queue_position,
+            active_scenario_result_id=snapshot.active_scenario_result_id,
+        )
+        if result is not None and result.status != ScenarioRunState.CANCELLED:
+            raise ValueError(f"Cannot cancel run in '{result.status}' state.")
+        return result
+
+    def get_queue_snapshot(self) -> ScenarioQueueSnapshot:
+        """
+        Return the current in-process FIFO scheduler state.
+
+        Returns:
+            ScenarioQueueSnapshot: Active run and ordered waiting runs.
+        """
+        snapshot_at = datetime.now(timezone.utc)
+        active = None
+        if self._active_scenario_result_id is not None:
+            active_run = self._active_tasks.get(self._active_scenario_result_id)
+            if active_run is not None:
+                active = self._build_queue_entry(run=active_run, state=ScenarioRunState.IN_PROGRESS)
+        queued = [
+            self._build_queue_entry(run=run, state=ScenarioRunState.QUEUED, position=position)
+            for position, run in enumerate(self._queued_runs, start=1)
+        ]
+        return ScenarioQueueSnapshot(
+            revision=self._queue_revision,
+            snapshot_at=snapshot_at,
+            active=active,
+            queued=queued,
+        )
+
+    async def reconcile_interrupted_runs_async(self) -> int:
+        """
+        Mark scheduler-managed local rows failed when executable objects were lost.
+
+        Shared and unknown memory backends are intentionally non-destructive because
+        another process may still own their runs. File-backed SQLite assumes one
+        scheduler process has exclusive ownership of that database file.
+
+        Returns:
+            int: Number of reconciled rows.
+        """
+        if not isinstance(self._memory, SQLiteMemory):
+            logger.info(
+                "Skipping interrupted Scenario run reconciliation for shared or unsupported %s memory.",
+                type(self._memory).__name__,
+            )
+            return 0
+
+        states = (ScenarioRunState.CREATED, ScenarioRunState.QUEUED, ScenarioRunState.IN_PROGRESS)
+        after_id = None
+        reconciled = 0
+        while True:
+            interrupted, has_more = await asyncio.to_thread(
+                self._memory.get_scenario_run_state_page,
+                states=states,
+                after_id=after_id,
+                limit=500,
+            )
+            for result in interrupted:
+                header = await asyncio.to_thread(
+                    self._memory.get_scenario_result_header,
+                    scenario_result_id=result.scenario_result_id,
+                )
+                if header is None or header.metadata.get(_SCHEDULER_METADATA_KEY) != _SCHEDULER_METADATA_VALUE:
+                    continue
+                await asyncio.to_thread(
+                    self._memory.update_scenario_run_state,
+                    scenario_result_id=result.scenario_result_id,
+                    scenario_run_state=ScenarioRunState.FAILED,
+                    error_message=_RESTART_INTERRUPTION_REASON,
+                    error_type=_INTERRUPTED_ERROR_TYPE,
+                )
+                reconciled += 1
+            if not has_more:
+                return reconciled
+            if not interrupted:
+                raise RuntimeError(
+                    "Scenario run state projection reported another page without returning a cursor row."
+                )
+            after_id = interrupted[-1].scenario_result_id
+
+    async def shutdown_async(self) -> None:
+        """Stop scheduling and terminalize active and queued runs for process shutdown."""
+        task: asyncio.Task[None] | None = None
+        retry_tasks: list[asyncio.Task[None]] = []
+        errors: list[Exception] = []
+        async with self._scheduler_lock:
+            self._stopping = True
+            retry_tasks = list(self._handoff_retry_tasks)
+            queued = list(self._queued_runs)
+            self._queued_runs.clear()
+            if queued:
+                self._queue_revision += 1
+            for run in queued:
+                try:
+                    await asyncio.to_thread(
+                        self._memory.update_scenario_run_state,
+                        scenario_result_id=run.scenario_result_id,
+                        scenario_run_state=ScenarioRunState.FAILED,
+                        error_message=_SHUTDOWN_INTERRUPTION_REASON,
+                        error_type=_INTERRUPTED_ERROR_TYPE,
+                    )
+                except Exception as exc:
+                    errors.append(exc)
+            if self._active_scenario_result_id is not None:
+                active = self._active_tasks[self._active_scenario_result_id]
+                active.cancellation_state = ScenarioRunState.FAILED
+                active.cancellation_reason = _SHUTDOWN_INTERRUPTION_REASON
+                active.cancellation_error_type = _INTERRUPTED_ERROR_TYPE
+                task = active.task
+                if task is None or task.done():
+                    try:
+                        await asyncio.to_thread(
+                            self._memory.update_scenario_run_state,
+                            scenario_result_id=active.scenario_result_id,
+                            scenario_run_state=ScenarioRunState.FAILED,
+                            error_message=_SHUTDOWN_INTERRUPTION_REASON,
+                            error_type=_INTERRUPTED_ERROR_TYPE,
+                        )
+                    except Exception as exc:
+                        errors.append(exc)
+                    self._active_scenario_result_id = None
+                    self._release_completed_task(scenario_result_id=active.scenario_result_id)
+                    self._queue_revision += 1
+        if task is not None and not task.done():
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            except Exception as exc:
+                errors.append(exc)
+        for retry_task in retry_tasks:
+            retry_task.cancel()
+        if retry_tasks:
+            await asyncio.gather(*retry_tasks, return_exceptions=True)
+        if errors:
+            raise ExceptionGroup("Failed to persist one or more scenario shutdown transitions.", errors)
+
+    async def _enqueue_run_async(self, *, scheduled: _ActiveTask) -> None:
+        """Atomically enqueue a persisted initialized run or start it immediately."""
+        async with self._scheduler_lock:
+            if self._stopping:
+                raise RuntimeError("Scenario run scheduling is stopping.")
+            scheduled_ids = {
+                *(run.scenario_result_id for run in self._queued_runs),
+                *self._active_tasks.keys(),
+            }
+            if scheduled.scenario_result_id in scheduled_ids:
+                raise ValueError(f"Scenario run '{scheduled.scenario_result_id}' is already scheduled.")
+            self._terminal_errors.pop(scheduled.scenario_result_id, None)
+            if self._active_scenario_result_id is None:
+                await self._start_scheduled_run_locked_async(scheduled=scheduled)
+                return
+            await asyncio.to_thread(
+                self._memory.update_scenario_run_state_and_metadata_fields,
+                scenario_result_id=scheduled.scenario_result_id,
+                scenario_run_state=ScenarioRunState.QUEUED,
+                metadata_fields={_SCHEDULER_METADATA_KEY: _SCHEDULER_METADATA_VALUE},
+            )
+            self._queued_runs.append(scheduled)
+            self._queue_revision += 1
+
+    async def _start_scheduled_run_locked_async(self, *, scheduled: _ActiveTask) -> None:
+        """Start one run while the scheduler lock guarantees exclusive ownership."""
+        scheduled.started_at = datetime.now(timezone.utc)
+        await asyncio.to_thread(
+            self._memory.update_scenario_run_state_and_metadata_fields,
+            scenario_result_id=scheduled.scenario_result_id,
+            scenario_run_state=ScenarioRunState.IN_PROGRESS,
+            metadata_fields={
+                _SCHEDULER_METADATA_KEY: _SCHEDULER_METADATA_VALUE,
+                SCENARIO_RUN_STARTED_AT_METADATA_KEY: scheduled.started_at.isoformat(),
+            },
+        )
+        self._active_scenario_result_id = scheduled.scenario_result_id
+        self._active_tasks[scheduled.scenario_result_id] = scheduled
+        scheduled.task = asyncio.create_task(self._execute_run_async(scenario_result_id=scheduled.scenario_result_id))
+        self._queue_revision += 1
+
+    async def _handoff_scheduler_async(self, *, scenario_result_id: str) -> None:
+        """Release one terminal active run and start the next valid queued run once."""
+        async with self._scheduler_lock:
+            if self._active_scenario_result_id != scenario_result_id:
+                return
+            if self._stopping:
+                self._active_scenario_result_id = None
+                self._release_completed_task(scenario_result_id=scenario_result_id)
+                self._queue_revision += 1
+                return
+            while self._queued_runs:
+                next_run = self._queued_runs[0]
+                persisted = await asyncio.to_thread(
+                    self._memory.get_scenario_results,
+                    scenario_result_ids=[next_run.scenario_result_id],
+                )
+                if not persisted or persisted[0].scenario_run_state != ScenarioRunState.QUEUED:
+                    self._queued_runs.popleft()
+                    self._queue_revision += 1
+                    continue
+                await self._start_scheduled_run_locked_async(scheduled=next_run)
+                self._queued_runs.popleft()
+                self._release_completed_task(scenario_result_id=scenario_result_id)
+                return
+            self._active_scenario_result_id = None
+            self._release_completed_task(scenario_result_id=scenario_result_id)
+            self._queue_revision += 1
+
+    def _release_completed_task(self, *, scenario_result_id: str) -> None:
+        """Release executable state while retaining bounded terminal error evidence."""
+        completed = self._active_tasks.pop(scenario_result_id, None)
+        if completed is None or completed.error is None:
+            return
+        self._terminal_errors[scenario_result_id] = completed.error
+        self._terminal_errors.move_to_end(scenario_result_id)
+        while len(self._terminal_errors) > _MAX_TERMINAL_ERRORS:
+            self._terminal_errors.popitem(last=False)
+
+    def _schedule_handoff_retry(self, *, scenario_result_id: str) -> None:
+        """Retry a failed terminal handoff without permitting another active run."""
+        retry_task = asyncio.create_task(self._retry_handoff_async(scenario_result_id=scenario_result_id))
+        self._handoff_retry_tasks.add(retry_task)
+        retry_task.add_done_callback(self._handoff_retry_tasks.discard)
+
+    def _schedule_terminalization_retry(self, *, active: _ActiveTask) -> None:
+        """Retry cancellation persistence before releasing the active slot."""
+        retry_task = asyncio.create_task(self._retry_terminalization_async(active=active))
+        self._handoff_retry_tasks.add(retry_task)
+        retry_task.add_done_callback(self._handoff_retry_tasks.discard)
+
+    async def _retry_handoff_async(self, *, scenario_result_id: str) -> None:
+        """Retry scheduler handoff with bounded exponential delay until it succeeds or shutdown begins."""
+        delay = _SCHEDULER_RETRY_INITIAL_SECONDS
+        while not self._stopping and self._active_scenario_result_id == scenario_result_id:
+            await asyncio.sleep(delay)
+            try:
+                await self._handoff_scheduler_async(scenario_result_id=scenario_result_id)
+            except Exception:
+                logger.exception("Scenario scheduler handoff retry failed for %s.", scenario_result_id)
+                delay = min(delay * 2, _SCHEDULER_RETRY_MAX_SECONDS)
+            else:
+                return
+
+    async def _retry_terminalization_async(self, *, active: _ActiveTask) -> None:
+        """Retry a failed cancellation transition, then perform the terminal handoff."""
+        delay = _SCHEDULER_RETRY_INITIAL_SECONDS
+        while not self._stopping and self._active_scenario_result_id == active.scenario_result_id:
+            await asyncio.sleep(delay)
+            try:
+                async with self._scheduler_lock:
+                    if self._stopping or self._active_scenario_result_id != active.scenario_result_id:
+                        return
+                    await asyncio.to_thread(
+                        self._memory.update_scenario_run_state,
+                        scenario_result_id=active.scenario_result_id,
+                        scenario_run_state=active.cancellation_state,
+                        error_message=active.cancellation_reason,
+                        error_type=active.cancellation_error_type,
+                    )
+                    if not active.retain_error_on_terminalization:
+                        active.error = None
+                await self._handoff_scheduler_async(scenario_result_id=active.scenario_result_id)
+            except Exception:
+                logger.exception(
+                    "Scenario terminal transition retry failed for %s.",
+                    active.scenario_result_id,
+                )
+                delay = min(delay * 2, _SCHEDULER_RETRY_MAX_SECONDS)
+            else:
+                return
+
+    async def _complete_handoff_async(self, *, scenario_result_id: str) -> None:
+        """Complete terminal handoff even if the execution task is cancelled while waiting for the scheduler lock."""
+        handoff_task = asyncio.create_task(self._handoff_scheduler_async(scenario_result_id=scenario_result_id))
+        self._handoff_retry_tasks.add(handoff_task)
+        handoff_task.add_done_callback(self._handoff_retry_tasks.discard)
+        try:
+            await asyncio.shield(handoff_task)
+        except asyncio.CancelledError:
+            try:
+                await handoff_task
+            except asyncio.CancelledError:
+                return
+            except Exception:
+                logger.exception("Scenario scheduler handoff failed for %s; retrying.", scenario_result_id)
+                if not self._stopping:
+                    self._schedule_handoff_retry(scenario_result_id=scenario_result_id)
+        except Exception:
+            logger.exception("Scenario scheduler handoff failed for %s; retrying.", scenario_result_id)
+            if not self._stopping:
+                self._schedule_handoff_retry(scenario_result_id=scenario_result_id)
+
+    @staticmethod
+    def _build_queue_entry(
+        *,
+        run: _ActiveTask,
+        state: ScenarioRunState,
+        position: int | None = None,
+    ) -> ScenarioQueueEntry:
+        """
+        Map event-loop scheduler state to the canonical queue DTO.
+
+        Returns:
+            ScenarioQueueEntry: Canonical active or queued entry.
+        """
+        if run.created_at is None or run.enqueued_at is None:
+            raise RuntimeError(f"Scenario run '{run.scenario_result_id}' has incomplete queue timestamps.")
+        return ScenarioQueueEntry(
+            scenario_result_id=run.scenario_result_id,
+            scenario_name=run.scenario_name,
+            scenario_registry_name=run.scenario_registry_name,
+            created_at=run.created_at,
+            enqueued_at=run.enqueued_at,
+            started_at=run.started_at,
+            state=state,
+            position=position,
         )
 
-        return self.get_run(scenario_result_id=scenario_result_id)
+    @staticmethod
+    def _is_terminal_state(state: ScenarioRunState) -> bool:
+        """Return whether a scenario state is terminal."""
+        return state in (ScenarioRunState.COMPLETED, ScenarioRunState.FAILED, ScenarioRunState.CANCELLED)
 
     async def _run_initializers_async(self, *, request: RunScenarioRequest) -> None:
         """
@@ -498,6 +916,7 @@ async def _initialize_scenario_async(self, *, request: RunScenarioRequest, init_
             request.scenario_name,
             scenario_params=request.scenario_params or {},
             scenario_result_id=request.scenario_result_id or None,
+            initial_metadata={_SCHEDULER_METADATA_KEY: _SCHEDULER_METADATA_VALUE},
             **init_kwargs,
         )
 
@@ -507,36 +926,68 @@ async def _execute_run_async(self, *, scenario_result_id: str) -> None:
 
         Only calls scenario.run_async on the already-initialized scenario.
 
-        Note: this method intentionally does NOT remove the entry from
-        ``_active_tasks`` on completion. The entry must stay so that
-        ``_build_response_from_db`` can read ``active.error`` when the
-        caller next polls the run status. Cleanup happens lazily there
-        once the error has been surfaced.
+        Terminal handoff releases executable objects. Bounded error evidence is
+        retained separately for later status polling.
 
         Args:
             scenario_result_id: The scenario result ID for this run.
         """
         active = self._active_tasks[scenario_result_id]
         assert active.scenario is not None
+        handoff_ready = True
 
         try:
             await active.scenario.run_async()
 
         except asyncio.CancelledError:
-            logger.info(f"Scenario run {scenario_result_id} was cancelled.")
+            try:
+                await asyncio.to_thread(
+                    self._memory.update_scenario_run_state,
+                    scenario_result_id=scenario_result_id,
+                    scenario_run_state=active.cancellation_state,
+                    error_message=active.cancellation_reason,
+                    error_type=active.cancellation_error_type,
+                )
+            except Exception as exc:
+                handoff_ready = False
+                active.error = str(exc)
+                if not self._stopping:
+                    self._schedule_terminalization_retry(active=active)
+                raise
+            logger.info("Scenario run %s stopped in state %s.", scenario_result_id, active.cancellation_state.value)
 
         except Exception as e:
             active.error = str(e)
+            active.cancellation_state = ScenarioRunState.FAILED
+            active.cancellation_reason = str(e)
+            active.cancellation_error_type = type(e).__name__
+            active.retain_error_on_terminalization = True
+            try:
+                await asyncio.to_thread(
+                    self._memory.update_scenario_run_state,
+                    scenario_result_id=scenario_result_id,
+                    scenario_run_state=ScenarioRunState.FAILED,
+                    error_message=str(e),
+                    error_type=type(e).__name__,
+                )
+            except Exception:
+                handoff_ready = False
+                if not self._stopping:
+                    self._schedule_terminalization_retry(active=active)
+                logger.exception("Failed to persist terminal state for scenario run %s.", scenario_result_id)
             logger.exception(f"Scenario run {scenario_result_id} failed: {e}")
 
         finally:
-            self._run_semaphore.release()
+            if handoff_ready:
+                await self._complete_handoff_async(scenario_result_id=scenario_result_id)
 
     def _build_response(
         self,
         *,
         scenario_result_id: str,
         active_error: str | None,
+        queue_position: int | None,
+        active_scenario_result_id: str | None,
     ) -> ScenarioRunSummary | None:
         """
         Build a ScenarioRunResponse by querying the database and merging active task state.
@@ -544,6 +995,8 @@ def _build_response(
         Args:
             scenario_result_id: The scenario result ID.
             active_error: Error copied from the active asyncio task, if any.
+            queue_position: Current 1-based waiting position, if queued.
+            active_scenario_result_id: Currently executing scenario result ID.
 
         Returns:
             ScenarioRunResponse if found in the database, None otherwise.
@@ -551,13 +1004,20 @@ def _build_response(
         results = self._memory.get_scenario_results(scenario_result_ids=[scenario_result_id])
         if not results:
             return None
-        return self._build_response_from_db(scenario_result=results[0], active_error=active_error)
+        return self._build_response_from_db(
+            scenario_result=results[0],
+            active_error=active_error,
+            queue_position=queue_position,
+            active_scenario_result_id=active_scenario_result_id,
+        )
 
     def _build_response_from_db(
         self,
         *,
         scenario_result: ScenarioResult,
         active_error: str | None = None,
+        queue_position: int | None = None,
+        active_scenario_result_id: str | None = None,
     ) -> ScenarioRunSummary:
         """
         Build a ScenarioRunResponse from a database ScenarioResult, merged with active task info.
@@ -565,6 +1025,8 @@ def _build_response_from_db(
         Args:
             scenario_result: A ScenarioResult retrieved from CentralMemory.
             active_error: Error copied from the active asyncio task, if any.
+            queue_position: Current 1-based waiting position, if queued.
+            active_scenario_result_id: Currently executing scenario result ID.
 
         Returns:
             The API response model.
@@ -625,7 +1087,8 @@ def _build_response_from_db(
         # a COMPLETED scenario can still hide errored objectives or rate-limit retries.
         failed_attacks: list[AttackErrorSummary] = []
         attack_retries: list[AttackRetrySummary] = []
-        total_retries = 0
+        overload_events: deque[Any] = deque(maxlen=_MAX_OVERLOAD_EVENTS)
+        inner_retries_by_unit: dict[_ResultUnitIdentity, int] = {}
         attempts_by_unit: dict[_ResultUnitIdentity, int] = {}
         for atomic_attack_name, results in scenario_result.attack_results.items():
             for attack_result in results:
@@ -637,10 +1100,11 @@ def _build_response_from_db(
                 attempts_by_unit[unit_identity] = attempts_by_unit.get(unit_identity, 0) + 1
                 retries = getattr(attack_result, "total_retries", 0)
                 if isinstance(retries, int):
-                    total_retries += retries
+                    inner_retries_by_unit[unit_identity] = inner_retries_by_unit.get(unit_identity, 0) + max(0, retries)
 
                 retry_events = getattr(attack_result, "retry_events", None)
                 if isinstance(retry_events, list) and retry_events:
+                    overload_events.extend(retry_events)
                     attack_retries.append(
                         AttackRetrySummary(
                             attack_result_id=str(attack_result.attack_result_id),
@@ -656,10 +1120,16 @@ def _build_response_from_db(
                             objective=attack_result.objective,
                             error_type=attack_result.error_type,
                             error_message=attack_result.error_message,
-                            total_retries=retries if isinstance(retries, int) else 0,
+                            total_retries=max(0, retries) if isinstance(retries, int) else 0,
                         )
                     )
-        total_retries += sum(max(0, attempt_count - 1) for attempt_count in attempts_by_unit.values())
+        total_retries = sum(
+            self._total_retry_work(
+                inner_retries=inner_retries_by_unit.get(unit_identity, 0),
+                attempt_count=attempt_count,
+            )
+            for unit_identity, attempt_count in attempts_by_unit.items()
+        )
 
         updated_at = scenario_result.creation_time
         if terminal and scenario_result.completion_time is not None:
@@ -672,6 +1142,7 @@ def _build_response_from_db(
             scenario_version=scenario_result.scenario_version,
             status=status,
             created_at=scenario_result.creation_time,
+            started_at=self._load_started_at(scenario_result=scenario_result),
             updated_at=updated_at,
             error=error,
             error_type=error_type,
@@ -695,6 +1166,9 @@ def _build_response_from_db(
             planned_total_available=plan is not None,
             successful_attacks=successful_attacks,
             error_attacks=len(failed_attacks),
+            queue_position=queue_position,
+            active_scenario_result_id=active_scenario_result_id,
+            overload_summaries=self._build_overload_summaries(retry_events=overload_events),
         )
 
     def _build_history_summary(
@@ -811,6 +1285,7 @@ def _build_history_summary(
             scenario_version=record.scenario_version,
             status=status,
             created_at=record.created_at,
+            started_at=record.started_at,
             updated_at=updated_at,
             error=record.error_message,
             error_type=record.error_type,
@@ -873,6 +1348,9 @@ def _merge_history_units(
             preferred = incoming if incoming_completed else existing
         else:
             preferred = incoming if incoming.latest_timestamp > existing.latest_timestamp else existing
+        attempt_count = max(0, existing.attempt_count) + max(0, incoming.attempt_count)
+        existing_inner_retries = max(0, existing.total_retries - max(0, existing.attempt_count - 1))
+        incoming_inner_retries = max(0, incoming.total_retries - max(0, incoming.attempt_count - 1))
         return ScenarioHistoryUnitRecord(
             scenario_result_id=preferred.scenario_result_id,
             atomic_attack_name=preferred.atomic_attack_name,
@@ -881,10 +1359,41 @@ def _merge_history_units(
             objective_sha256=preferred.objective_sha256 or existing.objective_sha256 or incoming.objective_sha256,
             latest_outcome=preferred.latest_outcome,
             latest_timestamp=max(existing.latest_timestamp, incoming.latest_timestamp),
-            total_retries=max(0, existing.total_retries) + max(0, incoming.total_retries) + 1,
+            total_retries=ScenarioRunService._total_retry_work(
+                inner_retries=existing_inner_retries + incoming_inner_retries,
+                attempt_count=attempt_count,
+            ),
             error_count=max(0, existing.error_count) + max(0, incoming.error_count),
+            attempt_count=attempt_count,
         )
 
+    @staticmethod
+    def _total_retry_work(*, inner_retries: int, attempt_count: int) -> int:
+        """
+        Count retry work beyond the first logical attempt.
+
+        Returns:
+            int: Inner retries plus additional scenario attempts.
+        """
+        return max(0, inner_retries) + max(0, attempt_count - 1)
+
+    @staticmethod
+    def _load_started_at(*, scenario_result: ScenarioResult) -> datetime | None:
+        """
+        Load the persisted aware execution start timestamp from scenario metadata.
+
+        Returns:
+            datetime | None: The execution start, or None for legacy or invalid metadata.
+        """
+        raw_value = (getattr(scenario_result, "metadata", None) or {}).get(SCENARIO_RUN_STARTED_AT_METADATA_KEY)
+        if raw_value is None:
+            return None
+        try:
+            started_at = _STARTED_AT_ADAPTER.validate_python(raw_value)
+        except ValidationError:
+            return None
+        return started_at if started_at.tzinfo is not None else None
+
     @staticmethod
     def _safe_run_metadata(
         *,
@@ -907,6 +1416,55 @@ def _safe_run_metadata(
             ScenarioRunService._safe_scenario_parameters(parameters=dict(scenario_identifier.params)),
         )
 
+    @staticmethod
+    def _build_overload_summaries(*, retry_events: Sequence[Any]) -> list[ScenarioOverloadSummary]:
+        """
+        Aggregate bounded HTTP overload evidence by component role.
+
+        Returns:
+            list[ScenarioOverloadSummary]: Most recently affected roles first.
+        """
+        aggregates: dict[str, dict[str, Any]] = {}
+        for event in retry_events:
+            status_code = getattr(event, "status_code", None)
+            if not isinstance(status_code, int) or (status_code != 429 and not 500 <= status_code <= 599):
+                continue
+            role = str(getattr(event, "component_role", "") or "unknown")
+            timestamp = getattr(event, "timestamp", None)
+            if not isinstance(timestamp, datetime):
+                continue
+            aggregate = aggregates.setdefault(
+                role,
+                {
+                    "count": 0,
+                    "rate_limit_count": 0,
+                    "server_error_count": 0,
+                    "status_codes": set(),
+                    "latest_timestamp": timestamp,
+                },
+            )
+            aggregate["count"] += 1
+            aggregate["rate_limit_count"] += status_code == 429
+            aggregate["server_error_count"] += 500 <= status_code <= 599
+            aggregate["status_codes"].add(status_code)
+            aggregate["latest_timestamp"] = max(aggregate["latest_timestamp"], timestamp)
+        ordered = sorted(
+            aggregates.items(),
+            key=lambda item: item[1]["latest_timestamp"],
+            reverse=True,
+        )[:_MAX_OVERLOAD_ROLES]
+        return [
+            ScenarioOverloadSummary(
+                component_role=role,
+                count=aggregate["count"],
+                rate_limit_count=aggregate["rate_limit_count"],
+                server_error_count=aggregate["server_error_count"],
+                status_codes=sorted(aggregate["status_codes"]),
+                latest_timestamp=aggregate["latest_timestamp"],
+            )
+            for role, aggregate in ordered
+        ]
+
     @staticmethod
     def _safe_target_metadata(*, target_identifier: TargetIdentifier | None) -> ScenarioTargetSummary | None:
         """
@@ -1068,10 +1626,16 @@ def _decode_history_cursor(
         )
 
     def _get_active_task(self, *, scenario_result_id: str) -> _ActiveTask | None:
-        """Return a live task and release completed task state."""
+        """Return executable state for an active run."""
         active = self._active_tasks.get(scenario_result_id)
-        if active is not None and active.task is not None and active.task.done():
-            self._active_tasks.pop(scenario_result_id, None)
+        if (
+            active is not None
+            and active.task is not None
+            and active.task.done()
+            and self._active_scenario_result_id != scenario_result_id
+        ):
+            self._release_completed_task(scenario_result_id=scenario_result_id)
+            return None
         return active
 
     def snapshot_active_run(self, *, scenario_result_id: str) -> _ActiveRunSnapshot:
@@ -1081,11 +1645,29 @@ def snapshot_active_run(self, *, scenario_result_id: str) -> _ActiveRunSnapshot:
         Returns:
             _ActiveRunSnapshot: An immutable copy of the active state.
         """
+        active_scenario_result_id = self._active_scenario_result_id
+        queue_position = next(
+            (
+                position
+                for position, queued in enumerate(self._queued_runs, start=1)
+                if queued.scenario_result_id == scenario_result_id
+            ),
+            None,
+        )
         active = self._get_active_task(scenario_result_id=scenario_result_id)
         if active is None:
-            return _ActiveRunSnapshot()
+            return _ActiveRunSnapshot(
+                error=self._terminal_errors.get(scenario_result_id),
+                queue_position=queue_position,
+                active_scenario_result_id=active_scenario_result_id,
+            )
         active_group_ids = tuple(sorted(active.scenario.active_atomic_group_ids)) if active.scenario is not None else ()
-        return _ActiveRunSnapshot(error=active.error, active_group_ids=active_group_ids)
+        return _ActiveRunSnapshot(
+            error=active.error,
+            active_group_ids=active_group_ids,
+            queue_position=queue_position,
+            active_scenario_result_id=active_scenario_result_id,
+        )
 
     @staticmethod
     def _load_run_plan(*, scenario_result: ScenarioResult) -> ScenarioRunPlan | None:
@@ -1206,6 +1788,8 @@ def get_run_progress(
             since=since,
             limit=limit,
             active_group_ids=snapshot.active_group_ids,
+            queue_position=snapshot.queue_position,
+            active_scenario_result_id=snapshot.active_scenario_result_id,
         )
 
     def get_run_progress_from_storage(
@@ -1215,6 +1799,8 @@ def get_run_progress_from_storage(
         since: str | None,
         limit: int,
         active_group_ids: Sequence[str],
+        queue_position: int | None = None,
+        active_scenario_result_id: str | None = None,
     ) -> ScenarioRunProgress | None:
         """Return compact database progress using a previously captured live-state snapshot."""
         header_result = self._memory.get_scenario_result_header(scenario_result_id=scenario_result_id)
@@ -1236,6 +1822,9 @@ def get_run_progress_from_storage(
 
         response_plan_lookup = plan_lookup if plan is not None else _ScenarioPlanLookup.from_plan(plan=response_plan)
         results = [self._map_progress_delta(delta=delta, plan_lookup=response_plan_lookup) for delta in deltas]
+        overload_events: deque[Any] = deque(maxlen=_MAX_OVERLOAD_EVENTS)
+        for delta in deltas:
+            overload_events.extend(delta.retry_events)
         next_cursor = (
             self._encode_progress_cursor(scenario_result_id=scenario_result_id, delta=deltas[-1]) if deltas else since
         )
@@ -1260,6 +1849,7 @@ def get_run_progress_from_storage(
                 scenario_version=header_result.scenario_version,
                 status=header_result.scenario_run_state,
                 created_at=header_result.creation_time,
+                started_at=self._load_started_at(scenario_result=header_result),
                 completed_at=header_result.completion_time if terminal else None,
                 pyrit_version=header_result.pyrit_version,
                 target=target,
@@ -1267,6 +1857,9 @@ def get_run_progress_from_storage(
                 datasets_used=datasets_used,
                 scenario_parameters=scenario_parameters,
                 labels=header_result.labels,
+                queue_position=queue_position,
+                active_scenario_result_id=active_scenario_result_id,
+                overload_summaries=self._build_overload_summaries(retry_events=overload_events),
             ),
             plan=response_plan,
             reset=False,
diff --git a/pyrit/exceptions/retry_collector.py b/pyrit/exceptions/retry_collector.py
index 4f5d216498..703b9e085f 100644
--- a/pyrit/exceptions/retry_collector.py
+++ b/pyrit/exceptions/retry_collector.py
@@ -41,12 +41,18 @@ def record(self, *, retry_state: RetryCallState) -> None:
         # Extract exception info
         exception_type = ""
         exception_message = ""
+        status_code: int | None = None
         outcome = retry_state.outcome
         if outcome is not None and outcome.failed:
             exc = outcome.exception()
             if exc:
                 exception_type = type(exc).__name__
                 exception_message = str(exc)
+                candidate_status = getattr(exc, "status_code", None)
+                if not isinstance(candidate_status, int):
+                    candidate_status = getattr(getattr(exc, "response", None), "status_code", None)
+                if isinstance(candidate_status, int):
+                    status_code = candidate_status
 
         # Extract context info
         component_role = ""
@@ -69,6 +75,7 @@ def record(self, *, retry_state: RetryCallState) -> None:
             component_role=component_role,
             component_name=component_name,
             endpoint=endpoint,
+            status_code=status_code,
             elapsed_seconds=round(elapsed, 3),
         )
         self.events.append(event)
diff --git a/pyrit/memory/__init__.py b/pyrit/memory/__init__.py
index 56c2c9ee33..2cd882eef5 100644
--- a/pyrit/memory/__init__.py
+++ b/pyrit/memory/__init__.py
@@ -22,6 +22,8 @@
         ScenarioHistoryKeysetCursor,
         ScenarioHistoryRunRecord,
         ScenarioHistoryUnitRecord,
+        ScenarioProgressKeysetCursor,
+        ScenarioRunStateRecord,
     )
     from pyrit.memory.memory_models import AttackResultEntry, EmbeddingDataEntry, PromptMemoryEntry, SeedEntry
     from pyrit.memory.sqlite_memory import SQLiteMemory
@@ -64,6 +66,8 @@
     "ScenarioHistoryKeysetCursor": "pyrit.memory.memory_interface",
     "ScenarioHistoryRunRecord": "pyrit.memory.memory_interface",
     "ScenarioHistoryUnitRecord": "pyrit.memory.memory_interface",
+    "ScenarioProgressKeysetCursor": "pyrit.memory.memory_interface",
+    "ScenarioRunStateRecord": "pyrit.memory.memory_interface",
     "PromptMemoryEntry": "pyrit.memory.memory_models",
     "SeedEntry": "pyrit.memory.memory_models",
     "set_message_piece_sha256_async": "pyrit.memory.storage",
diff --git a/pyrit/memory/azure_sql_memory.py b/pyrit/memory/azure_sql_memory.py
index bce6d08a50..40dbefc65d 100644
--- a/pyrit/memory/azure_sql_memory.py
+++ b/pyrit/memory/azure_sql_memory.py
@@ -595,7 +595,25 @@ def get_conversation_stats(self, *, conversation_ids: Sequence[str]) -> dict[str
 
         return result
 
-    def _get_scenario_result_label_condition(self, *, labels: Mapping[str, str | Sequence[str]]) -> Any:
+    def _get_scenario_result_label_condition(self, *, labels: dict[str, str]) -> Any:
+        """
+        Filter ScenarioResults by legacy single-value labels.
+
+        Returns:
+            Any: SQLAlchemy condition for all supplied labels.
+        """
+        conditions = []
+        for key_index, (key, value) in enumerate(labels.items()):
+            path_param = f"scenario_label_path_{key_index}"
+            value_param = f"scenario_label_value_{key_index}"
+            conditions.append(
+                text(f"ISJSON(labels) = 1 AND JSON_VALUE(labels, :{path_param}) = :{value_param}").bindparams(
+                    **{path_param: f'$."{key}"', value_param: value}
+                )
+            )
+        return and_(*conditions)
+
+    def _get_scenario_result_labels_condition(self, *, labels: Mapping[str, str | Sequence[str]]) -> Any:
         """
         Get the SQL Azure implementation for filtering ScenarioResults by labels.
 
@@ -672,6 +690,10 @@ def _get_scenario_history_plan_expressions(self) -> tuple[Any, Any, Any]:
             ),
         )
 
+    def _get_scenario_started_at_expression(self) -> Any:
+        """Return the persisted execution start without loading full scenario metadata."""
+        return func.json_value(ScenarioResultEntry.scenario_metadata, "$.started_at")
+
     def _get_scenario_attempt_unit_expressions(self) -> tuple[Any, Any, Any]:
         """Return SQL Server JSON expressions for persisted scenario attempt attribution."""
         atomic_name = func.coalesce(
diff --git a/pyrit/memory/memory_interface.py b/pyrit/memory/memory_interface.py
index 90b97843bf..5135b72daf 100644
--- a/pyrit/memory/memory_interface.py
+++ b/pyrit/memory/memory_interface.py
@@ -18,7 +18,7 @@
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, NamedTuple, TypeVar
 from urllib.parse import urlparse
 
-from sqlalchemy import MetaData, and_, case, func, not_, or_, select
+from sqlalchemy import MetaData, and_, case, func, literal, not_, or_, select
 from sqlalchemy.engine.base import Engine
 from sqlalchemy.exc import IntegrityError, SQLAlchemyError
 from sqlalchemy.orm import joinedload
@@ -168,11 +168,17 @@ class ScenarioHistoryRunRecord:
     scenario_registry_name: str | None
     plan_atomic_groups: str | list[dict[str, Any]] | None
     plan_seed_id_map: str | list[dict[str, str]] | None
+    started_at: datetime | None = None
 
 
 @dataclass(frozen=True, slots=True, kw_only=True)
 class ScenarioHistoryUnitRecord:
-    """One logical scenario work unit aggregated from all persisted attempts."""
+    """
+    One logical scenario work unit aggregated from all persisted attempts.
+
+    ``total_retries`` is all work beyond the initial logical attempt: inner
+    retries plus additional scenario-level attempts.
+    """
 
     scenario_result_id: str
     atomic_attack_name: str
@@ -183,6 +189,15 @@ class ScenarioHistoryUnitRecord:
     latest_timestamp: datetime
     total_retries: int
     error_count: int
+    attempt_count: int = 1
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ScenarioRunStateRecord:
+    """Lightweight persisted ID/state projection used for startup reconciliation."""
+
+    scenario_result_id: str
+    state: ScenarioRunState
 
 
 @dataclass(frozen=True, slots=True, kw_only=True)
@@ -1652,17 +1667,38 @@ def get_conversation_stats(self, *, conversation_ids: Sequence[str]) -> dict[str
         """
 
     @abc.abstractmethod
-    def _get_scenario_result_label_condition(self, *, labels: Mapping[str, str | Sequence[str]]) -> Any:
+    def _get_scenario_result_label_condition(self, *, labels: dict[str, str]) -> Any:
         """
         Return a database-specific condition for filtering ScenarioResults by labels.
 
         Args:
-            labels: Labels with OR-within-key and AND-across-key semantics.
+            labels: Legacy single-value labels with AND-across-key semantics.
 
         Returns:
             Database-specific SQLAlchemy condition.
         """
 
+    def _get_scenario_result_labels_condition(self, *, labels: Mapping[str, str | Sequence[str]]) -> Any:
+        """
+        Compose multi-value label filters through the legacy single-value hook.
+
+        Returns:
+            Any: OR-within-key and AND-across-key SQLAlchemy condition.
+        """
+        conditions = []
+        for key, raw_value in labels.items():
+            values = [raw_value] if isinstance(raw_value, str) else list(raw_value)
+            if values:
+                conditions.append(
+                    or_(
+                        *(
+                            self._get_scenario_result_label_condition(labels={key: str(value)}).unique_params()
+                            for value in values
+                        )
+                    )
+                )
+        return and_(*conditions)
+
     def _get_scenario_registry_name_condition(self, *, scenario_names: Sequence[str]) -> Any:
         """
         Return a backend-specific condition matching persisted run-plan registry names.
@@ -1687,6 +1723,10 @@ def _get_scenario_history_plan_expressions(self) -> tuple[Any, Any, Any]:
             "to support Scenario history queries."
         )
 
+    def _get_scenario_started_at_expression(self) -> Any:
+        """Return a compact persisted start-time expression when the backend supports one."""
+        return literal(None)
+
     def _get_scenario_attempt_unit_expressions(self) -> tuple[Any, Any, Any]:
         """
         Return backend-specific JSON expressions for scenario attempt unit attribution.
@@ -3942,6 +3982,29 @@ def update_scenario_run_state(
             error_message (str | None): Optional scenario-level error message.
             error_type (str | None): Optional exception class name.
 
+        Raises:
+            ValueError: If the scenario result is not found.
+        """
+        self.update_scenario_run_state_and_metadata_fields(
+            scenario_result_id=scenario_result_id,
+            scenario_run_state=scenario_run_state,
+            error_message=error_message,
+            error_type=error_type,
+            metadata_fields={},
+        )
+
+    def update_scenario_run_state_and_metadata_fields(
+        self,
+        *,
+        scenario_result_id: str,
+        scenario_run_state: ScenarioRunState,
+        metadata_fields: Mapping[str, Any],
+        error_message: str | None = None,
+        error_type: str | None = None,
+    ) -> None:
+        """
+        Update run state and merge scenario metadata in one transaction.
+
         Raises:
             ValueError: If the scenario result is not found.
         """
@@ -3954,6 +4017,9 @@ def update_scenario_run_state(
             entry.scenario_run_state = scenario_run_state.value
             entry.error_message = error_message
             entry.error_type = error_type
+            if metadata_fields:
+                entry.scenario_metadata = {**(entry.scenario_metadata or {}), **metadata_fields}
+                flag_modified(entry, "scenario_metadata")
             if scenario_run_state in (
                 ScenarioRunState.COMPLETED,
                 ScenarioRunState.FAILED,
@@ -3993,6 +4059,26 @@ def update_scenario_metadata(
             entry.scenario_metadata = metadata if metadata else None
             session.commit()
 
+    def update_scenario_metadata_fields(
+        self,
+        *,
+        scenario_result_id: str,
+        fields: Mapping[str, Any],
+    ) -> None:
+        """
+        Merge selected fields into persisted scenario metadata in one transaction.
+
+        Raises:
+            ValueError: If the scenario result is not found.
+        """
+        with closing(self.get_session()) as session:
+            entry = session.query(ScenarioResultEntry).filter_by(id=scenario_result_id).first()
+            if not entry:
+                raise ValueError(f"Scenario result with ID {scenario_result_id} not found in memory")
+            entry.scenario_metadata = {**(entry.scenario_metadata or {}), **fields}
+            flag_modified(entry, "scenario_metadata")
+            session.commit()
+
     def get_scenario_result_header(self, *, scenario_result_id: str) -> ScenarioResult | None:
         """Return one ScenarioResult header without hydrating linked attack results."""
         with closing(self.get_session()) as session:
@@ -4021,6 +4107,46 @@ def get_scenario_result_headers(self, *, limit: int = 100) -> Sequence[ScenarioR
         )
         return [entry.get_scenario_result() for entry in entries]
 
+    def get_scenario_run_state_page(
+        self,
+        *,
+        states: Sequence[ScenarioRunState],
+        after_id: str | None = None,
+        limit: int = 500,
+    ) -> tuple[list[ScenarioRunStateRecord], bool]:
+        """
+        Return one bounded ID/state page without hydrating ScenarioResults or AttackResults.
+
+        Returns:
+            tuple[list[ScenarioRunStateRecord], bool]: State records and whether another page exists.
+
+        Raises:
+            ValueError: If the limit or cursor ID is invalid.
+        """
+        if limit < 1 or limit > 500:
+            raise ValueError("Scenario run state projection limit must be between 1 and 500.")
+        conditions = [ScenarioResultEntry.scenario_run_state.in_([state.value for state in states])]
+        if after_id is not None:
+            conditions.append(ScenarioResultEntry.id > uuid.UUID(after_id))
+        statement = (
+            select(ScenarioResultEntry.id, ScenarioResultEntry.scenario_run_state)
+            .where(and_(*conditions))
+            .order_by(ScenarioResultEntry.id.asc())
+            .limit(limit + 1)
+        )
+        with closing(self.get_session()) as session:
+            rows = session.execute(statement).all()
+        return (
+            [
+                ScenarioRunStateRecord(
+                    scenario_result_id=str(row.id),
+                    state=ScenarioRunState(row.scenario_run_state),
+                )
+                for row in rows[:limit]
+            ],
+            len(rows) > limit,
+        )
+
     def get_scenario_run_history_page(
         self,
         *,
@@ -4071,7 +4197,7 @@ def get_scenario_run_history_page(
                 f"Invalid label key(s) {invalid_keys!r}: keys must match {self._LABEL_KEY_PATTERN.pattern}."
             )
         if effective_labels:
-            conditions.append(self._get_scenario_result_label_condition(labels=effective_labels))
+            conditions.append(self._get_scenario_result_labels_condition(labels=effective_labels))
         if cursor is not None:
             cursor_id = uuid.UUID(cursor.scenario_result_id)
             conditions.append(
@@ -4094,6 +4220,7 @@ def get_scenario_run_history_page(
             ScenarioResultEntry.scenario_run_state,
             ScenarioResultEntry.labels,
             ScenarioResultEntry.timestamp,
+            self._get_scenario_started_at_expression().label("started_at"),
             ScenarioResultEntry.completion_time,
             ScenarioResultEntry.error_message,
             ScenarioResultEntry.error_type,
@@ -4133,11 +4260,18 @@ def get_scenario_run_history_page(
                     AttackResultEntry.objective_sha256.label("objective_sha256"),
                     AttackResultEntry.outcome.label("latest_outcome"),
                     func.max(AttackResultEntry.timestamp).over(partition_by=unit_partition).label("latest_timestamp"),
-                    (
-                        func.sum(func.coalesce(AttackResultEntry.total_retries, 0)).over(partition_by=unit_partition)
-                        + func.count().over(partition_by=unit_partition)
-                        - 1
-                    ).label("total_retries"),
+                    func.sum(
+                        case(
+                            (
+                                func.coalesce(AttackResultEntry.total_retries, 0) > 0,
+                                func.coalesce(AttackResultEntry.total_retries, 0),
+                            ),
+                            else_=0,
+                        )
+                    )
+                    .over(partition_by=unit_partition)
+                    .label("inner_retries"),
+                    func.count().over(partition_by=unit_partition).label("attempt_count"),
                     func.sum(case((AttackResultEntry.outcome == AttackOutcome.ERROR.value, 1), else_=0))
                     .over(partition_by=unit_partition)
                     .label("error_count"),
@@ -4166,6 +4300,7 @@ def get_scenario_run_history_page(
                 status=row.scenario_run_state,
                 labels=row.labels or {},
                 created_at=row.timestamp,
+                started_at=self._parse_scenario_started_at(raw_value=row.started_at),
                 completed_at=row.completion_time,
                 error_message=row.error_message,
                 error_type=row.error_type,
@@ -4189,12 +4324,29 @@ def get_scenario_run_history_page(
                     objective_sha256=row.objective_sha256,
                     latest_outcome=row.latest_outcome,
                     latest_timestamp=row.latest_timestamp,
-                    total_retries=row.total_retries or 0,
+                    total_retries=(row.inner_retries or 0) + max(0, (row.attempt_count or 0) - 1),
                     error_count=row.error_count or 0,
+                    attempt_count=row.attempt_count or 0,
                 )
             )
         return records, units_by_run, len(rows) > limit
 
+    @staticmethod
+    def _parse_scenario_started_at(*, raw_value: Any) -> datetime | None:
+        """
+        Parse a persisted aware scenario start timestamp.
+
+        Returns:
+            datetime | None: Aware start timestamp, or None for legacy or malformed values.
+        """
+        if not isinstance(raw_value, str):
+            return None
+        try:
+            value = datetime.fromisoformat(raw_value)
+        except ValueError:
+            return None
+        return value if value.tzinfo is not None else None
+
     def get_unique_scenario_labels(self) -> dict[str, list[str]]:
         """Return all unique label values across scenario results."""
         label_values: dict[str, set[str]] = {}
diff --git a/pyrit/memory/sqlite_memory.py b/pyrit/memory/sqlite_memory.py
index 74f41bc60a..3b2f5651e9 100644
--- a/pyrit/memory/sqlite_memory.py
+++ b/pyrit/memory/sqlite_memory.py
@@ -439,9 +439,20 @@ def get_conversation_stats(self, *, conversation_ids: Sequence[str]) -> dict[str
 
         return result
 
-    def _get_scenario_result_label_condition(self, *, labels: Mapping[str, str | Sequence[str]]) -> Any:
+    def _get_scenario_result_label_condition(self, *, labels: dict[str, str]) -> Any:
         """
-        SQLite implementation for filtering ScenarioResults by labels.
+        Filter ScenarioResults by legacy single-value labels.
+
+        Returns:
+            Any: SQLAlchemy condition for all supplied labels.
+        """
+        return and_(
+            *(func.json_extract(ScenarioResultEntry.labels, f'$."{key}"') == value for key, value in labels.items())
+        )
+
+    def _get_scenario_result_labels_condition(self, *, labels: Mapping[str, str | Sequence[str]]) -> Any:
+        """
+        SQLite implementation for filtering ScenarioResults by multi-value labels.
         Uses json_extract() function specific to SQLite.
 
         Returns:
@@ -499,6 +510,10 @@ def _get_scenario_history_plan_expressions(self) -> tuple[Any, Any, Any]:
             compact_seed_map,
         )
 
+    def _get_scenario_started_at_expression(self) -> Any:
+        """Return the persisted execution start without loading full scenario metadata."""
+        return func.json_extract(ScenarioResultEntry.scenario_metadata, "$.started_at")
+
     def _get_scenario_attempt_unit_expressions(self) -> tuple[Any, Any, Any]:
         """Return SQLite JSON expressions for persisted scenario attempt attribution."""
         atomic_name = func.coalesce(
diff --git a/pyrit/models/__init__.py b/pyrit/models/__init__.py
index 5b666173d8..5b8d2b8bdc 100644
--- a/pyrit/models/__init__.py
+++ b/pyrit/models/__init__.py
@@ -108,9 +108,12 @@
     from pyrit.models.scenario_progress import (
         SCENARIO_RUN_PLAN_METADATA_KEY,
         SCENARIO_RUN_PLAN_VERSION,
+        SCENARIO_RUN_STARTED_AT_METADATA_KEY,
         ScenarioAttackResultDelta,
         ScenarioProgressHeader,
         ScenarioProgressResult,
+        ScenarioQueueEntry,
+        ScenarioQueueSnapshot,
         ScenarioRunPlan,
         ScenarioRunPlanAtomicGroup,
         ScenarioRunPlanSeedGroup,
@@ -260,9 +263,12 @@
     "ScenarioRunState": "pyrit.models.results.scenario_result",
     "SCENARIO_RUN_PLAN_METADATA_KEY": "pyrit.models.scenario_progress",
     "SCENARIO_RUN_PLAN_VERSION": "pyrit.models.scenario_progress",
+    "SCENARIO_RUN_STARTED_AT_METADATA_KEY": "pyrit.models.scenario_progress",
     "ScenarioAttackResultDelta": "pyrit.models.scenario_progress",
     "ScenarioProgressHeader": "pyrit.models.scenario_progress",
     "ScenarioProgressResult": "pyrit.models.scenario_progress",
+    "ScenarioQueueEntry": "pyrit.models.scenario_progress",
+    "ScenarioQueueSnapshot": "pyrit.models.scenario_progress",
     "ScenarioRunPlan": "pyrit.models.scenario_progress",
     "ScenarioRunPlanAtomicGroup": "pyrit.models.scenario_progress",
     "ScenarioRunPlanSeedGroup": "pyrit.models.scenario_progress",
diff --git a/pyrit/models/catalog/scenario.py b/pyrit/models/catalog/scenario.py
index 8884d466ef..d46af4068c 100644
--- a/pyrit/models/catalog/scenario.py
+++ b/pyrit/models/catalog/scenario.py
@@ -310,6 +310,17 @@ class AttackRetrySummary(BaseModel):
     )
 
 
+class ScenarioOverloadSummary(BaseModel):
+    """Recent structured overload signals grouped by component role."""
+
+    component_role: str = Field(..., description="Role of the component that observed overload")
+    count: int = Field(..., ge=1, description="Recent HTTP 429 and 5xx retry signals")
+    rate_limit_count: int = Field(0, ge=0, description="Recent HTTP 429 retry signals")
+    server_error_count: int = Field(0, ge=0, description="Recent HTTP 5xx retry signals")
+    status_codes: list[int] = Field(default_factory=list, description="Observed overload status codes")
+    latest_timestamp: datetime = Field(..., description="Latest overload signal timestamp")
+
+
 class ScenarioRunSummary(BaseModel):
     """Response for a scenario run (status + result details)."""
 
@@ -319,6 +330,7 @@ class ScenarioRunSummary(BaseModel):
     scenario_version: int = Field(0, ge=0, description="Version of the scenario")
     status: ScenarioRunState = Field(..., description="Current run status")
     created_at: datetime = Field(..., description="When the run was created")
+    started_at: datetime | None = Field(None, description="When active scenario execution started")
     updated_at: datetime = Field(..., description="When the run status last changed")
     error: str | None = Field(None, description="Error message if status is FAILED")
     error_type: str | None = Field(None, description="Exception class name if status is FAILED")
@@ -335,7 +347,10 @@ class ScenarioRunSummary(BaseModel):
         description="Per-attack retry events, surfaced as each attack result lands so the CLI can stream warnings",
     )
     total_retries: int = Field(
-        0, ge=0, description="Total retry attempts recorded across all attack results (endpoint-stress signal)"
+        0,
+        ge=0,
+        description="Total retry work beyond each logical unit's initial attempt, including inner retries "
+        "and additional scenario attempts",
     )
     labels: dict[str, str] = Field(default_factory=dict, description="Labels attached to this run")
     completed_at: datetime | None = Field(None, description="When the scenario finished")
@@ -356,6 +371,12 @@ class ScenarioRunSummary(BaseModel):
         True,
         description="Whether failed_attacks and attack_retries contain per-attempt details",
     )
+    queue_position: int | None = Field(None, ge=1, description="Current 1-based waiting position")
+    active_scenario_result_id: str | None = Field(None, description="Currently executing scenario result ID")
+    overload_summaries: list[ScenarioOverloadSummary] = Field(
+        default_factory=list,
+        description="Bounded recent HTTP 429 and 5xx retry evidence grouped by component role",
+    )
 
 
 class ScenarioRunListItem(BaseModel):
@@ -367,6 +388,7 @@ class ScenarioRunListItem(BaseModel):
     scenario_version: int = Field(0, ge=0, description="Version of the scenario")
     status: ScenarioRunState = Field(..., description="Current run status")
     created_at: datetime = Field(..., description="When the run was created")
+    started_at: datetime | None = Field(None, description="When active scenario execution started")
     updated_at: datetime = Field(..., description="When the run status last changed")
     error: str | None = Field(None, description="Persisted run-level error message")
     error_type: str | None = Field(None, description="Persisted run-level exception class")
diff --git a/pyrit/models/results/scenario_result.py b/pyrit/models/results/scenario_result.py
index bddfb26f20..bb03ec8a8b 100644
--- a/pyrit/models/results/scenario_result.py
+++ b/pyrit/models/results/scenario_result.py
@@ -46,6 +46,7 @@ class ScenarioRunState(str, Enum):
     """
 
     CREATED = "CREATED"
+    QUEUED = "QUEUED"
     IN_PROGRESS = "IN_PROGRESS"
     COMPLETED = "COMPLETED"
     FAILED = "FAILED"
diff --git a/pyrit/models/retry_event.py b/pyrit/models/retry_event.py
index 7f5a0f7982..6e0945372d 100644
--- a/pyrit/models/retry_event.py
+++ b/pyrit/models/retry_event.py
@@ -28,4 +28,5 @@ class RetryEvent(BaseModel):
     component_role: str = ""
     component_name: str | None = None
     endpoint: str | None = None
+    status_code: int | None = None
     elapsed_seconds: float = 0.0
diff --git a/pyrit/models/scenario_progress.py b/pyrit/models/scenario_progress.py
index df7e1b2822..4bc3ffe53e 100644
--- a/pyrit/models/scenario_progress.py
+++ b/pyrit/models/scenario_progress.py
@@ -8,13 +8,14 @@
 
 from pydantic import AwareDatetime, BaseModel, Field, model_validator
 
-from pyrit.models.catalog.scenario import ScenarioTargetSummary  # noqa: TC001
+from pyrit.models.catalog.scenario import ScenarioOverloadSummary, ScenarioTargetSummary  # noqa: TC001
 from pyrit.models.identifiers.atomic_attack_identifier import AtomicAttackIdentifier
 from pyrit.models.results.attack_result import AttackOutcome
 from pyrit.models.results.scenario_result import ScenarioRunState
 from pyrit.models.retry_event import RetryEvent
 
 SCENARIO_RUN_PLAN_METADATA_KEY = "run_plan"
+SCENARIO_RUN_STARTED_AT_METADATA_KEY = "started_at"
 SCENARIO_RUN_PLAN_VERSION = 1
 
 
@@ -85,6 +86,7 @@ class ScenarioProgressHeader(BaseModel):
     scenario_version: int
     status: ScenarioRunState
     created_at: datetime
+    started_at: AwareDatetime | None = None
     completed_at: datetime | None = None
     pyrit_version: str | None = None
     target: "ScenarioTargetSummary | None" = None
@@ -92,6 +94,9 @@ class ScenarioProgressHeader(BaseModel):
     datasets_used: list[str] = Field(default_factory=list)
     scenario_parameters: dict[str, Any] = Field(default_factory=dict)
     labels: dict[str, str] = Field(default_factory=dict)
+    queue_position: int | None = Field(None, ge=1)
+    active_scenario_result_id: str | None = None
+    overload_summaries: list["ScenarioOverloadSummary"] = Field(default_factory=list)
 
 
 class ScenarioProgressResult(BaseModel):
@@ -123,6 +128,28 @@ class ScenarioRunProgress(BaseModel):
     plan_complete: bool
 
 
+class ScenarioQueueEntry(BaseModel):
+    """One active or queued scenario run in scheduler order."""
+
+    scenario_result_id: str
+    scenario_name: str
+    scenario_registry_name: str
+    created_at: AwareDatetime
+    enqueued_at: AwareDatetime
+    started_at: AwareDatetime | None = None
+    state: ScenarioRunState
+    position: int | None = Field(None, ge=1)
+
+
+class ScenarioQueueSnapshot(BaseModel):
+    """Point-in-time FIFO scheduler state."""
+
+    revision: int = Field(ge=0)
+    snapshot_at: AwareDatetime
+    active: ScenarioQueueEntry | None = None
+    queued: list[ScenarioQueueEntry] = Field(default_factory=list)
+
+
 class ScenarioAttackResultDelta(BaseModel):
     """Lightweight memory projection used to map one scenario progress delta."""
 
diff --git a/pyrit/registry/components/scenario_registry.py b/pyrit/registry/components/scenario_registry.py
index e5823ec1f3..cbd84f5206 100644
--- a/pyrit/registry/components/scenario_registry.py
+++ b/pyrit/registry/components/scenario_registry.py
@@ -24,6 +24,7 @@
 from pyrit.registry.registry_metadata import RegistryMetadata
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
     from types import ModuleType
 
     from pyrit.models import Parameter
@@ -245,6 +246,7 @@ async def create_and_initialize_async(
         *,
         scenario_params: dict[str, Any] | None = None,
         scenario_result_id: str | None = None,
+        initial_metadata: Mapping[str, Any] | None = None,
         **initialize_kwargs: Any,
     ) -> Scenario:
         """
@@ -274,6 +276,8 @@ async def create_and_initialize_async(
                 parameters to set before initialization. Defaults to an empty mapping.
             scenario_result_id (str | None): Existing scenario-result id to resume,
                 or ``None`` to start a fresh run.
+            initial_metadata (Mapping[str, Any] | None): Caller-owned metadata to
+                persist atomically when a fresh scenario result is created.
             **initialize_kwargs (Any): Common run-resolved parameters merged into the
                 param bag (notably ``objective_target``).
 
@@ -287,5 +291,7 @@ async def create_and_initialize_async(
         merged_args = {**(scenario_params or {}), **initialize_kwargs}
         scenario = self._create_and_configure(name, params=merged_args, constructor_kwargs=constructor_kwargs)
         scenario.set_scenario_registry_name(scenario_registry_name=name)
+        if initial_metadata:
+            scenario.set_initial_metadata(metadata=initial_metadata)
         await scenario.initialize_async()
         return scenario
diff --git a/pyrit/scenario/core/scenario.py b/pyrit/scenario/core/scenario.py
index 6973d7cdc5..5e36c15d46 100644
--- a/pyrit/scenario/core/scenario.py
+++ b/pyrit/scenario/core/scenario.py
@@ -12,7 +12,7 @@
 import logging
 import uuid
 from abc import ABC, abstractmethod
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, final
@@ -235,6 +235,7 @@ def __init__(
         self._atomic_attacks: list[AtomicAttack] = []
         self._scenario_result_id: str | None = str(scenario_result_id) if scenario_result_id else None
         self._scenario_registry_name: str | None = None
+        self._initial_metadata: dict[str, Any] = {}
         self._active_atomic_groups: dict[str, str] = {}
 
         # Store prepared techniques for use in _build_atomic_attacks_async
@@ -282,6 +283,10 @@ def set_scenario_registry_name(self, *, scenario_registry_name: str) -> None:
         """Record the requested registry name for durable run-plan attribution."""
         self._scenario_registry_name = scenario_registry_name
 
+    def set_initial_metadata(self, *, metadata: Mapping[str, Any]) -> None:
+        """Set caller-owned metadata to persist when a new scenario result is created."""
+        self._initial_metadata = dict(metadata)
+
     @classmethod
     def _common_scenario_parameters(cls) -> list[Parameter]:
         """
@@ -986,7 +991,10 @@ async def initialize_async(self) -> None:
             attack_results=attack_results,
             scenario_run_state=ScenarioRunState.CREATED,
             display_group_map=self._display_group_map,
-            metadata=self._build_initial_scenario_metadata(),
+            metadata={
+                **self._build_initial_scenario_metadata(),
+                **self._initial_metadata,
+            },
         )
 
         self._memory.add_scenario_results_to_memory(scenario_results=[result])
diff --git a/tests/unit/backend/test_main.py b/tests/unit/backend/test_main.py
index 170e314288..a36976f20b 100644
--- a/tests/unit/backend/test_main.py
+++ b/tests/unit/backend/test_main.py
@@ -18,13 +18,26 @@
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from pyrit.backend.main import SPAStaticFiles, app, lifespan, setup_frontend
+from pyrit.backend.services.scenario_run_service import ScenarioRunService
+from pyrit.memory import AzureSQLMemory
 from pyrit.setup.configuration_loader import ConfigurationLoader
 
 
+@pytest.fixture
+def mock_scenario_run_lifecycle():
+    """Mock scenario scheduling lifecycle hooks."""
+    service = MagicMock(
+        reconcile_interrupted_runs_async=AsyncMock(return_value=0),
+        shutdown_async=AsyncMock(),
+    )
+    with patch("pyrit.backend.main.get_scenario_run_service", return_value=service):
+        yield service
+
+
 class TestLifespan:
     """Tests for the application lifespan context manager."""
 
-    async def test_lifespan_yields(self) -> None:
+    async def test_lifespan_yields(self, mock_scenario_run_lifecycle) -> None:
         """Test that lifespan delegates to ConfigurationLoader and yields."""
         fake_config = ConfigurationLoader()
         service = MagicMock(run_additional_initializers_async=AsyncMock())
@@ -42,8 +55,10 @@ async def test_lifespan_yields(self) -> None:
             assert app.state.max_concurrent_scenario_runs == fake_config.max_concurrent_scenario_runs
             assert app.state.allow_custom_initializers is False
             service.run_additional_initializers_async.assert_awaited_once_with()
+            mock_scenario_run_lifecycle.reconcile_interrupted_runs_async.assert_awaited_once()
+            mock_scenario_run_lifecycle.shutdown_async.assert_awaited_once()
 
-    async def test_lifespan_warns_when_custom_initializers_allowed(self) -> None:
+    async def test_lifespan_warns_when_custom_initializers_allowed(self, mock_scenario_run_lifecycle) -> None:
         """Test that lifespan logs a warning when allow_custom_initializers is enabled."""
         fake_config = ConfigurationLoader(allow_custom_initializers=True)
         with (
@@ -63,7 +78,34 @@ async def test_lifespan_warns_when_custom_initializers_allowed(self) -> None:
 
             mock_warning.assert_called_once()
 
-    async def test_lifespan_populates_default_labels_from_operator_and_operation(self) -> None:
+    async def test_lifespan_shared_memory_reconciliation_is_non_destructive(self) -> None:
+        shared_memory = MagicMock(spec=AzureSQLMemory)
+        fake_config = ConfigurationLoader()
+        with patch(
+            "pyrit.backend.services.scenario_run_service.CentralMemory.get_memory_instance",
+            return_value=shared_memory,
+        ):
+            service = ScenarioRunService()
+
+        with (
+            patch.object(ConfigurationLoader, "load_with_overrides", return_value=fake_config),
+            patch.object(ConfigurationLoader, "initialize_pyrit_async", new=AsyncMock()),
+            patch(
+                "pyrit.backend.main.get_initializer_service",
+                return_value=MagicMock(run_additional_initializers_async=AsyncMock()),
+            ),
+            patch("pyrit.backend.main.get_scenario_run_service", return_value=service),
+            patch("pyrit.backend.main.setup_frontend"),
+        ):
+            async with lifespan(app):
+                pass
+
+        shared_memory.get_scenario_run_state_page.assert_not_called()
+        shared_memory.update_scenario_run_state.assert_not_called()
+
+    async def test_lifespan_populates_default_labels_from_operator_and_operation(
+        self, mock_scenario_run_lifecycle
+    ) -> None:
         """Test that operator and operation are exposed as default_labels."""
         fake_config = ConfigurationLoader(operator="alice", operation="op-42")
         with (
@@ -82,7 +124,7 @@ async def test_lifespan_populates_default_labels_from_operator_and_operation(sel
 
             assert app.state.default_labels == {"operator": "alice", "operation": "op-42"}
 
-    async def test_lifespan_loads_explicit_config_as_override(self) -> None:
+    async def test_lifespan_loads_explicit_config_as_override(self, mock_scenario_run_lifecycle) -> None:
         """Test that PYRIT_CONFIG_FILE overlays the default configuration."""
         fake_config = ConfigurationLoader()
         with (
@@ -102,7 +144,7 @@ async def test_lifespan_loads_explicit_config_as_override(self) -> None:
 
             assert str(load_mock.call_args.kwargs["config_file"]).endswith("foo.yaml")
 
-    async def test_lifespan_configures_custom_initializer_source_from_config(self) -> None:
+    async def test_lifespan_configures_custom_initializer_source_from_config(self, mock_scenario_run_lifecycle) -> None:
         """Test that YAML config determines the custom script source."""
         fake_config = ConfigurationLoader(custom_initializers_source="C:/yaml/initializers")
         registry = MagicMock()
@@ -120,7 +162,7 @@ async def test_lifespan_configures_custom_initializer_source_from_config(self) -
         registry.configure_custom_scripts_source.assert_called_once_with("C:/yaml/initializers")
         registry.register_stored_initializers.assert_not_called()
 
-    async def test_lifespan_registers_stored_initializers_when_enabled(self) -> None:
+    async def test_lifespan_registers_stored_initializers_when_enabled(self, mock_scenario_run_lifecycle) -> None:
         """Test that enabled custom initializers are registered before baseline initialization."""
         fake_config = ConfigurationLoader(allow_custom_initializers=True)
         call_order: list[str] = []
@@ -145,7 +187,7 @@ async def initialize_async(*, raise_on_initializer_error: bool) -> None:
         registry.register_stored_initializers.assert_called_once_with()
         assert call_order == ["custom", "baseline"]
 
-    async def test_lifespan_downloads_blob_config_to_temporary_file(self) -> None:
+    async def test_lifespan_downloads_blob_config_to_temporary_file(self, mock_scenario_run_lifecycle) -> None:
         """Test that an Azure Blob config URI is materialized and removed after loading."""
         fake_config = ConfigurationLoader()
         config_content = b"operator: blob-user\n"
diff --git a/tests/unit/backend/test_scenario_run_routes.py b/tests/unit/backend/test_scenario_run_routes.py
index 558768b1fd..f1dfe30322 100644
--- a/tests/unit/backend/test_scenario_run_routes.py
+++ b/tests/unit/backend/test_scenario_run_routes.py
@@ -22,6 +22,8 @@
     AttackOutcome,
     AttackResult,
     ScenarioProgressHeader,
+    ScenarioQueueEntry,
+    ScenarioQueueSnapshot,
     ScenarioRunPlan,
     ScenarioRunProgress,
     ScenarioRunState,
@@ -250,6 +252,45 @@ def test_list_runs_returns_400_for_invalid_cursor(self, client: TestClient) -> N
         assert response.json()["detail"] == "Malformed scenario history cursor."
 
 
+class TestScenarioRunQueueRoute:
+    """Tests for GET /api/scenarios/runs/queue."""
+
+    def test_queue_returns_active_and_ordered_entries(self, client: TestClient) -> None:
+        now = datetime(2025, 1, 1, tzinfo=timezone.utc)
+        snapshot = ScenarioQueueSnapshot(
+            revision=4,
+            snapshot_at=now,
+            active=ScenarioQueueEntry(
+                scenario_result_id="active",
+                scenario_name="ActiveScenario",
+                scenario_registry_name="active.scenario",
+                state=ScenarioRunState.IN_PROGRESS,
+                created_at=now,
+                enqueued_at=now,
+                started_at=now,
+            ),
+            queued=[
+                ScenarioQueueEntry(
+                    scenario_result_id="queued",
+                    scenario_name="QueuedScenario",
+                    scenario_registry_name="queued.scenario",
+                    state=ScenarioRunState.QUEUED,
+                    position=1,
+                    created_at=now,
+                    enqueued_at=now,
+                )
+            ],
+        )
+        with patch("pyrit.backend.routes.scenarios.get_scenario_run_service") as mock_get:
+            mock_get.return_value.get_queue_snapshot.return_value = snapshot
+
+            response = client.get("/api/scenarios/runs/queue")
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.json()["active"]["scenario_result_id"] == "active"
+        assert response.json()["queued"][0]["position"] == 1
+
+
 class TestGetScenarioRunRoute:
     """Tests for GET /api/scenarios/runs/{id}."""
 
@@ -349,7 +390,12 @@ def test_progress_returns_compact_plan_response(self, client: TestClient) -> Non
         with patch("pyrit.backend.routes.scenarios.get_scenario_run_service") as mock_get:
             mock_service = MagicMock()
             mock_service.snapshot_active_run.side_effect = lambda **_: (
-                snapshot_thread.append(get_ident()) or MagicMock(active_group_ids=("active-group",))
+                snapshot_thread.append(get_ident())
+                or MagicMock(
+                    active_group_ids=("active-group",),
+                    queue_position=None,
+                    active_scenario_result_id="test-run-id",
+                )
             )
             mock_service.get_run_progress_from_storage.side_effect = lambda **_: (
                 storage_thread.append(get_ident()) or progress
@@ -366,6 +412,8 @@ def test_progress_returns_compact_plan_response(self, client: TestClient) -> Non
             since=None,
             limit=25,
             active_group_ids=("active-group",),
+            queue_position=None,
+            active_scenario_result_id="test-run-id",
         )
         assert snapshot_thread[0] != storage_thread[0]
 
@@ -388,7 +436,11 @@ async def test_progress_supports_direct_keyword_call(self) -> None:
         )
         with patch("pyrit.backend.routes.scenarios.get_scenario_run_service") as mock_get:
             mock_service = MagicMock()
-            mock_service.snapshot_active_run.return_value = MagicMock(active_group_ids=())
+            mock_service.snapshot_active_run.return_value = MagicMock(
+                active_group_ids=(),
+                queue_position=None,
+                active_scenario_result_id="test-run-id",
+            )
             mock_service.get_run_progress_from_storage.return_value = progress
             mock_get.return_value = mock_service
 
@@ -404,6 +456,8 @@ async def test_progress_supports_direct_keyword_call(self) -> None:
             since=None,
             limit=25,
             active_group_ids=(),
+            queue_position=None,
+            active_scenario_result_id="test-run-id",
         )
 
 
diff --git a/tests/unit/backend/test_scenario_run_service.py b/tests/unit/backend/test_scenario_run_service.py
index b213c6f489..c2a5b75fbb 100644
--- a/tests/unit/backend/test_scenario_run_service.py
+++ b/tests/unit/backend/test_scenario_run_service.py
@@ -17,11 +17,16 @@
 import pyrit.backend.services.scenario_configuration_resolver as _resolver_mod
 import pyrit.backend.services.scenario_run_service as _svc_mod
 from pyrit.backend.services.scenario_run_service import (
-    _DEFAULT_MAX_CONCURRENT_RUNS,
     ScenarioRunService,
 )
 from pyrit.converter import Converter
-from pyrit.memory import ScenarioHistoryRunRecord, ScenarioHistoryUnitRecord
+from pyrit.memory import (
+    AzureSQLMemory,
+    ScenarioHistoryRunRecord,
+    ScenarioHistoryUnitRecord,
+    ScenarioRunStateRecord,
+    SQLiteMemory,
+)
 from pyrit.models import (
     SCENARIO_RUN_PLAN_METADATA_KEY,
     AtomicAttackIdentifier,
@@ -29,6 +34,7 @@
     AttackResult,
     AttackSeedGroup,
     ComponentIdentifier,
+    RetryEvent,
     ScenarioAttackResultDelta,
     ScenarioResult,
     ScenarioRunPlan,
@@ -150,6 +156,7 @@ def _make_history_record(
         status=run_state.value,
         labels={},
         created_at=scenario_result.creation_time,
+        started_at=None,
         completed_at=scenario_result.completion_time,
         error_message=None,
         error_type=None,
@@ -162,7 +169,7 @@ def _make_history_record(
 @pytest.fixture
 def mock_memory():
     """Patch CentralMemory.get_memory_instance to return a mock."""
-    mock = MagicMock()
+    mock = MagicMock(spec=SQLiteMemory)
     mock.get_scenario_results.return_value = []
     mock.get_scenario_result_headers.return_value = []
     # Default: no error AttackResults linked to any scenario. Tests that exercise
@@ -222,12 +229,28 @@ class TestScenarioRunServiceStartRun:
     async def test_start_run_returns_running_status(self, mock_all_registries) -> None:
         """Test that starting a run returns RUNNING status with run_id = scenario_result_id."""
         service = ScenarioRunService()
+        mock_memory = mock_all_registries["memory"]
+        service._terminal_errors["sr-uuid-1"] = "prior failed attempt"
         response = await service.start_run_async(request=_make_request())
 
         assert response.scenario_result_id == "sr-uuid-1"
         assert response.status == ScenarioRunState.IN_PROGRESS
         assert response.scenario_name == "foundry.red_team_agent"
+        assert "sr-uuid-1" not in service._terminal_errors
         assert response.error is None
+        metadata_call = mock_memory.update_scenario_run_state_and_metadata_fields.call_args
+        assert metadata_call.kwargs["scenario_result_id"] == "sr-uuid-1"
+        assert metadata_call.kwargs["scenario_run_state"] == ScenarioRunState.IN_PROGRESS
+        persisted_start = datetime.fromisoformat(
+            metadata_call.kwargs["metadata_fields"][_svc_mod.SCENARIO_RUN_STARTED_AT_METADATA_KEY]
+        )
+        assert persisted_start.tzinfo is not None
+        assert (
+            metadata_call.kwargs["metadata_fields"][_svc_mod._SCHEDULER_METADATA_KEY]
+            == _svc_mod._SCHEDULER_METADATA_VALUE
+        )
+        mock_memory.update_scenario_metadata_fields.assert_not_called()
+        mock_memory.update_scenario_run_state.assert_not_called()
 
     async def test_start_run_invalid_scenario_raises_value_error(self, mock_memory) -> None:
         """Test that an invalid scenario name raises ValueError immediately."""
@@ -376,6 +399,7 @@ def get_aggregate_tags(cls) -> set[str]:
             "airt.jailbreak",
             scenario_params=scenario_params,
             scenario_result_id=None,
+            initial_metadata={_svc_mod._SCHEDULER_METADATA_KEY: _svc_mod._SCHEDULER_METADATA_VALUE},
             objective_target=objective_target,
             max_concurrency=10,
             max_retries=0,
@@ -383,6 +407,107 @@ def get_aggregate_tags(cls) -> set[str]:
             scenario_techniques=[_JailbreakTechnique.PROMPT_SENDING],
         )
 
+    async def test_exact_eight_unit_jailbreak_request_queues_behind_active_run(self, mock_all_registries) -> None:
+        """The configured eight-unit request keeps a stable ID and FIFO position while another run executes."""
+
+        class _JailbreakTechnique(ScenarioTechnique):
+            ALL = ("all", {"all"})
+            DEFAULT = ("default", {"default"})
+            PROMPT_SENDING = ("prompt_sending", {"default"})
+
+            @classmethod
+            def get_aggregate_tags(cls) -> set[str]:
+                return {"all", "default"}
+
+        service = ScenarioRunService()
+        mock_sr = mock_all_registries["scenario_registry"]
+        mock_memory = mock_all_registries["memory"]
+        mock_all_registries["scenario_instance"]._technique_class = _JailbreakTechnique
+        records: dict[str, MagicMock] = {}
+        active_started = asyncio.Event()
+        queued_started = asyncio.Event()
+        release_active = asyncio.Event()
+        started: list[str] = []
+
+        async def _create_scenario(*args: object, **kwargs: object) -> MagicMock:
+            run_id = f"run-{len(records) + 1}"
+            record = _make_db_scenario_result(
+                result_id=run_id,
+                scenario_name=str(args[0]),
+                run_state=ScenarioRunState.CREATED,
+            )
+            records[run_id] = record
+            scenario = MagicMock()
+            scenario._scenario_result_id = run_id
+            scenario.active_atomic_group_ids = set()
+
+            async def _run() -> None:
+                started.append(run_id)
+                if run_id == "run-1":
+                    active_started.set()
+                    await release_active.wait()
+                else:
+                    queued_started.set()
+                record.scenario_run_state = ScenarioRunState.COMPLETED
+
+            scenario.run_async = AsyncMock(side_effect=_run)
+            return scenario
+
+        def _get_results(*, scenario_result_ids: list[str] | None = None) -> list[MagicMock]:
+            if scenario_result_ids is None:
+                return list(records.values())
+            return [records[run_id] for run_id in scenario_result_ids if run_id in records]
+
+        def _update_state(*, scenario_result_id: str, scenario_run_state: ScenarioRunState, **_: object) -> None:
+            records[scenario_result_id].scenario_run_state = scenario_run_state
+
+        mock_sr.create_and_initialize_async = AsyncMock(side_effect=_create_scenario)
+        mock_memory.get_scenario_results.side_effect = _get_results
+        mock_memory.update_scenario_run_state.side_effect = _update_state
+        mock_memory.update_scenario_run_state_and_metadata_fields.side_effect = _update_state
+
+        active_response = await service.start_run_async(request=_make_request())
+        await asyncio.wait_for(active_started.wait(), timeout=1)
+        configured_request = _make_request(
+            scenario_name="airt.jailbreak",
+            techniques=["prompt_sending"],
+            include_baseline=False,
+            scenario_params={"num_jailbreaks": 2, "num_jailbreak_attempts": 1},
+        )
+        queued_response = await service.start_run_async(request=configured_request)
+
+        assert active_response.scenario_result_id == "run-1"
+        assert queued_response.scenario_result_id == "run-2"
+        assert queued_response.status == ScenarioRunState.QUEUED
+        assert queued_response.queue_position == 1
+        assert queued_response.active_scenario_result_id == "run-1"
+        queued_transition = next(
+            call
+            for call in mock_memory.update_scenario_run_state_and_metadata_fields.call_args_list
+            if call.kwargs["scenario_result_id"] == "run-2"
+            and call.kwargs["scenario_run_state"] == ScenarioRunState.QUEUED
+        )
+        assert (
+            queued_transition.kwargs["metadata_fields"][_svc_mod._SCHEDULER_METADATA_KEY]
+            == _svc_mod._SCHEDULER_METADATA_VALUE
+        )
+        assert [(entry.scenario_result_id, entry.position) for entry in service.get_queue_snapshot().queued] == [
+            ("run-2", 1)
+        ]
+        second_init = mock_sr.create_and_initialize_async.await_args_list[1]
+        assert second_init.args == ("airt.jailbreak",)
+        assert second_init.kwargs["scenario_params"] == {
+            "num_jailbreaks": 2,
+            "num_jailbreak_attempts": 1,
+        }
+        assert second_init.kwargs["scenario_techniques"] == [_JailbreakTechnique.PROMPT_SENDING]
+        assert second_init.kwargs["include_baseline"] is False
+
+        release_active.set()
+        await asyncio.wait_for(queued_started.wait(), timeout=1)
+        await asyncio.wait_for(service._active_tasks["run-2"].task, timeout=1)
+        assert started == ["run-1", "run-2"]
+
     async def test_start_run_forwards_include_baseline(self, mock_all_registries) -> None:
         service = ScenarioRunService()
         request = _make_request()
@@ -571,30 +696,112 @@ class _MarkerDatasetConfiguration(DatasetConfiguration):
         assert built_config.dataset_names == ["a", "b"]
         assert built_config.max_dataset_size == 7
 
-    async def test_start_run_exceeds_concurrent_limit(self, mock_all_registries) -> None:
-        """Test that exceeding concurrent run limit raises ValueError."""
+    async def test_concurrent_launches_run_one_at_a_time_in_fifo_order(self, mock_all_registries) -> None:
+        """Concurrent launches queue durably and hand off exactly once in FIFO order."""
         service = ScenarioRunService()
-        scenario_instance = mock_all_registries["scenario_instance"]
         mock_sr = mock_all_registries["scenario_registry"]
+        mock_memory = mock_all_registries["memory"]
+        records: dict[str, MagicMock] = {}
+        release_events: dict[str, asyncio.Event] = {}
+        started_events: dict[str, asyncio.Event] = {}
+        started: list[str] = []
+        active_count = 0
+        max_active_count = 0
+        fail_once = {"handoff_read": False, "queued_cancel": False, "active_cancel": False}
+
+        async def _create_scenario(*args: object, **kwargs: object) -> MagicMock:
+            run_id = f"run-{len(records) + 1}"
+            record = _make_db_scenario_result(result_id=run_id, run_state=ScenarioRunState.CREATED)
+            records[run_id] = record
+            release_events[run_id] = asyncio.Event()
+            started_events[run_id] = asyncio.Event()
+            scenario = MagicMock()
+            scenario._scenario_result_id = run_id
+
+            async def _run() -> None:
+                nonlocal active_count, max_active_count
+                active_count += 1
+                max_active_count = max(max_active_count, active_count)
+                started.append(run_id)
+                started_events[run_id].set()
+                try:
+                    await release_events[run_id].wait()
+                except asyncio.CancelledError:
+                    raise
+                else:
+                    record.scenario_run_state = ScenarioRunState.COMPLETED
+                finally:
+                    active_count -= 1
+
+            scenario.run_async = AsyncMock(side_effect=_run)
+            return scenario
+
+        def _get_results(*, scenario_result_ids: list[str] | None = None) -> list[MagicMock]:
+            if scenario_result_ids is None:
+                return list(records.values())
+            if fail_once["handoff_read"] and scenario_result_ids == ["run-2"]:
+                fail_once["handoff_read"] = False
+                raise RuntimeError("temporary storage failure")
+            return [records[run_id] for run_id in scenario_result_ids if run_id in records]
+
+        def _update_state(*, scenario_result_id: str, scenario_run_state: ScenarioRunState, **_: object) -> None:
+            if (
+                fail_once["queued_cancel"]
+                and scenario_result_id == "run-3"
+                and scenario_run_state == ScenarioRunState.CANCELLED
+            ):
+                fail_once["queued_cancel"] = False
+                raise RuntimeError("temporary cancellation persistence failure")
+            if (
+                fail_once["active_cancel"]
+                and scenario_result_id == "run-2"
+                and scenario_run_state == ScenarioRunState.CANCELLED
+            ):
+                fail_once["active_cancel"] = False
+                raise RuntimeError("temporary active cancellation persistence failure")
+            records[scenario_result_id].scenario_run_state = scenario_run_state
+
+        mock_sr.create_and_initialize_async = AsyncMock(side_effect=_create_scenario)
+        mock_memory.get_scenario_results.side_effect = _get_results
+        mock_memory.update_scenario_run_state.side_effect = _update_state
+        mock_memory.update_scenario_run_state_and_metadata_fields.side_effect = _update_state
+
+        responses = await asyncio.gather(*(service.start_run_async(request=_make_request()) for _ in range(4)))
+
+        assert [response.scenario_result_id for response in responses] == ["run-1", "run-2", "run-3", "run-4"]
+        snapshot = service.get_queue_snapshot()
+        assert snapshot.active and snapshot.active.scenario_result_id == "run-1"
+        assert [(entry.scenario_result_id, entry.position) for entry in snapshot.queued] == [
+            ("run-2", 1),
+            ("run-3", 2),
+            ("run-4", 3),
+        ]
 
-        # Each call needs a unique scenario_result_id
-        call_count = 0
-
-        async def _set_unique_id(*args: object, **kwargs: object) -> object:
-            nonlocal call_count
-            call_count += 1
-            scenario_instance._scenario_result_id = f"sr-uuid-{call_count}"
-            return scenario_instance
-
-        mock_sr.create_and_initialize_async = AsyncMock(side_effect=_set_unique_id)
+        fail_once["handoff_read"] = True
+        release_events["run-1"].set()
+        await asyncio.wait_for(started_events["run-2"].wait(), timeout=1)
+        fail_once["queued_cancel"] = True
+        with pytest.raises(RuntimeError, match="temporary cancellation persistence failure"):
+            await service.cancel_run_async(scenario_result_id="run-3")
+        assert [entry.scenario_result_id for entry in service.get_queue_snapshot().queued] == ["run-3", "run-4"]
+        cancelled = await service.cancel_run_async(scenario_result_id="run-3")
+        assert cancelled and cancelled.status == ScenarioRunState.CANCELLED
+        assert [(entry.scenario_result_id, entry.position) for entry in service.get_queue_snapshot().queued] == [
+            ("run-4", 1)
+        ]
 
-        # Fill up to the limit
-        for _ in range(_DEFAULT_MAX_CONCURRENT_RUNS):
-            await service.start_run_async(request=_make_request())
+        fail_once["active_cancel"] = True
+        with pytest.raises(RuntimeError, match="temporary active cancellation persistence failure"):
+            await service.cancel_run_async(scenario_result_id="run-2")
+        await asyncio.wait_for(started_events["run-4"].wait(), timeout=1)
+        assert records["run-2"].scenario_run_state == ScenarioRunState.CANCELLED
+        release_events["run-4"].set()
+        await asyncio.wait_for(service._active_tasks["run-4"].task, timeout=1)
 
-        # Next one should fail
-        with pytest.raises(ValueError, match="Maximum concurrent runs"):
-            await service.start_run_async(request=_make_request())
+        assert started == ["run-1", "run-2", "run-4"]
+        assert max_active_count == 1
+        assert service.get_queue_snapshot().active is None
+        assert service.get_queue_snapshot().queued == []
 
     async def test_start_run_runs_initializers(self, mock_all_registries) -> None:
         """Test that initializers are run during start_run_async."""
@@ -996,6 +1203,7 @@ async def test_cancel_run_sets_cancelled_status(self, mock_all_registries) -> No
         """Test that cancelling a running scenario persists CANCELLED to DB."""
         service = ScenarioRunService()
         mock_memory = mock_all_registries["memory"]
+        mock_all_registries["scenario_instance"].run_async.side_effect = asyncio.Event().wait
         response = await service.start_run_async(request=_make_request())
 
         # After update_scenario_run_state, the next DB query should return CANCELLED
@@ -1008,7 +1216,7 @@ async def test_cancel_run_sets_cancelled_status(self, mock_all_registries) -> No
 
         result = await service.cancel_run_async(scenario_result_id=response.scenario_result_id)
 
-        mock_memory.update_scenario_run_state.assert_called_once_with(
+        mock_memory.update_scenario_run_state.assert_any_call(
             scenario_result_id=response.scenario_result_id,
             scenario_run_state=ScenarioRunState.CANCELLED,
             error_message="Run was cancelled by user",
@@ -1017,6 +1225,157 @@ async def test_cancel_run_sets_cancelled_status(self, mock_all_registries) -> No
         assert result is not None
         assert result.status == ScenarioRunState.CANCELLED
 
+
+class TestScenarioRunServiceRecovery:
+    """Tests for restart reconciliation and overload evidence."""
+
+    async def test_reconcile_marks_only_scheduler_managed_local_rows_failed(self, mock_memory) -> None:
+        scheduler_metadata = {_svc_mod._SCHEDULER_METADATA_KEY: _svc_mod._SCHEDULER_METADATA_VALUE}
+        interrupted = [
+            ScenarioRunStateRecord(
+                scenario_result_id="created",
+                state=ScenarioRunState.CREATED,
+            ),
+            ScenarioRunStateRecord(
+                scenario_result_id="queued",
+                state=ScenarioRunState.QUEUED,
+            ),
+            ScenarioRunStateRecord(
+                scenario_result_id="running",
+                state=ScenarioRunState.IN_PROGRESS,
+            ),
+            ScenarioRunStateRecord(
+                scenario_result_id="framework-run",
+                state=ScenarioRunState.IN_PROGRESS,
+            ),
+        ]
+        mock_memory.get_scenario_run_state_page.return_value = (interrupted, False)
+        headers = {
+            "created": MagicMock(metadata=scheduler_metadata),
+            "queued": MagicMock(metadata=scheduler_metadata),
+            "running": MagicMock(metadata=scheduler_metadata),
+            "framework-run": MagicMock(metadata={}),
+        }
+        mock_memory.get_scenario_result_header.side_effect = lambda *, scenario_result_id: headers[scenario_result_id]
+
+        reconciled = await ScenarioRunService().reconcile_interrupted_runs_async()
+
+        assert reconciled == 3
+        assert {call.kwargs["scenario_result_id"] for call in mock_memory.update_scenario_run_state.call_args_list} == {
+            "created",
+            "queued",
+            "running",
+        }
+        assert all(
+            call.kwargs["scenario_run_state"] == ScenarioRunState.FAILED
+            and call.kwargs["error_type"] == "ScenarioInterruptedError"
+            for call in mock_memory.update_scenario_run_state.call_args_list
+        )
+        mock_memory.get_scenario_results.assert_not_called()
+        mock_memory.get_scenario_run_state_page.assert_called_once_with(
+            states=(ScenarioRunState.CREATED, ScenarioRunState.QUEUED, ScenarioRunState.IN_PROGRESS),
+            after_id=None,
+            limit=500,
+        )
+
+    async def test_reconcile_pages_nonterminal_state_projection(self, mock_memory) -> None:
+        first = ScenarioRunStateRecord(
+            scenario_result_id="00000000-0000-0000-0000-000000000001",
+            state=ScenarioRunState.QUEUED,
+        )
+        second = ScenarioRunStateRecord(
+            scenario_result_id="00000000-0000-0000-0000-000000000002",
+            state=ScenarioRunState.IN_PROGRESS,
+        )
+        mock_memory.get_scenario_run_state_page.side_effect = [([first], True), ([second], False)]
+        mock_memory.get_scenario_result_header.return_value = MagicMock(
+            metadata={_svc_mod._SCHEDULER_METADATA_KEY: _svc_mod._SCHEDULER_METADATA_VALUE}
+        )
+
+        reconciled = await ScenarioRunService().reconcile_interrupted_runs_async()
+
+        assert reconciled == 2
+        assert mock_memory.get_scenario_run_state_page.call_args_list[1].kwargs["after_id"] == first.scenario_result_id
+
+    async def test_reconcile_shared_backend_is_non_destructive(self) -> None:
+        shared_memory = MagicMock(spec=AzureSQLMemory)
+        with patch(_MEMORY_PATCH, return_value=shared_memory):
+            reconciled = await ScenarioRunService().reconcile_interrupted_runs_async()
+
+        assert reconciled == 0
+        shared_memory.get_scenario_run_state_page.assert_not_called()
+        shared_memory.update_scenario_run_state.assert_not_called()
+
+    async def test_shutdown_fails_active_and_queued_runs_without_starting_next(self, mock_all_registries) -> None:
+        mock_scenario_registry = mock_all_registries["scenario_registry"]
+        mock_memory = mock_all_registries["memory"]
+        records: dict[str, MagicMock] = {}
+        scenarios: dict[str, MagicMock] = {}
+
+        async def _create_scenario(*args: object, **kwargs: object) -> MagicMock:
+            run_id = f"shutdown-{len(records) + 1}"
+            records[run_id] = _make_db_scenario_result(
+                result_id=run_id,
+                run_state=ScenarioRunState.CREATED,
+            )
+            scenario = MagicMock()
+            scenario._scenario_result_id = run_id
+            scenario.run_async = AsyncMock(side_effect=asyncio.Event().wait)
+            scenarios[run_id] = scenario
+            return scenario
+
+        def _get_results(*, scenario_result_ids: list[str] | None = None) -> list[MagicMock]:
+            if scenario_result_ids is None:
+                return list(records.values())
+            return [records[run_id] for run_id in scenario_result_ids if run_id in records]
+
+        def _update_state(*, scenario_result_id: str, scenario_run_state: ScenarioRunState, **_: object) -> None:
+            records[scenario_result_id].scenario_run_state = scenario_run_state
+
+        mock_scenario_registry.create_and_initialize_async = AsyncMock(side_effect=_create_scenario)
+        mock_memory.get_scenario_results.side_effect = _get_results
+        mock_memory.update_scenario_run_state.side_effect = _update_state
+        mock_memory.update_scenario_run_state_and_metadata_fields.side_effect = _update_state
+        service = ScenarioRunService()
+        await service.start_run_async(request=_make_request())
+        await service.start_run_async(request=_make_request())
+        await asyncio.sleep(0)
+
+        await service.shutdown_async()
+
+        assert records["shutdown-1"].scenario_run_state == ScenarioRunState.FAILED
+        assert records["shutdown-2"].scenario_run_state == ScenarioRunState.FAILED
+        scenarios["shutdown-1"].run_async.assert_awaited_once()
+        scenarios["shutdown-2"].run_async.assert_not_awaited()
+        failure_calls = [
+            call
+            for call in mock_memory.update_scenario_run_state.call_args_list
+            if call.kwargs.get("scenario_run_state") == ScenarioRunState.FAILED
+        ]
+        assert len(failure_calls) == 2
+        assert all(call.kwargs["error_type"] == "ScenarioInterruptedError" for call in failure_calls)
+        assert all("shut down" in call.kwargs["error_message"] for call in failure_calls)
+
+    def test_overload_summaries_group_429_and_5xx_by_role_without_false_positives(self, mock_memory) -> None:
+        now = datetime(2025, 1, 1, tzinfo=timezone.utc)
+        events = [
+            RetryEvent(component_role="adversarial_chat", status_code=429, timestamp=now),
+            RetryEvent(component_role="adversarial_chat", status_code=503, timestamp=now + timedelta(seconds=2)),
+            RetryEvent(component_role="objective_target", status_code=500, timestamp=now + timedelta(seconds=1)),
+            RetryEvent(component_role="objective_target", status_code=408, timestamp=now + timedelta(seconds=3)),
+            RetryEvent(component_role="objective_target", exception_message="HTTP 429", timestamp=now),
+        ]
+
+        summaries = ScenarioRunService._build_overload_summaries(retry_events=events)
+
+        assert [summary.component_role for summary in summaries] == ["adversarial_chat", "objective_target"]
+        assert summaries[0].count == 2
+        assert summaries[0].rate_limit_count == 1
+        assert summaries[0].server_error_count == 1
+        assert summaries[0].status_codes == [429, 503]
+        assert summaries[1].count == 1
+        assert summaries[1].status_codes == [500]
+
     async def test_cancel_waits_for_final_persisted_progress_delta(self, mock_all_registries) -> None:
         """Cancellation completes task cleanup before callers can fetch terminal progress."""
         mock_memory = mock_all_registries["memory"]
@@ -1100,46 +1459,62 @@ async def test_execute_run_completes_successfully(self, mock_all_registries) ->
         mock_scenario_result.creation_time = datetime(2025, 1, 1, tzinfo=timezone.utc)
         mock_scenario_result.completion_time = datetime(2025, 1, 1, 0, 5, tzinfo=timezone.utc)
 
-        mock_instance.run_async = AsyncMock(return_value=mock_scenario_result)
+        execution_started = asyncio.Event()
+        release_execution = asyncio.Event()
+
+        async def _run() -> MagicMock:
+            execution_started.set()
+            await release_execution.wait()
+            return mock_scenario_result
+
+        mock_instance.run_async = AsyncMock(side_effect=_run)
 
         response = await service.start_run_async(request=_make_request())
+        await execution_started.wait()
 
         # Wait for the background task to complete
         active = service._active_tasks.get(response.scenario_result_id)
         assert active is not None
         assert active.task is not None
+        release_execution.set()
         await active.task
 
-        # Active task is cleaned up on next get_run (deferred cleanup)
-        assert response.scenario_result_id in service._active_tasks
+        # Executable task state is released during terminal handoff.
+        assert response.scenario_result_id not in service._active_tasks
         fetched = service.get_run(scenario_result_id=response.scenario_result_id)
         assert fetched is not None
-        assert response.scenario_result_id not in service._active_tasks
 
     async def test_execute_run_fails_with_error(self, mock_all_registries) -> None:
         """Test that a run_async failure stores error and surfaces it via get_run."""
         service = ScenarioRunService()
         mock_instance = mock_all_registries["scenario_instance"]
+        execution_started = asyncio.Event()
+        release_execution = asyncio.Event()
 
-        mock_instance.run_async = AsyncMock(side_effect=RuntimeError("scenario exploded"))
+        async def _run() -> None:
+            execution_started.set()
+            await release_execution.wait()
+            raise RuntimeError("scenario exploded")
 
+        mock_instance.run_async = AsyncMock(side_effect=_run)
         response = await service.start_run_async(request=_make_request())
+        await execution_started.wait()
 
         # Wait for the background task
         active = service._active_tasks.get(response.scenario_result_id)
         assert active is not None
         assert active.task is not None
+        release_execution.set()
         await active.task
 
-        # Error is stored on the active task until get_run reads it
+        # Error evidence remains available after executable task state is released.
         assert active.error == "scenario exploded"
-        assert response.scenario_result_id in service._active_tasks
+        assert response.scenario_result_id not in service._active_tasks
 
-        # get_run should surface the error and clean up
+        # get_run surfaces the bounded terminal error evidence.
         fetched = service.get_run(scenario_result_id=response.scenario_result_id)
         assert fetched is not None
         assert fetched.error == "scenario exploded"
-        assert response.scenario_result_id not in service._active_tasks
 
 
 class TestScenarioRunServiceGetResults:
@@ -1304,6 +1679,29 @@ def test_error_attacks_and_retries_are_surfaced(self, mock_memory) -> None:
         assert failed.error_message == "429 Too Many Requests"
         assert failed.total_retries == 4
 
+    def test_negative_error_attack_retries_are_clamped(self, mock_memory) -> None:
+        from pyrit.models import AttackOutcome
+
+        errored = MagicMock()
+        errored.outcome = AttackOutcome.ERROR
+        errored.objective = "malformed persisted result"
+        errored.error_type = "PersistedError"
+        errored.error_message = "invalid retry count"
+        errored.total_retries = -1
+
+        db_result = _make_db_scenario_result(
+            result_id="sr-negative-retries",
+            run_state=ScenarioRunState.COMPLETED,
+            attack_results={"attack_a": [errored]},
+        )
+        mock_memory.get_scenario_results.return_value = [db_result]
+
+        fetched = ScenarioRunService().get_run(scenario_result_id="sr-negative-retries")
+
+        assert fetched is not None
+        assert fetched.total_retries == 0
+        assert fetched.failed_attacks[0].total_retries == 0
+
     def test_no_failed_attacks_when_all_succeed(self, mock_memory) -> None:
         from pyrit.models import AttackOutcome
 
@@ -1578,6 +1976,85 @@ def test_planned_progress_includes_latest_errors_in_success_rate_denominator(moc
     assert summary.objective_achieved_rate == 50
 
 
+def test_history_and_detail_retry_work_match_across_attempt_partitions(mock_memory) -> None:
+    objective = "partitioned objective"
+    plan = ScenarioRunPlan(
+        scenario_registry_name="test.scenario",
+        atomic_groups=[
+            ScenarioRunPlanAtomicGroup(
+                id="group-1",
+                atomic_attack_name="attack",
+                display_group="Attack",
+                technique_eval_hash="eval",
+                seed_group_ids=["seed-1"],
+            )
+        ],
+        seed_groups=[
+            ScenarioRunPlanSeedGroup(
+                id="seed-1",
+                objective_sha256=_svc_mod.to_sha256(objective),
+                objective=objective,
+            )
+        ],
+    )
+    timestamp = datetime(2026, 8, 8, tzinfo=timezone.utc)
+    attempts = [
+        AttackResult(
+            conversation_id=f"conversation-{index}",
+            objective=objective,
+            outcome=outcome,
+            total_retries=inner_retries,
+            timestamp=timestamp + timedelta(seconds=index),
+        )
+        for index, (outcome, inner_retries) in enumerate(
+            ((AttackOutcome.ERROR, 1), (AttackOutcome.ERROR, 0), (AttackOutcome.SUCCESS, 2))
+        )
+    ]
+    scenario_result = make_scenario_result(
+        attack_results={"attack": attempts},
+        scenario_run_state=ScenarioRunState.COMPLETED,
+        metadata={SCENARIO_RUN_PLAN_METADATA_KEY: plan.model_dump(mode="json")},
+    )
+    record = replace(
+        _make_history_record(result_id=str(scenario_result.id), run_state=ScenarioRunState.COMPLETED),
+        scenario_registry_name=plan.scenario_registry_name,
+        plan_atomic_groups=[group.model_dump(mode="json") for group in plan.atomic_groups],
+        plan_seed_id_map=[{"id": "seed-1", "objective_sha256": _svc_mod.to_sha256(objective)}],
+    )
+    units = [
+        ScenarioHistoryUnitRecord(
+            scenario_result_id=str(scenario_result.id),
+            atomic_attack_name="attack",
+            technique_eval_hash="eval",
+            seed_group_id=_svc_mod.to_sha256(objective),
+            objective_sha256=_svc_mod.to_sha256(objective),
+            latest_outcome=AttackOutcome.ERROR.value,
+            latest_timestamp=timestamp + timedelta(seconds=1),
+            total_retries=2,
+            error_count=2,
+            attempt_count=2,
+        ),
+        ScenarioHistoryUnitRecord(
+            scenario_result_id=str(scenario_result.id),
+            atomic_attack_name="attack",
+            technique_eval_hash="eval",
+            seed_group_id="seed-1",
+            objective_sha256=_svc_mod.to_sha256(objective),
+            latest_outcome=AttackOutcome.SUCCESS.value,
+            latest_timestamp=timestamp + timedelta(seconds=2),
+            total_retries=2,
+            error_count=0,
+            attempt_count=1,
+        ),
+    ]
+    service = ScenarioRunService()
+
+    detail = service._build_response_from_db(scenario_result=scenario_result)
+    history = service._build_history_summary(record=record, units=units)
+    assert detail.total_retries == 5
+    assert history.total_retries == detail.total_retries
+
+
 def test_planned_progress_maps_legacy_objective_hash_to_logical_seed_id(mock_memory) -> None:
     objective = "legacy resumed objective"
     seed_group = AttackSeedGroup(seeds=[SeedObjective(value=objective)])
@@ -1653,6 +2130,33 @@ def test_get_progress_uses_lightweight_queries_without_full_hydration(mock_memor
     assert str(header.id) not in service._active_tasks
 
 
+def test_get_progress_exposes_persisted_started_at(mock_memory) -> None:
+    started_at = datetime(2026, 8, 8, 12, 30, tzinfo=timezone.utc)
+    header = make_scenario_result(
+        attack_results={},
+        metadata={
+            SCENARIO_RUN_PLAN_METADATA_KEY: ScenarioRunPlan(
+                atomic_groups=[],
+                seed_groups=[],
+                scenario_registry_name="test.scenario",
+            ).model_dump(mode="json"),
+            _svc_mod.SCENARIO_RUN_STARTED_AT_METADATA_KEY: started_at.isoformat(),
+        },
+    )
+    mock_memory.get_scenario_result_header.return_value = header
+    mock_memory.get_scenario_attack_result_deltas.return_value = ([], False)
+
+    progress = ScenarioRunService().get_run_progress_from_storage(
+        scenario_result_id=str(header.id),
+        since=None,
+        limit=25,
+        active_group_ids=[],
+    )
+
+    assert progress is not None
+    assert progress.run.started_at == started_at
+
+
 def test_get_progress_rejects_duplicate_stored_plan_groups(mock_memory) -> None:
     group = ScenarioRunPlanAtomicGroup(
         id="duplicate",
diff --git a/tests/unit/backend/test_scenario_service.py b/tests/unit/backend/test_scenario_service.py
index f8185d62b0..ff657eb456 100644
--- a/tests/unit/backend/test_scenario_service.py
+++ b/tests/unit/backend/test_scenario_service.py
@@ -810,12 +810,15 @@ def test_get_scenario_returns_404_when_not_found(self, client: TestClient) -> No
             assert response.status_code == status.HTTP_404_NOT_FOUND
 
     def test_estimate_scenario_returns_configured_projection(self, client: TestClient) -> None:
-        """POST catalog estimate forwards request fields and returns the structured estimate."""
+        """Configured estimation returns the exact projection without touching run scheduling."""
         estimate = ScenarioRunSizeEstimate(
             estimated_attack_count=12,
             components=[ScenarioRunSizeComponent(label="Configured Jailbreak", count=12)],
         )
-        with patch("pyrit.backend.routes.scenarios.get_scenario_service") as mock_get_service:
+        with (
+            patch("pyrit.backend.routes.scenarios.get_scenario_service") as mock_get_service,
+            patch("pyrit.backend.routes.scenarios.get_scenario_run_service") as mock_get_run_service,
+        ):
             mock_service = MagicMock()
             mock_service.estimate_scenario_run_size_async = AsyncMock(return_value=estimate)
             mock_get_service.return_value = mock_service
@@ -824,7 +827,7 @@ def test_estimate_scenario_returns_configured_projection(self, client: TestClien
                 "/api/scenarios/catalog/airt.jailbreak/estimate",
                 json={
                     "techniques": ["prompt_sending"],
-                    "include_baseline": True,
+                    "include_baseline": False,
                     "scenario_params": {
                         "num_jailbreaks": 2,
                         "num_jailbreak_attempts": 1,
@@ -836,11 +839,12 @@ def test_estimate_scenario_returns_configured_projection(self, client: TestClien
         assert response.json()["estimated_attack_count"] == 12
         request = mock_service.estimate_scenario_run_size_async.await_args.kwargs["request"]
         assert request.techniques == ["prompt_sending"]
-        assert request.include_baseline is True
+        assert request.include_baseline is False
         assert request.scenario_params == {
             "num_jailbreaks": 2,
             "num_jailbreak_attempts": 1,
         }
+        mock_get_run_service.assert_not_called()
 
     async def test_estimate_scenario_supports_direct_keyword_call(self) -> None:
         """The FastAPI handler remains directly callable through its keyword-only API."""
diff --git a/tests/unit/exceptions/test_retry_collector.py b/tests/unit/exceptions/test_retry_collector.py
index f37b51a886..c4da265581 100644
--- a/tests/unit/exceptions/test_retry_collector.py
+++ b/tests/unit/exceptions/test_retry_collector.py
@@ -66,6 +66,25 @@ def test_record_extracts_exception_info(self) -> None:
         assert evt.exception_type == "ValueError"
         assert evt.exception_message == "test error"
 
+    def test_record_extracts_direct_or_response_status_code(self) -> None:
+        """record() preserves structured HTTP status codes without parsing messages."""
+        from unittest.mock import MagicMock
+
+        class DirectStatusError(Exception):
+            status_code = 429
+
+        class ResponseStatusError(Exception):
+            response = MagicMock(status_code=503)
+
+        collector = RetryCollector()
+        for exception in (DirectStatusError("limited"), ResponseStatusError("unavailable")):
+            retry_state = MagicMock(start_time=0.0, fn=None)
+            retry_state.outcome.failed = True
+            retry_state.outcome.exception.return_value = exception
+            collector.record(retry_state=retry_state)
+
+        assert [event.status_code for event in collector.events] == [429, 503]
+
     def test_record_multiple_events(self) -> None:
         """record() accumulates events."""
         from unittest.mock import MagicMock
diff --git a/tests/unit/memory/memory_interface/test_interface_scenario_history.py b/tests/unit/memory/memory_interface/test_interface_scenario_history.py
index 07c8d2de3d..c50523d962 100644
--- a/tests/unit/memory/memory_interface/test_interface_scenario_history.py
+++ b/tests/unit/memory/memory_interface/test_interface_scenario_history.py
@@ -5,14 +5,17 @@
 
 import json
 import uuid
+from contextlib import closing
 from datetime import datetime, timedelta, timezone
-from unittest.mock import MagicMock
+from typing import Any
+from unittest.mock import MagicMock, patch
 
 import pytest
+from sqlalchemy import and_, select, text
 from unit.mocks import get_mock_target_identifier, make_scenario_result
 
-from pyrit.memory import MemoryInterface, ScenarioHistoryKeysetCursor
-from pyrit.memory.memory_models import ScenarioResultEntry
+from pyrit.memory import MemoryInterface, ScenarioHistoryKeysetCursor, SQLiteMemory
+from pyrit.memory.memory_models import AttackResultEntry, ScenarioResultEntry
 from pyrit.models import (
     SCENARIO_RUN_PLAN_METADATA_KEY,
     AttackOutcome,
@@ -24,6 +27,23 @@
 )
 
 
+class _LegacyScenarioLabelMemory(SQLiteMemory):
+    """Concrete backend retaining the pre-history single-value label hook."""
+
+    _get_scenario_result_labels_condition = MemoryInterface._get_scenario_result_labels_condition
+
+    def _get_scenario_result_label_condition(self, *, labels: dict[str, str]) -> Any:
+        conditions = []
+        for key, value in labels.items():
+            conditions.append(
+                text("json_extract(labels, :scenario_label_path_0) = :scenario_label_value_0").bindparams(
+                    scenario_label_path_0=f'$."{key}"',
+                    scenario_label_value_0=value,
+                )
+            )
+        return and_(*conditions)
+
+
 @pytest.mark.parametrize(
     ("method_name", "kwargs"),
     [
@@ -139,6 +159,11 @@ def test_history_filters_names_statuses_and_labels_without_hydration(
         labels={"operator": "bob", "operation": "nightly", "team.name": "safety"},
     )
     sqlite_instance.add_scenario_results_to_memory(scenario_results=[included, excluded])
+    started_at = timestamp + timedelta(seconds=30)
+    sqlite_instance.update_scenario_metadata_fields(
+        scenario_result_id=str(included.id),
+        fields={"started_at": started_at.isoformat()},
+    )
     attacks = [
         AttackResult(
             attack_result_id=str(uuid.UUID(int=12)),
@@ -155,6 +180,7 @@ def test_history_filters_names_statuses_and_labels_without_hydration(
             },
             error_type="RuntimeError",
             error_message="failed",
+            total_retries=-3,
         ),
         AttackResult(
             attack_result_id=str(uuid.UUID(int=13)),
@@ -190,6 +216,7 @@ def test_history_filters_names_statuses_and_labels_without_hydration(
     )
 
     assert [row.scenario_result_id for row in rows] == [str(included.id)]
+    assert rows[0].started_at == started_at
     assert rows[0].scenario_identifier["class_name"] == "ImplementationClass"
     assert rows[0].scenario_registry_name == "registered.scenario"
     compact_groups = (
@@ -217,6 +244,86 @@ def test_history_filters_names_statuses_and_labels_without_hydration(
     assert has_more is False
 
 
+def test_legacy_label_hook_is_constructible_and_composes_multi_value_semantics(
+    sqlite_instance: MemoryInterface,
+) -> None:
+    timestamp = datetime(2026, 8, 7, tzinfo=timezone.utc)
+    included = _make_scenario(
+        result_id=uuid.UUID(int=30),
+        timestamp=timestamp,
+        name="Included",
+        state=ScenarioRunState.COMPLETED,
+        labels={"operator": "alice", "operation": "nightly"},
+    )
+    excluded = _make_scenario(
+        result_id=uuid.UUID(int=31),
+        timestamp=timestamp,
+        name="Excluded",
+        state=ScenarioRunState.COMPLETED,
+        labels={"operator": "carol", "operation": "nightly"},
+    )
+    sqlite_instance.add_scenario_results_to_memory(scenario_results=[included, excluded])
+    legacy = object.__new__(_LegacyScenarioLabelMemory)
+    condition = legacy._get_scenario_result_labels_condition(
+        labels={"operator": ["alice", "bob"], "operation": "nightly"}
+    )
+
+    with closing(sqlite_instance.get_session()) as session:
+        ids = session.execute(select(ScenarioResultEntry.id).where(condition)).scalars().all()
+
+    assert "_get_scenario_result_label_condition" not in _LegacyScenarioLabelMemory.__abstractmethods__
+    assert ids == [included.id]
+
+
+def test_nonterminal_state_projection_is_bounded_and_never_hydrates_results(
+    sqlite_instance: MemoryInterface,
+) -> None:
+    timestamp = datetime(2026, 8, 7, tzinfo=timezone.utc)
+    queued = _make_scenario(
+        result_id=uuid.UUID(int=40),
+        timestamp=timestamp,
+        name="Queued",
+        state=ScenarioRunState.QUEUED,
+        labels={},
+    )
+    running = _make_scenario(
+        result_id=uuid.UUID(int=41),
+        timestamp=timestamp,
+        name="Running",
+        state=ScenarioRunState.IN_PROGRESS,
+        labels={},
+    )
+    completed = _make_scenario(
+        result_id=uuid.UUID(int=42),
+        timestamp=timestamp,
+        name="Completed",
+        state=ScenarioRunState.COMPLETED,
+        labels={},
+    )
+    sqlite_instance.add_scenario_results_to_memory(scenario_results=[queued, running, completed])
+
+    with (
+        patch.object(ScenarioResultEntry, "get_scenario_result", side_effect=AssertionError("hydrated ScenarioResult")),
+        patch.object(AttackResultEntry, "get_attack_result", side_effect=AssertionError("hydrated AttackResult")),
+    ):
+        first, has_more = sqlite_instance.get_scenario_run_state_page(
+            states=[ScenarioRunState.QUEUED, ScenarioRunState.IN_PROGRESS],
+            limit=1,
+        )
+        second, second_has_more = sqlite_instance.get_scenario_run_state_page(
+            states=[ScenarioRunState.QUEUED, ScenarioRunState.IN_PROGRESS],
+            after_id=first[-1].scenario_result_id,
+            limit=1,
+        )
+
+    assert [record.state for record in [*first, *second]] == [
+        ScenarioRunState.QUEUED,
+        ScenarioRunState.IN_PROGRESS,
+    ]
+    assert has_more is True
+    assert second_has_more is False
+
+
 def test_unique_scenario_labels_are_grouped_for_filter_options(sqlite_instance: MemoryInterface) -> None:
     timestamp = datetime(2026, 8, 7, tzinfo=timezone.utc)
     scenarios = [
diff --git a/tests/unit/memory/test_azure_sql_memory.py b/tests/unit/memory/test_azure_sql_memory.py
index 298a209fb2..dff3bbc779 100644
--- a/tests/unit/memory/test_azure_sql_memory.py
+++ b/tests/unit/memory/test_azure_sql_memory.py
@@ -442,7 +442,7 @@ def test_scenario_history_conditions_bind_or_within_label_and_registry_values(
     memory_interface: AzureSQLMemory,
 ) -> None:
     """Scenario-history SQL Server conditions bind repeated values without interpolation."""
-    label_condition = memory_interface._get_scenario_result_label_condition(
+    label_condition = memory_interface._get_scenario_result_labels_condition(
         labels={"team.name": ["alice", "bob"], "operation": "nightly"}
     )
     registry_condition = memory_interface._get_scenario_registry_name_condition(
diff --git a/tests/unit/registry/test_scenario_registry.py b/tests/unit/registry/test_scenario_registry.py
index a78fd5ab6d..649ef9beb7 100644
--- a/tests/unit/registry/test_scenario_registry.py
+++ b/tests/unit/registry/test_scenario_registry.py
@@ -132,6 +132,7 @@ async def test_create_and_initialize_async_creates_sets_params_and_initializes()
         "my.scenario",
         scenario_params={"foo": "bar"},
         scenario_result_id="sr-1",
+        initial_metadata={"scheduler_managed_by": "test"},
         objective_target=target,
         max_concurrency=2,
     )
@@ -139,6 +140,7 @@ async def test_create_and_initialize_async_creates_sets_params_and_initializes()
     assert result is scenario
     registry.create_instance.assert_called_once_with("my.scenario", scenario_result_id="sr-1")
     scenario.set_scenario_registry_name.assert_called_once_with(scenario_registry_name="my.scenario")
+    scenario.set_initial_metadata.assert_called_once_with(metadata={"scheduler_managed_by": "test"})
     scenario.set_params_from_args.assert_called_once_with(
         args={"foo": "bar", "objective_target": target, "max_concurrency": 2}
     )
diff --git a/tests/unit/scenario/core/test_scenario.py b/tests/unit/scenario/core/test_scenario.py
index e8d15c4ce1..23644d02ca 100644
--- a/tests/unit/scenario/core/test_scenario.py
+++ b/tests/unit/scenario/core/test_scenario.py
@@ -275,6 +275,7 @@ async def test_initialize_async_populates_atomic_attacks(self, mock_atomic_attac
         assert scenario.atomic_attack_count == 0
 
         scenario.set_params_from_args(args={"objective_target": mock_objective_target})
+        scenario.set_initial_metadata(metadata={"scheduler_managed_by": "test"})
         await scenario.initialize_async()
 
         assert scenario.atomic_attack_count == len(mock_atomic_attacks)
@@ -282,6 +283,7 @@ async def test_initialize_async_populates_atomic_attacks(self, mock_atomic_attac
         [stored] = scenario._memory.get_scenario_results(scenario_result_ids=[scenario._scenario_result_id])
         assert stored.metadata["run_plan"]["version"] == 1
         assert len(stored.metadata["run_plan"]["atomic_groups"]) == len(mock_atomic_attacks)
+        assert stored.metadata["scheduler_managed_by"] == "test"
 
     async def test_initialize_async_deduplicates_logical_seed_groups_in_run_plan(self, mock_objective_target) -> None:
         duplicate_seed_groups = [
@@ -350,6 +352,24 @@ async def test_initialize_async_sets_objective_target(self, mock_objective_targe
         assert scenario._objective_target_identifier.class_name == "MockTarget"
         assert scenario._objective_target_identifier.class_module == "test"
 
+    async def test_initial_metadata_survives_subclass_metadata_override(self, mock_objective_target):
+        scenario = ConcreteScenario(name="Test Scenario", version=1)
+        scenario.set_params_from_args(args={"objective_target": mock_objective_target})
+        scenario.set_initial_metadata(metadata={"scheduler_managed_by": "test"})
+
+        with patch.object(
+            scenario,
+            "_build_initial_scenario_metadata",
+            return_value={"scenario_owned": "value"},
+        ):
+            await scenario.initialize_async()
+
+        [stored] = scenario._memory.get_scenario_results(scenario_result_ids=[scenario._scenario_result_id])
+        assert stored.metadata == {
+            "scenario_owned": "value",
+            "scheduler_managed_by": "test",
+        }
+
     async def test_initialize_async_requires_objective_target(self):
         """Test that initialize_async raises ValueError when objective_target is None."""
         scenario = ConcreteScenario(

From 0226009cc11e9abf4abcca2c162072e228686dc7 Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Thu, 20 Aug 2026 22:03:48 -0700
Subject: [PATCH 04/12] FIX: Align FIFO scheduling with history contracts

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 frontend/src/components/History/ScenarioHistory.test.tsx | 9 ++-------
 pyrit/backend/services/scenario_run_service.py           | 2 +-
 pyrit/memory/__init__.py                                 | 2 --
 3 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/frontend/src/components/History/ScenarioHistory.test.tsx b/frontend/src/components/History/ScenarioHistory.test.tsx
index c8ec9ce51f..b4d75de6d5 100644
--- a/frontend/src/components/History/ScenarioHistory.test.tsx
+++ b/frontend/src/components/History/ScenarioHistory.test.tsx
@@ -158,14 +158,9 @@ describe('ScenarioHistory', () => {
         completed_at: null,
         total_attacks: 0,
         completed_attacks: 0,
-        successful_attacks: undefined,
+        successful_attacks: 0,
         objective_achieved_rate: 0,
-        failed_attacks: [{
-          atomic_attack_name: 'legacy-attack',
-          objective: 'Legacy objective',
-          total_retries: 0,
-        }],
-        error_attacks: undefined,
+        error_attacks: 1,
         total_retries: 0,
         labels: {},
         target: {
diff --git a/pyrit/backend/services/scenario_run_service.py b/pyrit/backend/services/scenario_run_service.py
index 872370d77a..ff2beec815 100644
--- a/pyrit/backend/services/scenario_run_service.py
+++ b/pyrit/backend/services/scenario_run_service.py
@@ -66,8 +66,8 @@
     AttackErrorSummary,
     AttackRetrySummary,
     RunScenarioRequest,
-    ScenarioRunListItem,
     ScenarioOverloadSummary,
+    ScenarioRunListItem,
     ScenarioRunSummary,
     ScenarioTargetSummary,
 )
diff --git a/pyrit/memory/__init__.py b/pyrit/memory/__init__.py
index 2cd882eef5..e9aa9d2e15 100644
--- a/pyrit/memory/__init__.py
+++ b/pyrit/memory/__init__.py
@@ -22,7 +22,6 @@
         ScenarioHistoryKeysetCursor,
         ScenarioHistoryRunRecord,
         ScenarioHistoryUnitRecord,
-        ScenarioProgressKeysetCursor,
         ScenarioRunStateRecord,
     )
     from pyrit.memory.memory_models import AttackResultEntry, EmbeddingDataEntry, PromptMemoryEntry, SeedEntry
@@ -66,7 +65,6 @@
     "ScenarioHistoryKeysetCursor": "pyrit.memory.memory_interface",
     "ScenarioHistoryRunRecord": "pyrit.memory.memory_interface",
     "ScenarioHistoryUnitRecord": "pyrit.memory.memory_interface",
-    "ScenarioProgressKeysetCursor": "pyrit.memory.memory_interface",
     "ScenarioRunStateRecord": "pyrit.memory.memory_interface",
     "PromptMemoryEntry": "pyrit.memory.memory_models",
     "SeedEntry": "pyrit.memory.memory_models",

From 6196b8a6cd100b1dec7cff6a1324d54cec640432 Mon Sep 17 00:00:00 2001
From: Roman Lutz <romanlutz13@gmail.com>
Date: Mon, 24 Aug 2026 18:50:38 -0700
Subject: [PATCH 05/12] TEST: Mock auth config in scenario E2E

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 frontend/e2e/scenario-history.spec.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/frontend/e2e/scenario-history.spec.ts b/frontend/e2e/scenario-history.spec.ts
index 21669515b7..941513dd20 100644
--- a/frontend/e2e/scenario-history.spec.ts
+++ b/frontend/e2e/scenario-history.spec.ts
@@ -210,6 +210,14 @@ async function mockScenarioAPIs(page: Page): Promise<ScenarioMocks> {
   let launchRequest: Record<string, unknown> | undefined;
   const estimateRequests: Record<string, unknown>[] = [];
 
+  await page.route(/\/api\/auth\/config(?:\?|$)/, async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({ clientId: "", tenantId: "", allowedGroupIds: "" }),
+    });
+  });
+
   await page.route(/\/api\/version(?:\?|$)/, async (route) => {
     await route.fulfill({
       status: 200,

From 41073fb58fe2c6947a6f9477b649aae6849a1933 Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Wed, 12 Aug 2026 03:52:24 -0700
Subject: [PATCH 06/12] FEAT: Add scenario configuration sizing

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 5d02c2d5-b499-4f78-a04d-03bffa750817
---
 frontend/e2e/api.spec.ts                      |   96 +-
 frontend/e2e/scenario-history.spec.ts         |   95 +-
 .../components/Parameters/ParameterField.tsx  |  153 +-
 .../Scenarios/ScenarioCatalog.test.tsx        |   26 +-
 .../Scenarios/ScenarioDetail.styles.ts        |   28 +
 .../Scenarios/ScenarioDetail.test.tsx         | 1812 +++++++++++++---
 .../components/Scenarios/ScenarioDetail.tsx   | 1889 ++++++++++-------
 .../Scenarios/ScenarioFlow.test.tsx           |   28 +-
 .../Scenarios/ScenarioRunEstimate.styles.ts   |  130 +-
 .../Scenarios/ScenarioRunEstimate.test.tsx    |  766 ++++++-
 .../Scenarios/ScenarioRunEstimate.tsx         |  566 ++++-
 .../Scenarios/scenarioAdaptiveCap.test.ts     |   42 +
 .../Scenarios/scenarioAdaptiveCap.ts          |   33 +
 .../Scenarios/scenarioDatasetCaps.test.ts     |   70 +
 .../Scenarios/scenarioDatasetCaps.ts          |   87 +
 .../Scenarios/scenarioRunEstimateAdapter.ts   |   64 +-
 .../Scenarios/scenarioTechniqueSets.test.ts   |   73 +
 frontend/src/services/api.test.ts             |   76 +-
 frontend/src/services/api.ts                  |   12 +-
 frontend/src/types/index.ts                   |   79 +-
 pyrit/analytics/technique_analysis.py         |  115 +-
 .../scenario_configuration_resolver.py        |   30 +-
 pyrit/backend/services/scenario_service.py    |   71 +-
 pyrit/models/__init__.py                      |    6 +
 pyrit/models/catalog/__init__.py              |   16 +
 pyrit/models/catalog/scenario.py              |  243 ++-
 .../registry/components/scenario_registry.py  |   52 +-
 pyrit/scenario/core/dataset_configuration.py  |  130 +-
 pyrit/scenario/core/scenario.py               |    9 +-
 pyrit/scenario/scenarios/adaptive/__init__.py |    6 +
 .../scenarios/adaptive/adaptive_scenario.py   |  129 +-
 .../scenario/scenarios/adaptive/dispatcher.py |   55 +-
 .../adaptive/selectors/epsilon_greedy.py      |   13 +-
 .../adaptive/selectors/technique_selector.py  |   15 +-
 .../scenarios/adaptive/technique_identity.py  |   72 +
 .../scenarios/adaptive/text_adaptive.py       |    5 +-
 pyrit/scenario/scenarios/airt/jailbreak.py    |   48 +-
 pyrit/scenario/scenarios/airt/psychosocial.py |    5 +-
 .../scenario/scenarios/garak/web_injection.py |    5 +-
 .../unit/analytics/test_technique_analysis.py |   85 +-
 .../unit/backend/test_scenario_run_service.py |   81 +-
 tests/unit/backend/test_scenario_service.py   |  261 ++-
 tests/unit/models/test_scenario_catalog.py    |  253 ++-
 tests/unit/registry/test_scenario_registry.py |  105 +-
 tests/unit/scenario/airt/test_jailbreak.py    |    9 +-
 .../core/test_dataset_configuration.py        |   99 +
 .../scenarios/adaptive/test_dispatcher.py     |   41 +-
 .../scenarios/adaptive/test_epsilon_greedy.py |   29 +-
 .../adaptive/test_technique_identity.py       |   23 +
 .../scenarios/adaptive/test_text_adaptive.py  |  213 +-
 .../test_default_run_size_estimates.py        |  144 +-
 51 files changed, 6917 insertions(+), 1576 deletions(-)
 create mode 100644 frontend/src/components/Scenarios/scenarioAdaptiveCap.test.ts
 create mode 100644 frontend/src/components/Scenarios/scenarioAdaptiveCap.ts
 create mode 100644 frontend/src/components/Scenarios/scenarioDatasetCaps.test.ts
 create mode 100644 frontend/src/components/Scenarios/scenarioDatasetCaps.ts
 create mode 100644 frontend/src/components/Scenarios/scenarioTechniqueSets.test.ts
 create mode 100644 pyrit/scenario/scenarios/adaptive/technique_identity.py
 create mode 100644 tests/unit/scenario/scenarios/adaptive/test_technique_identity.py

diff --git a/frontend/e2e/api.spec.ts b/frontend/e2e/api.spec.ts
index d9a1670ef2..9b5556ef29 100644
--- a/frontend/e2e/api.spec.ts
+++ b/frontend/e2e/api.spec.ts
@@ -1,26 +1,31 @@
 import { test, expect } from "@playwright/test";
+import type { APIRequestContext } from "@playwright/test";
 
 // API tests go through the Vite dev server proxy (/api -> configured backend)
 // rather than hitting the backend directly, so they work as soon as
 // Playwright's webServer is ready.
 
-test.describe("API Health Check", () => {
-  // The backend may still be starting when Vite is already up.
-  // Poll the health endpoint through the proxy until the backend is ready.
-  test.beforeAll(async ({ request }) => {
-    const maxWait = 30_000;
-    const interval = 1_000;
-    const start = Date.now();
-    while (Date.now() - start < maxWait) {
-      try {
-        const resp = await request.get("/api/health", { timeout: 2_000 });
-        if (resp.ok()) return;
-      } catch {
-        // Backend not ready yet
+async function waitForBackend(request: APIRequestContext): Promise<void> {
+  const maxWait = 30_000;
+  const interval = 1_000;
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    try {
+      const response = await request.get("/api/health", { timeout: 2_000 });
+      if (response.ok()) {
+        return;
       }
-      await new Promise((r) => setTimeout(r, interval));
+    } catch {
+      // Backend not ready yet
     }
-    throw new Error("Backend did not become healthy within 30 seconds");
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  throw new Error("Backend did not become healthy within 30 seconds");
+}
+
+test.describe("API Health Check", () => {
+  test.beforeAll(async ({ request }) => {
+    await waitForBackend(request);
   });
 
   test("should have healthy backend API @seeded", async ({ request }) => {
@@ -38,24 +43,12 @@ test.describe("API Health Check", () => {
     const data = await response.json();
     expect(data).toBeDefined();
   });
+
 });
 
 test.describe("Targets API", () => {
   test.beforeAll(async ({ request }) => {
-    // Wait for backend readiness
-    const maxWait = 30_000;
-    const interval = 1_000;
-    const start = Date.now();
-    while (Date.now() - start < maxWait) {
-      try {
-        const resp = await request.get("/api/health", { timeout: 2_000 });
-        if (resp.ok()) return;
-      } catch {
-        // Backend not ready yet
-      }
-      await new Promise((r) => setTimeout(r, interval));
-    }
-    throw new Error("Backend did not become healthy within 30 seconds");
+    await waitForBackend(request);
   });
 
   test("should list targets @seeded", async ({ request }) => {
@@ -103,19 +96,7 @@ test.describe("Targets API", () => {
 
 test.describe("Attacks API", () => {
   test.beforeAll(async ({ request }) => {
-    const maxWait = 30_000;
-    const interval = 1_000;
-    const start = Date.now();
-    while (Date.now() - start < maxWait) {
-      try {
-        const resp = await request.get("/api/health", { timeout: 2_000 });
-        if (resp.ok()) return;
-      } catch {
-        // Backend not ready yet
-      }
-      await new Promise((r) => setTimeout(r, interval));
-    }
-    throw new Error("Backend did not become healthy within 30 seconds");
+    await waitForBackend(request);
   });
 
   test("should list attacks @seeded", async ({ request }) => {
@@ -124,6 +105,37 @@ test.describe("Attacks API", () => {
   });
 });
 
+test.describe("Scenarios API", () => {
+  test.beforeAll(async ({ request }) => {
+    await waitForBackend(request);
+  });
+
+  test("should expose scenario catalog details and queue state @seeded", async ({ request }) => {
+    test.setTimeout(90_000);
+    const catalogResponse = await request.get("/api/scenarios/catalog?limit=200");
+    expect(catalogResponse.ok()).toBe(true);
+    const catalog = await catalogResponse.json();
+    expect(catalog.items.length).toBeGreaterThan(0);
+
+    const scenarioName = catalog.items[0].scenario_name as string;
+    const detailResponse = await request.get(`/api/scenarios/catalog/${encodeURIComponent(scenarioName)}`);
+    expect(detailResponse.ok()).toBe(true);
+    const detail = await detailResponse.json();
+    expect(detail.scenario_name).toBe(scenarioName);
+    expect(detail.dataset_size_limit).toEqual(expect.objectContaining({
+      default_scope: expect.any(String),
+      override_scope: expect.any(String),
+    }));
+
+    const queueResponse = await request.get("/api/scenarios/runs/queue");
+    expect(queueResponse.ok()).toBe(true);
+    await expect(queueResponse.json()).resolves.toEqual(expect.objectContaining({
+      revision: expect.any(Number),
+      queued: expect.any(Array),
+    }));
+  });
+});
+
 test.describe("Error Handling", () => {
   test("should display UI when backend is slow", async ({ page }) => {
     // Intercept and delay API calls
diff --git a/frontend/e2e/scenario-history.spec.ts b/frontend/e2e/scenario-history.spec.ts
index 941513dd20..b8216454ed 100644
--- a/frontend/e2e/scenario-history.spec.ts
+++ b/frontend/e2e/scenario-history.spec.ts
@@ -36,6 +36,9 @@ const configuredEstimate = {
   version: 1,
   status: "exact",
   total_attack_count: 8,
+  minimum_attack_count: 8,
+  maximum_attack_count: 8,
+  condition: null,
   components: [{
     label: "Prompt sending",
     count: 8,
@@ -49,6 +52,7 @@ const configuredEstimate = {
     note: null,
   }],
   datasets: [datasetSummary],
+  adaptive_details: null,
   note: "The backend total is authoritative.",
   retries_included: false,
 };
@@ -68,7 +72,11 @@ const catalogScenario = {
   },
   all_techniques: ["prompt_sending", "jailbreak_system_prompt", "flip"],
   default_datasets: ["harmbench"],
-  default_dataset_summaries: [datasetSummary],
+  dataset_size_limit: {
+    default_scope: "per_dataset",
+    default_count: 4,
+    override_scope: "per_dataset",
+  },
   baseline_policy: "enabled",
   include_baseline_by_default: false,
   supported_parameters: [
@@ -104,6 +112,9 @@ const catalogScenario = {
     version: 1,
     status: "exact",
     total_attack_count: 16,
+    minimum_attack_count: 16,
+    maximum_attack_count: 16,
+    condition: null,
     components: [{
       label: "Default attacks",
       count: 16,
@@ -116,6 +127,7 @@ const catalogScenario = {
       note: null,
     }],
     datasets: [datasetSummary],
+    adaptive_details: null,
     note: "Retries and internal turns are excluded.",
     retries_included: false,
   },
@@ -197,6 +209,8 @@ const progressAttempt = {
   timestamp: "2026-08-07T00:00:30Z",
   total_retries: 1,
   retries: [],
+  result_kind: "attack",
+  technique_name: "prompt_sending",
 };
 
 interface ScenarioMocks {
@@ -244,6 +258,14 @@ async function mockScenarioAPIs(page: Page): Promise<ScenarioMocks> {
     });
   });
 
+  await page.route(/\/api\/datasets(?:\?|$)/, async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({ items: [{ name: "harmbench" }] }),
+    });
+  });
+
   await page.route(new RegExp(`/api/scenarios/catalog/${SCENARIO_NAME.replace(".", "\\.")}/estimate$`), async (route) => {
     const request = route.request().postDataJSON() as Record<string, unknown>;
     estimateRequests.push(request);
@@ -404,15 +426,20 @@ async function mockScenarioAPIs(page: Page): Promise<ScenarioMocks> {
 
 async function configurePromptSendingRun(page: Page): Promise<void> {
   await expect(page.getByTestId("scenario-target-select")).toHaveValue("test-target");
-  await page.getByTestId("technique-prompt_sending").click();
+  await page.getByTestId("technique-mode-custom").click();
+  await expect(page.getByTestId("technique-prompt_sending")).toBeChecked();
+  await expect(page.getByTestId("technique-jailbreak_system_prompt")).toBeChecked();
+  await page.getByTestId("technique-jailbreak_system_prompt").click();
   await page.getByTestId("scenario-param-num_jailbreaks").fill("2");
   await page.getByTestId("scenario-param-num_jailbreak_attempts").fill("1");
   await expect(page.getByTestId("baseline-checkbox")).not.toBeChecked();
-  await expect(page.getByText("8 planned attacks")).toBeVisible();
+  await expect(page.getByRole("group", {
+    name: "1 technique multiplied by 4 objectives multiplied by 2 jailbreak templates multiplied by 1 attempt equals 8 planned attacks.",
+  })).toBeVisible();
 }
 
 test.describe("Scenario catalog, history, and live run routing", () => {
-  test("renders the semantic catalog, full metadata, safe MyST, and both sidebar destinations", async ({ page }) => {
+  test("opens the Configure page from the semantic launch index with complete safe metadata", async ({ page }) => {
     await mockScenarioAPIs(page);
     await page.goto("/scanner");
 
@@ -431,17 +458,53 @@ test.describe("Scenario catalog, history, and live run routing", () => {
     ]);
     await expect(page.getByTitle("Scenarios")).toHaveAttribute("aria-current", "page");
     await expect(page.getByRole("table", { name: "Registered scenarios" })).toBeVisible();
-    await expect(page.getByRole("columnheader", { name: "Default run size" })).toBeVisible();
+    await expect(page.getByRole("columnheader")).toHaveText([
+      "Scenario / purpose",
+      "Configure",
+      "Default dataset size",
+      "Default techniques",
+      "Default run size",
+    ]);
 
     const row = page.getByTestId(`scenario-card-${SCENARIO_NAME}`);
-    await row.getByRole("button", { name: "Configure run" }).click();
+    const cells = row.getByRole("cell");
+    await expect(cells).toHaveCount(5);
+    const configureButton = cells.nth(1).getByRole("button", { name: "Configure run" });
+    await expect(configureButton).toBeVisible();
+    const [scenarioCellBox, configureCellBox, datasetCellBox] = await Promise.all([
+      cells.nth(0).boundingBox(),
+      cells.nth(1).boundingBox(),
+      cells.nth(2).boundingBox(),
+    ]);
+    expect(scenarioCellBox).not.toBeNull();
+    expect(configureCellBox).not.toBeNull();
+    expect(datasetCellBox).not.toBeNull();
+    expect(configureCellBox!.x).toBeGreaterThan(scenarioCellBox!.x);
+    expect(configureCellBox!.x).toBeLessThan(datasetCellBox!.x);
+    await expect(page.getByRole("button", { name: /show details|hide details/i })).toHaveCount(0);
+
+    await configureButton.click();
     await expect(page).toHaveURL(`/scanner/${SCENARIO_NAME}`);
     await expect(page.getByRole("heading", { name: SCENARIO_NAME, level: 1 })).toBeVisible();
+    await expect(page.getByText("Jailbreak · v4")).toBeVisible();
     const description = page.getByTestId("scenario-detail-description");
     await expect(description.getByText("dataset")).toHaveCSS("font-weight", /^(600|700)$/);
     await expect(description.locator("code").filter({ hasText: "num_jailbreaks" })).toBeVisible();
     await expect(description.locator("img")).toHaveCount(0);
     await expect(description).toContainText(RAW_IMAGE_HTML);
+    await expect(page.getByRole("radio", { name: /Recommended \(default\).*2 techniques/ })).toBeChecked();
+    await expect(page.getByRole("radio", { name: /Easy.*1 technique/ })).toBeVisible();
+    await expect(page.getByRole("radio", { name: "Custom" })).toBeVisible();
+    const members = page.getByTestId("selected-technique-set-members");
+    await expect(members.getByText("prompt_sending")).toBeVisible();
+    await expect(members.getByText("jailbreak_system_prompt")).toBeVisible();
+    const preview = page.getByRole("complementary", { name: "Run preview" });
+    await expect(preview.getByText("Jailbreak templates: 2")).toBeVisible();
+    await expect(preview.getByRole("group", {
+      name: "2 techniques multiplied by 4 objectives multiplied by 2 jailbreak templates equals 16 planned attacks.",
+    })).toBeVisible();
+    await expect(page.getByText("Include direct baseline comparison")).toBeVisible();
+    await expect(page.getByText(/Also send each selected objective directly/)).toBeVisible();
 
     await page.getByTitle("Scenario History").click();
     await expect(page).toHaveURL("/scenario-history");
@@ -479,7 +542,9 @@ test.describe("Scenario catalog, history, and live run routing", () => {
       const requests = mocks.getEstimateRequests();
       return requests[requests.length - 1];
     }).toEqual(expectedEstimateRequest);
-    await expect(preview.getByText("Prompt sending: 2 jailbreak templates × 4 selected seed groups × 1 concrete techniques × 1 attempts = 8")).toBeVisible();
+    await expect(preview.getByRole("group", {
+      name: "1 technique multiplied by 4 objectives multiplied by 2 jailbreak templates multiplied by 1 attempt equals 8 planned attacks.",
+    })).toBeVisible();
     await expect(preview).not.toContainText("context_compliance");
 
     await page.getByTestId("launch-scenario-btn").click();
@@ -516,7 +581,21 @@ test.describe("Scenario catalog, history, and live run routing", () => {
     const client = await page.context().newCDPSession(page);
     await client.send("Emulation.setTouchEmulationEnabled", { enabled: true, maxTouchPoints: 1 });
     await page.setViewportSize({ width: 390, height: 844 });
-    await page.goto(`/scanner/${SCENARIO_NAME}`);
+    await page.goto("/scanner");
+    const catalogRow = page.getByTestId(`scenario-card-${SCENARIO_NAME}`);
+    const configureButton = catalogRow.getByRole("button", { name: "Configure run" });
+    await expect(catalogRow).toBeVisible();
+    expect(await catalogRow.getByRole("cell").allInnerTexts()).toEqual([
+      expect.stringContaining("Scenario / purpose"),
+      expect.stringContaining("Configure"),
+      expect.stringContaining("Default dataset size"),
+      expect.stringContaining("Default techniques"),
+      expect.stringContaining("Default run size"),
+    ]);
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBeLessThanOrEqual(390);
+    expect((await configureButton.boundingBox())?.height).toBeGreaterThanOrEqual(44);
+    await configureButton.press("Enter");
+    await expect(page).toHaveURL(`/scanner/${SCENARIO_NAME}`);
     await configurePromptSendingRun(page);
 
     const formBox = await page.getByRole("form", { name: "Scenario run configuration" }).boundingBox();
diff --git a/frontend/src/components/Parameters/ParameterField.tsx b/frontend/src/components/Parameters/ParameterField.tsx
index efe5fac2ae..3ab4d0ced2 100644
--- a/frontend/src/components/Parameters/ParameterField.tsx
+++ b/frontend/src/components/Parameters/ParameterField.tsx
@@ -1,8 +1,11 @@
+import { type ClipboardEvent, type KeyboardEvent, useRef } from 'react'
+
 import {
   Checkbox,
   Field,
   Input,
   Select,
+  type FieldProps,
 } from '@fluentui/react-components'
 
 import type { Parameter } from '@/types'
@@ -15,10 +18,27 @@ export interface ParameterFieldProps {
   value: ParameterFormValue
   disabled: boolean
   onChange: (name: string, value: ParameterFormValue) => void
+  displayLabel?: string
+  displayHint?: string
+  validationState?: FieldProps['validationState']
+  validationMessage?: string
+  numberMin?: number
+  numberMax?: number
+  numberStep?: number
+  numberWholeOnly?: boolean
+  onRejectedNumberInput?: (
+    name: string,
+    reason: RejectedNumberInputReason,
+    retainedValue: string,
+  ) => void
   /** Prefix for `data-testid` attributes. Defaults to `'param'` (e.g. `param-<name>`). */
   testIdPrefix?: string
 }
 
+export type RejectedNumberInputReason = 'format' | 'below-min' | 'above-max'
+
+const BLOCKED_WHOLE_NUMBER_KEYS = new Set(['-', '+', '.', 'e', 'E'])
+
 /**
  * Renders the appropriate Fluent UI control for a declared {@link Parameter},
  * driven by {@link getParameterControlKind}. Shared by every dynamic
@@ -34,17 +54,30 @@ export default function ParameterField({
   value,
   disabled,
   onChange,
+  displayLabel,
+  displayHint,
+  validationState,
+  validationMessage,
+  numberMin,
+  numberMax,
+  numberStep,
+  numberWholeOnly = false,
+  onRejectedNumberInput,
   testIdPrefix = 'param',
 }: ParameterFieldProps) {
   const styles = useParameterFieldStyles()
+  const rejectedNumberSequenceRef = useRef(false)
+  const editSessionStartValueRef = useRef('')
   const kind = getParameterControlKind(parameter)
-  const label = parameter.required ? `${parameter.name} *` : parameter.name
+  const baseLabel = displayLabel ?? parameter.name
+  const label = parameter.required ? `${baseLabel} *` : baseLabel
+  const fieldHint = displayHint ?? parameter.description ?? undefined
   const testId = `${testIdPrefix}-${parameter.name}`
 
   if (kind === 'boolean') {
     const current = value === 'true' || value === 'false' ? value : ''
     return (
-      <Field label={label} hint={parameter.description ?? undefined}>
+      <Field label={label} hint={fieldHint}>
         <Select
           className={styles.control}
           value={current}
@@ -63,7 +96,7 @@ export default function ParameterField({
   if (kind === 'multiselect') {
     const selected = Array.isArray(value) ? value : []
     return (
-      <Field label={label} hint={parameter.description ?? undefined}>
+      <Field label={label} hint={fieldHint}>
         <div className={styles.checkboxGroup} role="group" aria-labelledby={`${testId}-group-label`}>
           <span id={`${testId}-group-label`} className={styles.srOnly}>
             {label}
@@ -99,7 +132,7 @@ export default function ParameterField({
 
   if (kind === 'select') {
     return (
-      <Field label={label} hint={parameter.description ?? undefined}>
+      <Field label={label} hint={fieldHint}>
         <Select
           className={styles.control}
           value={stringValue}
@@ -119,18 +152,122 @@ export default function ParameterField({
   }
 
   const placeholder = typeof parameter.default === 'string' ? parameter.default : undefined
-  const hint =
-    parameter.description ?? (kind === 'list' ? 'Comma-separated list of values.' : parameter.type_name)
+  const hint = fieldHint ?? (kind === 'list' ? 'Comma-separated list of values.' : parameter.type_name)
+  const rejectNumberInput = (
+    reason: RejectedNumberInputReason,
+    retainedValue: string,
+  ): void => {
+    rejectedNumberSequenceRef.current = reason !== 'above-max'
+    if (reason === 'above-max' && numberMax !== undefined) {
+      editSessionStartValueRef.current = String(numberMax)
+    }
+    onRejectedNumberInput?.(parameter.name, reason, retainedValue)
+  }
+  const handleNumberKeyDown = (event: KeyboardEvent<HTMLInputElement>): void => {
+    if (!numberWholeOnly) {
+      return
+    }
+    if (event.key === 'Backspace' || event.key === 'Delete') {
+      rejectedNumberSequenceRef.current = false
+      return
+    }
+    if (
+      event.key === 'ArrowDown'
+      && numberMin !== undefined
+      && Number(stringValue) <= numberMin
+    ) {
+      event.preventDefault()
+      event.stopPropagation()
+      return
+    }
+    if (
+      event.key === 'ArrowUp'
+      && numberMax !== undefined
+      && Number(stringValue) >= numberMax
+    ) {
+      event.preventDefault()
+      event.stopPropagation()
+      return
+    }
+    if (BLOCKED_WHOLE_NUMBER_KEYS.has(event.key)) {
+      event.preventDefault()
+      event.stopPropagation()
+      rejectNumberInput('format', editSessionStartValueRef.current)
+      return
+    }
+    if (rejectedNumberSequenceRef.current && event.key.length === 1) {
+      event.preventDefault()
+      event.stopPropagation()
+    }
+  }
+  const handleNumberPaste = (event: ClipboardEvent<HTMLInputElement>): void => {
+    if (!numberWholeOnly) {
+      return
+    }
+    const pastedValue = event.clipboardData.getData('text')
+    if (!/^\d+$/.test(pastedValue)) {
+      event.preventDefault()
+      rejectNumberInput('format', stringValue)
+      return
+    }
+    if (numberMax !== undefined && Number(pastedValue) > numberMax) {
+      event.preventDefault()
+      rejectNumberInput('above-max', stringValue)
+      return
+    }
+    if (numberMin !== undefined && Number(pastedValue) < numberMin) {
+      event.preventDefault()
+      rejectNumberInput('below-min', stringValue)
+    }
+  }
+  const handleInputChange = (nextValue: string): void => {
+    if (numberWholeOnly && nextValue !== '' && !/^\d+$/.test(nextValue)) {
+      rejectNumberInput('format', stringValue)
+      return
+    }
+    if (numberMax !== undefined && nextValue !== '' && Number(nextValue) > numberMax) {
+      rejectNumberInput('above-max', stringValue)
+      return
+    }
+    if (numberMin !== undefined && nextValue !== '' && Number(nextValue) < numberMin) {
+      rejectNumberInput('below-min', stringValue)
+      return
+    }
+    rejectedNumberSequenceRef.current = false
+    if (nextValue === '') {
+      editSessionStartValueRef.current = ''
+    }
+    onChange(parameter.name, nextValue)
+  }
 
   return (
-    <Field label={label} hint={hint}>
+    <Field
+      label={label}
+      hint={hint}
+      validationState={validationState}
+      validationMessage={validationMessage}
+    >
       <Input
         className={styles.control}
         value={stringValue}
         type={kind === 'number' ? 'number' : 'text'}
+        min={kind === 'number' ? numberMin : undefined}
+        max={kind === 'number' ? numberMax : undefined}
+        step={kind === 'number' ? numberStep : undefined}
+        inputMode={kind === 'number' && numberWholeOnly ? 'numeric' : undefined}
+        pattern={kind === 'number' && numberWholeOnly ? '[0-9]*' : undefined}
+        aria-invalid={validationState === 'error'}
         placeholder={placeholder}
         disabled={disabled}
-        onChange={(_, data) => onChange(parameter.name, data.value)}
+        onKeyDown={kind === 'number' ? handleNumberKeyDown : undefined}
+        onPaste={kind === 'number' ? handleNumberPaste : undefined}
+        onFocus={() => {
+          editSessionStartValueRef.current = stringValue
+        }}
+        onBlur={() => {
+          rejectedNumberSequenceRef.current = false
+        }}
+        onChange={(_, data) => handleInputChange(data.value)}
         data-testid={testId}
       />
     </Field>
diff --git a/frontend/src/components/Scenarios/ScenarioCatalog.test.tsx b/frontend/src/components/Scenarios/ScenarioCatalog.test.tsx
index 011a09dfc9..abdc788faf 100644
--- a/frontend/src/components/Scenarios/ScenarioCatalog.test.tsx
+++ b/frontend/src/components/Scenarios/ScenarioCatalog.test.tsx
@@ -544,31 +544,49 @@ describe('ScenarioCatalog', () => {
     expect(within(row).getByText('population-a · population-b')).toBeInTheDocument()
   })
 
-  it('shows an adaptive estimate as a plain attack range', async () => {
+  it('shows adaptive planned attacks together with the technique attempt bound', async () => {
     mockListCatalog.mockResolvedValue({
       items: [
         makeScenario({
           scenario_name: 'adaptive.text_adaptive',
           default_run_size: {
-            estimated_attack_count: null,
+            version: 1,
+            status: 'conditional',
+            total_attack_count: null,
             minimum_attack_count: 21,
             maximum_attack_count: 42,
+            condition: 'target_capabilities',
             components: [
               {
                 label: 'Baseline',
                 count: 21,
+                factors: [{ label: 'objectives', count: 21 }],
                 is_baseline: true,
+                condition: null,
                 note: null,
               },
               {
                 label: 'Adaptive objectives',
                 count: 21,
+                factors: [{ label: 'compatible objectives', count: 21 }],
                 is_baseline: false,
+                condition: null,
                 note: null,
               },
             ],
             datasets: [],
+            adaptive_details: {
+              objective_count: 21,
+              selected_candidate_technique_count: 2,
+              candidate_technique_count: 2,
+              max_attempts_per_objective: 3,
+              techniques_per_objective_upper_bound: 2,
+              technique_attempt_count_upper_bound: 42,
+              stop_on_first_success: true,
+              compatibility_may_reduce_attempts: true,
+            },
             note: null,
+            retries_included: false,
           },
         }),
       ],
@@ -578,8 +596,8 @@ describe('ScenarioCatalog', () => {
     render(<TestWrapper><ScenarioCatalog /></TestWrapper>)
 
     const row = await screen.findByTestId('scenario-card-adaptive.text_adaptive')
-    expect(within(row).getByText('21-42 attacks')).toBeInTheDocument()
-    expect(within(row).queryByText(/progress units|attack attempts/i)).not.toBeInTheDocument()
+    expect(within(row).getByText('21–42 planned attacks · up to 42 technique attempts')).toBeInTheDocument()
+    expect(within(row).queryByText(/objective envelope/i)).not.toBeInTheDocument()
   })
 
   it('keeps declared datasets visible when backend population summaries are unavailable', async () => {
diff --git a/frontend/src/components/Scenarios/ScenarioDetail.styles.ts b/frontend/src/components/Scenarios/ScenarioDetail.styles.ts
index 9e0e9e21af..7cebe6f8a4 100644
--- a/frontend/src/components/Scenarios/ScenarioDetail.styles.ts
+++ b/frontend/src/components/Scenarios/ScenarioDetail.styles.ts
@@ -38,6 +38,9 @@ export const useScenarioDetailStyles = makeStyles({
     flexDirection: 'column',
     gap: tokens.spacingVerticalXS,
   },
+  scenarioMetadata: {
+    color: tokens.colorNeutralForeground3,
+  },
   description: {
     color: tokens.colorNeutralForeground3,
     fontSize: tokens.fontSizeBase200,
@@ -64,6 +67,9 @@ export const useScenarioDetailStyles = makeStyles({
   },
   control: {
     ...mobileTouchTargetHeight,
+    width: '100%',
+    minWidth: 0,
+    maxWidth: '100%',
     '& > select': {
       [TOUCH_INPUT_QUERY]: {
         minHeight: MINIMUM_TOUCH_TARGET_SIZE,
@@ -110,6 +116,28 @@ export const useScenarioDetailStyles = makeStyles({
   techniqueTag: {
     ...mobileTouchTarget,
   },
+  datasetPickerHeader: {
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    flexWrap: 'wrap',
+    gap: tokens.spacingHorizontalM,
+  },
+  datasetList: {
+    display: 'flex',
+    flexDirection: 'column',
+    gap: tokens.spacingVerticalXXS,
+    maxHeight: '18rem',
+    overflowY: 'auto',
+    padding: `${tokens.spacingVerticalXS} ${tokens.spacingHorizontalS}`,
+    border: `1px solid ${tokens.colorNeutralStroke2}`,
+    borderRadius: tokens.borderRadiusMedium,
+    backgroundColor: tokens.colorNeutralBackground1,
+  },
+  datasetEmptyState: {
+    padding: tokens.spacingVerticalM,
+    color: tokens.colorNeutralForeground3,
+  },
   hint: {
     color: tokens.colorNeutralForeground3,
   },
diff --git a/frontend/src/components/Scenarios/ScenarioDetail.test.tsx b/frontend/src/components/Scenarios/ScenarioDetail.test.tsx
index f60bed57d6..9025883ce5 100644
--- a/frontend/src/components/Scenarios/ScenarioDetail.test.tsx
+++ b/frontend/src/components/Scenarios/ScenarioDetail.test.tsx
@@ -3,10 +3,11 @@ import userEvent from '@testing-library/user-event'
 import { FluentProvider, webLightTheme } from '@fluentui/react-components'
 import { MemoryRouter, Route, Routes } from 'react-router'
 
-import { scenariosApi, targetsApi } from '@/services/api'
+import { datasetsApi, scenariosApi, targetsApi } from '@/services/api'
 import type {
   RegisteredScenario,
-  ScenarioRunSizeEstimateResponse,
+  ScenarioDefaultRunSizeEstimate,
+  ScenarioRunSizeEstimateRequest,
   TargetInstance,
 } from '@/types'
 
@@ -21,12 +22,24 @@ jest.mock('@/services/api', () => ({
   targetsApi: {
     listTargets: jest.fn(),
   },
+  datasetsApi: {
+    listDatasets: jest.fn(),
+  },
 }))
 
 const mockGetScenario = scenariosApi.getScenario as jest.Mock
 const mockEstimateRun = scenariosApi.estimateRun as jest.Mock
 const mockStartRun = scenariosApi.startRun as jest.Mock
 const mockListTargets = targetsApi.listTargets as jest.Mock
+const mockListDatasets = datasetsApi.listDatasets as jest.Mock
+const REMOVED_NORMAL_ESTIMATE_LABELS = new RegExp(
+  [
+    ['Run', 'size', 'calculated'].join(' '),
+    ['Final', 'count', 'set', 'at', 'launch'].join(' '),
+  ].join('|'),
+  'i',
+)
+const CORRECT_HIGHLIGHTED_SETTING_MESSAGE = 'Correct the highlighted setting to calculate this run.'
 
 const mockNavigate = jest.fn()
 const RAW_IMAGE_HTML = ['<', 'img src=x onerror="alert(1)">'].join('')
@@ -38,16 +51,10 @@ jest.mock('react-router', () => ({
 
 function makeScenario(overrides: Partial<RegisteredScenario> = {}): RegisteredScenario {
   const description = overrides.description ?? 'Red teams a target.'
-  const defaultTechnique = overrides.default_technique ?? 'default'
-  const aggregateTechniques = overrides.aggregate_techniques ?? ['all', 'default']
+  const defaultTechnique = overrides.default_technique ?? 'default_technique'
+  const aggregateTechniques = overrides.aggregate_techniques ?? ['default_technique']
   const defaultTechniques = overrides.default_techniques
-    ?? (aggregateTechniques.includes(defaultTechnique) ? ['default_technique'] : [defaultTechnique])
-  const allTechniques = overrides.all_techniques ?? ['default_technique', 'crescendo']
-  const techniqueSummaries = overrides.technique_summaries ?? allTechniques.map((name) => ({
-    name,
-    description: `${name} description.`,
-    tags: name === 'default_technique' ? ['default', 'single_turn'] : ['multi_turn'],
-  }))
+    ?? (aggregateTechniques.includes(defaultTechnique) ? ['crescendo'] : [defaultTechnique])
   return {
     scenario_name: 'foundry.red_team_agent',
     scenario_type: 'RedTeamAgentScenario',
@@ -56,17 +63,29 @@ function makeScenario(overrides: Partial<RegisteredScenario> = {}): RegisteredSc
       ?? Object.fromEntries(
         aggregateTechniques.map((name) => [name, name === defaultTechnique ? defaultTechniques : []]),
       ),
-    all_techniques: allTechniques,
-    technique_summaries: techniqueSummaries,
+    all_techniques: ['default_technique', 'crescendo'],
+    technique_summaries: [],
     default_datasets: ['harmbench'],
+    dataset_size_limit: {
+      default_scope: 'none',
+      default_count: null,
+      override_scope: 'per_dataset',
+    },
     baseline_policy: 'enabled',
     include_baseline_by_default: true,
     supported_parameters: [],
     default_run_size: {
-      estimated_attack_count: null,
+      version: 1,
+      status: 'unavailable',
+      total_attack_count: null,
+      minimum_attack_count: null,
+      maximum_attack_count: null,
+      condition: null,
       components: [],
       datasets: [],
+      adaptive_details: null,
       note: 'Default sizing is unavailable.',
+      retries_included: false,
     },
     ...overrides,
     description,
@@ -77,35 +96,150 @@ function makeScenario(overrides: Partial<RegisteredScenario> = {}): RegisteredSc
   }
 }
 
-function makeTarget(name: string, modelName?: string): TargetInstance {
+function makeTarget(name: string): TargetInstance {
   return {
     target_registry_name: name,
-    identifier: {
-      class_name: 'OpenAIChatTarget',
-      hash: `${name}-hash`,
-      model_name: modelName,
-    },
+    identifier: { class_name: 'OpenAIChatTarget', hash: `${name}-hash` },
   }
 }
 
-function makeEstimate(total: number | null): ScenarioRunSizeEstimateResponse {
+function makeEstimate(
+  total: number | null,
+  status: ScenarioDefaultRunSizeEstimate['status'] = total === null ? 'conditional' : 'exact',
+): ScenarioDefaultRunSizeEstimate {
   return {
-    estimated_attack_count: total,
-    minimum_attack_count: total === null ? 8 : null,
-    maximum_attack_count: total === null ? 12 : null,
+    version: 1,
+    status,
+    total_attack_count: total,
+    minimum_attack_count: null,
+    maximum_attack_count: null,
+    condition: null,
     components: total === null
-      ? [{ label: 'Possible attacks', count: 12, is_baseline: false, note: null }]
+      ? []
       : [
           {
             label: 'Configured attacks',
             count: total,
+            factors: [],
             is_baseline: false,
             note: null,
           },
         ],
     datasets: [],
+    adaptive_details: null,
     note: null,
+    retries_included: false,
+  }
+}
+
+function makeAdaptiveScenario(): RegisteredScenario {
+  const defaultMembers = ['role_play_movie_script', 'many_shot']
+  const defaultDatasets = [
+    'airt_hate',
+    'airt_fairness',
+    'airt_violence',
+    'airt_sexual',
+    'airt_harassment',
+    'airt_misinformation',
+    'airt_leakage',
+  ]
+  const aggregateTechniqueExpansions = {
+    default: defaultMembers,
+    all: [...defaultMembers, ...Array.from({ length: 15 }, (_, index) => `all_member_${index + 1}`)],
+    core: Array.from({ length: 14 }, (_, index) => `core_member_${index + 1}`),
+    extra: Array.from({ length: 3 }, (_, index) => `extra_member_${index + 1}`),
+    light: Array.from({ length: 9 }, (_, index) => `light_member_${index + 1}`),
+    multi_turn: Array.from({ length: 5 }, (_, index) => `multi_turn_member_${index + 1}`),
+    single_turn: Array.from({ length: 12 }, (_, index) => `single_turn_member_${index + 1}`),
   }
+  return makeScenario({
+    scenario_name: 'adaptive.text_adaptive',
+    scenario_type: 'TextAdaptive',
+    default_technique: 'default',
+    default_techniques: defaultMembers,
+    default_datasets: defaultDatasets,
+    dataset_size_limit: {
+      default_scope: 'per_dataset',
+      default_count: 4,
+      override_scope: 'per_dataset',
+    },
+    aggregate_techniques: ['all', 'default', 'core', 'extra', 'light', 'multi_turn', 'single_turn'],
+    aggregate_technique_expansions: aggregateTechniqueExpansions,
+    all_techniques: [...new Set(Object.values(aggregateTechniqueExpansions).flat())],
+    supported_parameters: [
+      {
+        name: 'max_attempts_per_objective',
+        type_name: 'int',
+        required: false,
+        default: 3,
+        choices: null,
+        is_list: false,
+      },
+    ],
+  })
+}
+
+function makeAdaptiveEstimateForRequest(
+  scenario: RegisteredScenario,
+  request: ScenarioRunSizeEstimateRequest,
+): ScenarioDefaultRunSizeEstimate {
+  const selectedSet = request.techniques?.[0] ?? 'default'
+  const selectedCandidateCount = scenario.aggregate_technique_expansions[selectedSet]?.length ?? 0
+  const candidateCount = selectedSet === 'core' ? 5 : selectedCandidateCount
+  const configuredMax = Number(request.scenario_params?.max_attempts_per_objective ?? 3)
+  const perObjective = Math.min(candidateCount, configuredMax)
+  const includeBaseline = request.include_baseline !== false
+  return {
+    ...makeEstimate(null),
+    minimum_attack_count: includeBaseline ? 21 : null,
+    maximum_attack_count: includeBaseline ? 42 : 21,
+    components: [
+      ...(includeBaseline ? [{
+        label: 'Baseline',
+        count: 21,
+        factors: [{ label: 'objectives', count: 21 }],
+        is_baseline: true,
+        condition: null,
+        note: null,
+      }] : []),
+      {
+        label: 'Adaptive objectives',
+        count: 21,
+        factors: [{ label: 'compatible objectives', count: 21 }],
+        is_baseline: false,
+        condition: null,
+        note: null,
+      },
+    ],
+    adaptive_details: {
+      objective_count: 21,
+      selected_candidate_technique_count: selectedCandidateCount,
+      candidate_technique_count: candidateCount,
+      max_attempts_per_objective: configuredMax,
+      techniques_per_objective_upper_bound: perObjective,
+      technique_attempt_count_upper_bound: 21 * perObjective,
+      stop_on_first_success: true,
+      compatibility_may_reduce_attempts: true,
+    },
+  }
+}
+
+function makeFullyCompatibleAdaptiveEstimateForRequest(
+  scenario: RegisteredScenario,
+  request: ScenarioRunSizeEstimateRequest,
+): ScenarioDefaultRunSizeEstimate {
+  const estimate = makeAdaptiveEstimateForRequest(scenario, request)
+  const adaptiveDetails = estimate.adaptive_details
+  if (!adaptiveDetails) {
+    throw new Error('Expected Adaptive estimate details.')
+  }
+  const candidateCount = adaptiveDetails.selected_candidate_technique_count ?? 0
+  const configuredMaximum = adaptiveDetails.max_attempts_per_objective
+  adaptiveDetails.candidate_technique_count = candidateCount
+  adaptiveDetails.techniques_per_objective_upper_bound = Math.min(candidateCount, configuredMaximum)
+  adaptiveDetails.technique_attempt_count_upper_bound =
+    adaptiveDetails.objective_count * adaptiveDetails.techniques_per_objective_upper_bound
+  return estimate
 }
 
 async function flushRenderedPromises(): Promise<void> {
@@ -153,7 +287,7 @@ function renderDetail(
       <MemoryRouter initialEntries={[path]}>
         <Routes>
           <Route
-            path="/:catalog/:scenarioName"
+            path="/scenarios/:scenarioName"
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             element={<ScenarioDetail {...(merged as any)} />}
           />
@@ -169,11 +303,20 @@ describe('ScenarioDetail', () => {
     mockGetScenario.mockReset()
     mockEstimateRun.mockReset()
     mockListTargets.mockReset()
+    mockListDatasets.mockReset()
     mockStartRun.mockReset()
     mockListTargets.mockResolvedValue({
       items: [makeTarget('target-a'), makeTarget('target-b')],
       pagination: { limit: 200, has_more: false },
     })
+    mockListDatasets.mockResolvedValue({
+      items: [
+        { name: 'harmbench' },
+        { name: 'ds_a' },
+        { name: 'ds_b' },
+        { name: 'xstest' },
+      ],
+    })
     mockGetScenario.mockResolvedValue(makeScenario())
     mockEstimateRun.mockReturnValue(new Promise(() => {}))
     mockStartRun.mockResolvedValue({ scenario_result_id: 'sr-default' })
@@ -186,26 +329,24 @@ describe('ScenarioDetail', () => {
   it('shows a loading state while fetching', () => {
     mockGetScenario.mockReturnValue(new Promise(() => {}))
     mockListTargets.mockReturnValue(new Promise(() => {}))
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     expect(screen.getByText('Loading scenario...')).toBeInTheDocument()
   })
 
   it('decodes the scenario name from the URL exactly once', async () => {
-    renderDetail('/scanner/foundry.red_team_agent');
+    renderDetail('/scenarios/foundry.red_team_agent');
     await screen.findByTestId('scenario-target-select')
     expect(mockGetScenario).toHaveBeenCalledWith('foundry.red_team_agent')
   })
 
   it('decodes a slash-bearing encoded scenario name back to the original', async () => {
-    renderDetail('/scanner/foundry%2Fred_team_agent')
+    renderDetail('/scenarios/foundry%2Fred_team_agent')
     await waitFor(() => expect(mockGetScenario).toHaveBeenCalledWith('foundry/red_team_agent'))
-    await screen.findByTestId('scenario-target-select')
   })
 
   it('preserves a literal percent sequence in a scenario registry name', async () => {
-    renderDetail('/scanner/discount%2550')
+    renderDetail('/scenarios/discount%2550')
     await waitFor(() => expect(mockGetScenario).toHaveBeenCalledWith('discount%50'))
-    await screen.findByTestId('scenario-target-select')
   })
 
   it('handles a malformed percent sequence without throwing during render', async () => {
@@ -214,7 +355,7 @@ describe('ScenarioDetail', () => {
       isAxiosError: true,
       response: { status: 404, data: { detail: 'not found' } },
     })
-    renderDetail('/scanner/%zz')
+    renderDetail('/scenarios/%zz')
     expect(await screen.findByTestId('scenario-not-found')).toBeInTheDocument()
     expect(mockGetScenario).toHaveBeenCalledWith('%zz')
     consoleWarn.mockRestore()
@@ -226,10 +367,10 @@ describe('ScenarioDetail', () => {
       response: { status: 404, data: { detail: 'not found' } },
     })
 
-    renderDetail('/scanner/missing.scenario')
+    renderDetail('/scenarios/missing.scenario')
 
     expect(await screen.findByTestId('scenario-not-found')).toBeInTheDocument()
-    expect(screen.getByRole('link', { name: /back to scanners/i })).toHaveAttribute('href', '/scanner')
+    expect(screen.getByRole('link', { name: /back to scenarios/i })).toHaveAttribute('href', '/scenarios')
     expect(screen.queryByTestId('scenario-error')).not.toBeInTheDocument()
   })
 
@@ -239,7 +380,7 @@ describe('ScenarioDetail', () => {
       .mockRejectedValueOnce({ isAxiosError: true, response: { status: 500, data: { detail: 'boom' } } })
       .mockResolvedValueOnce(makeScenario())
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
 
     expect(await screen.findByTestId('scenario-error')).toBeInTheDocument()
     expect(screen.getByText('boom')).toBeInTheDocument()
@@ -253,11 +394,8 @@ describe('ScenarioDetail', () => {
     jest.useFakeTimers()
     const onNavigate = jest.fn()
     mockListTargets.mockResolvedValueOnce({ items: [], pagination: { limit: 200, has_more: false } })
-    mockEstimateRun.mockResolvedValueOnce(makeEstimate(8))
 
-    renderDetail('/scanner/foundry.red_team_agent', { onNavigate })
-    await flushRenderedPromises()
-    await advanceTimers(300)
+    renderDetail('/scenarios/foundry.red_team_agent', { onNavigate })
 
     expect(screen.getByTestId('scenario-target-select')).toHaveValue('')
     expect(mockEstimateRun).toHaveBeenCalledWith(
@@ -274,52 +412,28 @@ describe('ScenarioDetail', () => {
   })
 
   it('defaults the target selector to the active target when it is among the fetched targets', async () => {
-    renderDetail('/scanner/foundry.red_team_agent', { activeTarget: makeTarget('target-b') })
+    renderDetail('/scenarios/foundry.red_team_agent', { activeTarget: makeTarget('target-b') })
 
     expect(await screen.findByTestId('scenario-target-select')).toHaveValue('target-b')
   })
 
-  it('shows model names in target options without another request', async () => {
-    mockListTargets.mockResolvedValueOnce({
-      items: [makeTarget('target-a', 'gpt-4o'), makeTarget('target-b')],
-      pagination: { limit: 200, has_more: false },
-    })
-
-    renderDetail('/scanner/foundry.red_team_agent')
-
-    expect(await screen.findByRole('option', { name: 'target-a (gpt-4o)' })).toBeInTheDocument()
-    expect(screen.getByRole('option', { name: 'target-b' })).toBeInTheDocument()
-    expect(mockListTargets).toHaveBeenCalledTimes(1)
-  })
-
   it('defaults the target selector to the first fetched target when there is no matching active target', async () => {
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
 
     expect(await screen.findByTestId('scenario-target-select')).toHaveValue('target-a')
   })
 
-  it('shows the configuration, estimate, and launch sections before the preview dialog', async () => {
-    const user = userEvent.setup()
-    renderDetail('/scanner/foundry.red_team_agent')
+  it('exposes the configuration form and run preview as ordered landmarks', async () => {
+    renderDetail('/scenarios/foundry.red_team_agent')
 
     expect(await screen.findByRole('form', { name: 'Scenario run configuration' })).toBeInTheDocument()
-    expect(screen.getByRole('region', { name: 'Scenario description' })).toBeInTheDocument()
-    expect(screen.getByTestId('run-estimate')).toBeInTheDocument()
-    expect(screen.getByRole('region', { name: 'Launch scan' })).toBeInTheDocument()
-    expect(screen.getByRole('button', { name: 'Launch scan' })).toBeInTheDocument()
-    expect(screen.queryByRole('dialog', { name: 'Run preview' })).not.toBeInTheDocument()
-
-    const preview = await openRunPreview(user)
-    expect(preview).toBeInTheDocument()
-    expect(mockStartRun).not.toHaveBeenCalled()
-    await user.click(within(preview).getByRole('button', { name: 'Cancel' }))
-    expect(screen.queryByRole('dialog', { name: 'Run preview' })).not.toBeInTheDocument()
+    expect(screen.getByRole('complementary', { name: 'Run preview' })).toBeInTheDocument()
   })
 
   it('debounces preview requests and aborts the superseded request', async () => {
     jest.useFakeTimers()
     const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime })
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await flushRenderedPromises()
 
     expect(screen.getByTestId('scenario-target-select')).toBeInTheDocument()
@@ -349,8 +463,8 @@ describe('ScenarioDetail', () => {
   it('ignores an out-of-order estimate response even when the request promise does not abort', async () => {
     jest.useFakeTimers()
     const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime })
-    let resolveFirst: (estimate: ScenarioRunSizeEstimateResponse) => void = () => {}
-    let resolveSecond: (estimate: ScenarioRunSizeEstimateResponse) => void = () => {}
+    let resolveFirst: (estimate: ScenarioDefaultRunSizeEstimate) => void = () => {}
+    let resolveSecond: (estimate: ScenarioDefaultRunSizeEstimate) => void = () => {}
     mockEstimateRun
       .mockReturnValueOnce(new Promise((resolve) => {
         resolveFirst = resolve
@@ -359,7 +473,7 @@ describe('ScenarioDetail', () => {
         resolveSecond = resolve
       }))
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await flushRenderedPromises()
     await advanceTimers(300)
     await user.selectOptions(screen.getByTestId('scenario-target-select'), 'target-b')
@@ -367,16 +481,16 @@ describe('ScenarioDetail', () => {
 
     resolveSecond(makeEstimate(12))
     await flushRenderedPromises()
-    const estimate = screen.getByTestId('run-estimate')
-    expect(within(estimate).getByText('12')).toBeInTheDocument()
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
+    expect(within(preview).getByRole('group', { name: '12 planned attacks.' })).toBeInTheDocument()
 
     resolveFirst(makeEstimate(8))
     await flushRenderedPromises()
-    expect(within(estimate).getByText('12')).toBeInTheDocument()
-    expect(within(estimate).queryByText('8')).not.toBeInTheDocument()
+    expect(within(preview).getByRole('group', { name: '12 planned attacks.' })).toBeInTheDocument()
+    expect(within(preview).queryByRole('group', { name: '8 planned attacks.' })).not.toBeInTheDocument()
   })
 
-  it('keeps the last good estimate and entered state after a transient preview failure', async () => {
+  it('clears prior arithmetic and keeps entered state after a transient preview failure', async () => {
     jest.useFakeTimers()
     const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime })
     mockEstimateRun
@@ -386,59 +500,101 @@ describe('ScenarioDetail', () => {
         response: { status: 503, data: { detail: 'Preview service unavailable' } },
       })
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await flushRenderedPromises()
     await advanceTimers(300)
     await flushRenderedPromises()
-    expect(within(screen.getByTestId('run-estimate')).getByText('8')).toBeInTheDocument()
+    expect(screen.getByRole('group', { name: '8 planned attacks.' })).toBeInTheDocument()
 
     await user.selectOptions(screen.getByTestId('scenario-target-select'), 'target-b')
     await advanceTimers(300)
     await flushRenderedPromises()
 
-    const estimate = screen.getByTestId('run-estimate')
-    expect(within(estimate).getByText('8')).toBeInTheDocument()
-    expect(within(estimate).getByText('Preview service unavailable')).toBeInTheDocument()
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
+    expect(within(preview).getByText('target-b')).toBeInTheDocument()
+    expect(within(preview).getByText('Run size couldn’t be updated.')).toBeInTheDocument()
+    expect(within(preview).queryByRole('group', { name: '8 planned attacks.' })).not.toBeInTheDocument()
+    expect(within(preview).getByText('Preview service unavailable')).toBeInTheDocument()
     expect(screen.getByTestId('scenario-target-select')).toHaveValue('target-b')
-    expect(screen.getByTestId('launch-scenario-btn')).not.toBeDisabled()
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+  })
+
+  it('hides stale arithmetic and blocks launch after a configuration request error', async () => {
+    jest.useFakeTimers()
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime })
+    mockEstimateRun
+      .mockResolvedValueOnce(makeEstimate(8))
+      .mockRejectedValueOnce({
+        isAxiosError: true,
+        response: {
+          status: 400,
+          data: {
+            detail: "Scenario 'adaptive.text_adaptive' does not support overriding dataset names.",
+          },
+        },
+      })
+    renderDetail('/scenarios/foundry.red_team_agent')
+    await flushRenderedPromises()
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    expect(screen.getByRole('group', { name: '8 planned attacks.' })).toBeInTheDocument()
+
+    await user.selectOptions(screen.getByTestId('scenario-target-select'), 'target-b')
+    await advanceTimers(300)
+    await flushRenderedPromises()
+
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
+    expect(within(preview).getByText('Run size couldn’t be updated.')).toBeInTheDocument()
+    expect(within(preview).queryByTestId('run-calculation')).not.toBeInTheDocument()
+    expect(within(preview).getByText(
+      "Scenario 'adaptive.text_adaptive' does not support overriding dataset names.",
+    )).toBeInTheDocument()
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
   })
 
   it('does not request a preview while the custom technique selection is empty', async () => {
     jest.useFakeTimers()
     const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime })
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await flushRenderedPromises()
 
-    await user.click(screen.getByTestId('technique-default_technique'))
+    await user.click(screen.getByTestId('technique-mode-custom'))
+    await user.click(screen.getByTestId('technique-crescendo'))
     await advanceTimers(300)
 
     expect(mockEstimateRun).not.toHaveBeenCalled()
     expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
-    expect(within(screen.getByTestId('run-estimate')).getByText('Unavailable')).toBeInTheDocument()
+    expect(screen.getByText('Complete the required configuration to request an estimate.'))
+      .toBeInTheDocument()
   })
 
-  it('renders a backend conditional estimate without inventing a total', async () => {
+  it('renders an unknown conditional estimate without inventing a total', async () => {
     jest.useFakeTimers()
     mockEstimateRun.mockResolvedValue(makeEstimate(null))
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await flushRenderedPromises()
     await advanceTimers(300)
     await flushRenderedPromises()
 
-    const estimate = screen.getByTestId('run-estimate')
-    expect(within(estimate).getByText('8-12')).toBeInTheDocument()
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
+    expect(within(preview).getByText('Run size is confirmed at launch.')).toBeInTheDocument()
+    expect(within(preview).queryByText(REMOVED_NORMAL_ESTIMATE_LABELS)).not.toBeInTheDocument()
+    expect(within(preview).queryByText(/planned attacks/)).not.toBeInTheDocument()
   })
 
   it('renders MyST literals through the shared safe Markdown renderer', async () => {
     mockGetScenario.mockResolvedValue(
       makeScenario({
+        scenario_type: 'Jailbreak',
+        scenario_version: 4,
         description: 'Configure this scenario.',
         description_markdown: `Set \`\`num_jailbreaks\`\`.\n\n${RAW_IMAGE_HTML}unsafe`,
       }),
     )
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
 
     const description = await screen.findByTestId('scenario-detail-description')
+    expect(screen.getByText('Jailbreak · v4')).toBeInTheDocument()
     expect(within(description).getByText('num_jailbreaks').tagName).toBe('CODE')
     expect(screen.queryByRole('img')).not.toBeInTheDocument()
     expect(
@@ -446,17 +602,31 @@ describe('ScenarioDetail', () => {
     ).toBeInTheDocument()
   })
 
-  it('initializes the individual techniques from the resolved defaults', async () => {
-    renderDetail('/scanner/foundry.red_team_agent')
+  it('initializes the technique selection from default_technique', async () => {
+    renderDetail('/scenarios/foundry.red_team_agent')
 
     await screen.findByTestId('scenario-target-select')
     expect(screen.getByTestId('technique-default_technique')).toBeChecked()
-    expect(screen.getByTestId('technique-crescendo')).not.toBeChecked()
-    expect(screen.queryByText('Aggregate preset')).not.toBeInTheDocument()
-    expect(screen.queryByText('Backend-resolved preset members')).not.toBeInTheDocument()
+    expect(screen.queryByRole('group', { name: 'Individual techniques' })).not.toBeInTheDocument()
+    expect(screen.getByTestId('selected-technique-set-members')).toHaveTextContent('crescendo')
   })
 
-  it('shows technique descriptions and tags', async () => {
+  it('marks a named technique set as the scenario default', async () => {
+    mockGetScenario.mockResolvedValue(
+      makeScenario({
+        default_technique: 'easy',
+        default_techniques: ['crescendo'],
+        aggregate_techniques: ['easy'],
+        aggregate_technique_expansions: { easy: ['crescendo'] },
+      }),
+    )
+
+    renderDetail('/scenarios/foundry.red_team_agent')
+
+    expect(await screen.findByLabelText('Easy (default) — 1 technique')).toBeChecked()
+  })
+
+  it('shows catalog-provided aggregate members before the configured estimate resolves', async () => {
     mockGetScenario.mockResolvedValue(
       makeScenario({
         default_technique: 'default',
@@ -466,31 +636,750 @@ describe('ScenarioDetail', () => {
           default: ['prompt_sending', 'jailbreak_system_prompt'],
         },
         all_techniques: ['prompt_sending', 'jailbreak_system_prompt'],
-        technique_summaries: [
+      }),
+    )
+
+    renderDetail('/scenarios/foundry.red_team_agent')
+    await screen.findByTestId('scenario-target-select')
+
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
+    expect(within(preview).getByText(
+      'Resolves to prompt_sending, jailbreak_system_prompt',
+    )).toBeInTheDocument()
+    expect(within(preview).getByText('Calculating planned attacks...')).toBeInTheDocument()
+  })
+
+  it('renders the initial Adaptive conditional estimate instead of an unavailable exact total', async () => {
+    mockGetScenario.mockResolvedValue(makeAdaptiveScenario())
+    mockEstimateRun.mockResolvedValue({
+      version: 1,
+      status: 'conditional',
+      total_attack_count: null,
+      minimum_attack_count: 21,
+      maximum_attack_count: 42,
+      condition: null,
+      components: [
+        {
+          label: 'Baseline',
+          count: 21,
+          factors: [{ label: 'selected logical seed groups', count: 21 }],
+          is_baseline: true,
+          condition: null,
+          note: null,
+        },
+        {
+          label: 'Adaptive attack envelopes',
+          count: 21,
+          factors: [{ label: 'compatible logical seed groups', count: 21 }],
+          is_baseline: false,
+          condition: null,
+          note: null,
+        },
+      ],
+      datasets: [],
+      adaptive_details: {
+        objective_count: 21,
+        selected_candidate_technique_count: 2,
+        candidate_technique_count: 2,
+        max_attempts_per_objective: 2,
+        techniques_per_objective_upper_bound: 2,
+        technique_attempt_count_upper_bound: 42,
+        stop_on_first_success: true,
+        compatibility_may_reduce_attempts: true,
+      },
+      note: 'Compatibility and early success may reduce the underlying attempt count.',
+      retries_included: false,
+    } satisfies ScenarioDefaultRunSizeEstimate)
+
+    renderDetail('/scenarios/adaptive.text_adaptive')
+
+    for (const datasetName of makeAdaptiveScenario().default_datasets) {
+      expect(await screen.findByTestId(`dataset-${datasetName}`)).toBeChecked()
+    }
+    expect(screen.getByText('7 datasets selected')).toBeInTheDocument()
+    await waitFor(() => expect(mockEstimateRun).toHaveBeenCalledWith(
+      'adaptive.text_adaptive',
+      {
+        target_name: 'target-a',
+        techniques: ['default'],
+        include_baseline: true,
+      },
+      expect.any(AbortSignal),
+    ))
+    expect(await screen.findByRole('group', {
+      name: '21 objectives multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 2, equals up to 42 technique attempts.',
+    })).toBeInTheDocument()
+    expect(screen.queryByText('Exact total unavailable')).not.toBeInTheDocument()
+  })
+
+  it('updates Adaptive estimates for subset, restored, single, and failed dataset requests', async () => {
+    jest.useFakeTimers()
+    const scenario = makeAdaptiveScenario()
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime })
+    const objectiveCounts = new Map([
+      ['airt_hate', 4],
+      ['airt_fairness', 1],
+      ['airt_violence', 3],
+      ['airt_sexual', 3],
+      ['airt_harassment', 3],
+      ['airt_misinformation', 3],
+      ['airt_leakage', 4],
+    ])
+    let failNextRequest = false
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(async (_scenarioName, request: ScenarioRunSizeEstimateRequest) => {
+      if (failNextRequest) {
+        failNextRequest = false
+        throw {
+          isAxiosError: true,
+          response: { status: 503, data: { detail: 'Current estimate failed' } },
+        }
+      }
+      const datasetNames = request.dataset_names ?? scenario.default_datasets
+      const objectiveCount = datasetNames.reduce(
+        (count, datasetName) => count + (objectiveCounts.get(datasetName) ?? 0),
+        0,
+      )
+      const configuredMaximum = Number(request.scenario_params?.max_attempts_per_objective ?? 3)
+      const effectiveMaximum = Math.min(2, configuredMaximum)
+      return {
+        ...makeEstimate(null),
+        minimum_attack_count: objectiveCount,
+        maximum_attack_count: objectiveCount * 2,
+        components: [
           {
-            name: 'prompt_sending',
-            description: 'Sends the objective directly.',
-            tags: ['default', 'single_turn'],
+            label: 'Baseline',
+            count: objectiveCount,
+            factors: [{ label: 'objectives', count: objectiveCount }],
+            is_baseline: true,
+            condition: null,
+            note: null,
           },
           {
-            name: 'jailbreak_system_prompt',
-            description: 'Places the jailbreak in the system prompt.',
-            tags: ['default', 'single_turn'],
+            label: 'Adaptive objectives',
+            count: objectiveCount,
+            factors: [{ label: 'objectives', count: objectiveCount }],
+            is_baseline: false,
+            condition: null,
+            note: null,
           },
         ],
+        adaptive_details: {
+          objective_count: objectiveCount,
+          selected_candidate_technique_count: 2,
+          candidate_technique_count: 2,
+          max_attempts_per_objective: configuredMaximum,
+          techniques_per_objective_upper_bound: effectiveMaximum,
+          technique_attempt_count_upper_bound: objectiveCount * effectiveMaximum,
+          stop_on_first_success: true,
+          compatibility_may_reduce_attempts: true,
+        },
+      }
+    })
+
+    renderDetail('/scenarios/adaptive.text_adaptive')
+    await flushRenderedPromises()
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    expect(screen.getByRole('group', {
+      name: '21 objectives multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 2, equals up to 42 technique attempts.',
+    })).toBeInTheDocument()
+
+    await user.click(screen.getByTestId('dataset-airt_fairness'))
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    expect(mockEstimateRun.mock.calls.at(-1)?.[1].dataset_names).toEqual([
+      'airt_hate',
+      'airt_violence',
+      'airt_sexual',
+      'airt_harassment',
+      'airt_misinformation',
+      'airt_leakage',
+    ])
+    expect(screen.getByRole('group', {
+      name: '20 objectives multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 2, equals up to 40 technique attempts.',
+    })).toBeInTheDocument()
+
+    await user.click(screen.getByTestId('restore-default-datasets'))
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    expect(mockEstimateRun.mock.calls.at(-1)?.[1]).not.toHaveProperty('dataset_names')
+    expect(screen.getByRole('group', {
+      name: '21 objectives multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 2, equals up to 42 technique attempts.',
+    })).toBeInTheDocument()
+
+    for (const datasetName of scenario.default_datasets.filter((name) => name !== 'airt_fairness')) {
+      await user.click(screen.getByTestId(`dataset-${datasetName}`))
+    }
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    expect(mockEstimateRun.mock.calls.at(-1)?.[1].dataset_names).toEqual(['airt_fairness'])
+    expect(screen.getByRole('group', {
+      name: '1 objective multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 2, equals up to 2 technique attempts.',
+    })).toBeInTheDocument()
+
+    failNextRequest = true
+    await user.click(screen.getByTestId('dataset-airt_hate'))
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
+    expect(within(preview).queryByTestId('run-calculation')).not.toBeInTheDocument()
+    expect(within(preview).getByText('Current estimate failed')).toBeInTheDocument()
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+  })
+
+  it('explains Adaptive technique sets, progress objectives, and bounded attempt work', async () => {
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(
+      async (
+        _scenarioName: string,
+        request: ScenarioRunSizeEstimateRequest,
+      ): Promise<ScenarioDefaultRunSizeEstimate> => makeAdaptiveEstimateForRequest(scenario, request),
+    )
+    const user = userEvent.setup()
+
+    renderDetail('/scenarios/adaptive.text_adaptive')
+
+    expect(await screen.findByLabelText('Recommended (default) — 2 techniques')).toBeChecked()
+    expect(screen.getByLabelText('All (17 techniques)')).not.toBeChecked()
+    expect(screen.getByLabelText('Core (14 techniques)')).toBeInTheDocument()
+    expect(screen.getByLabelText('Extra (3 techniques)')).toBeInTheDocument()
+    expect(screen.getByLabelText('Light (9 techniques)')).toBeInTheDocument()
+    expect(screen.getByLabelText('Multi-turn (5 techniques)')).toBeInTheDocument()
+    expect(screen.getByLabelText('Single-turn (12 techniques)')).toBeInTheDocument()
+    expect(screen.getByText(
+      'Choose a predefined set, or choose Custom to select techniques individually.',
+    )).toBeInTheDocument()
+    expect(screen.getByText(
+      /All is generated from the catalog; Recommended is curated for this scenario/,
+    )).toBeInTheDocument()
+    expect(screen.getByText(
+      /tries no more than the configured maximum or the compatible candidate count, whichever is smaller/,
+    )).toBeInTheDocument()
+    expect(screen.getByText(
+      /compatibility can still change how many objectives can run/,
+    )).toBeInTheDocument()
+    expect(screen.queryByText(/aggregate preset/i)).not.toBeInTheDocument()
+    expect(screen.getByRole('radio', { name: 'Custom' })).not.toBeChecked()
+    expect(screen.queryByRole('group', { name: 'Individual techniques' })).not.toBeInTheDocument()
+
+    expect(await screen.findByRole('group', {
+      name: '21 objectives multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 2, equals up to 42 technique attempts.',
+    })).toBeInTheDocument()
+
+    await user.click(screen.getByLabelText('Core (14 techniques)'))
+    expect(screen.getByLabelText('Core (14 techniques)')).toBeChecked()
+    const selectedMembers = screen.getByTestId('selected-technique-set-members')
+    expect(within(selectedMembers).getByText('core_member_14')).toBeInTheDocument()
+    expect(await screen.findByRole('group', {
+      name: '21 objectives multiplied by up to 2 techniques per objective, the smaller of 5 compatible candidates from 14 selected and limit 2, equals up to 42 technique attempts.',
+    })).toBeInTheDocument()
+    expect(screen.getAllByText(
+      /5 compatible candidates from 14 selected · limit 2/,
+    )).toHaveLength(2)
+
+    const maxAttempts = screen.getByRole('spinbutton', { name: 'Maximum techniques per objective' })
+    expect(screen.getByText(
+      /This is a per-objective limit, not a total-run budget/,
+    )).toBeInTheDocument()
+    expect(screen.getByText(/incompatible techniques are skipped/)).toBeInTheDocument()
+    expect(screen.getByText(/This is separate from retries/)).toBeInTheDocument()
+    await user.click(screen.getByRole('button', { name: 'Advanced options' }))
+    expect(screen.getByText(
+      'Maximum times to resume the scenario after an exception. This is separate from Adaptive trying another technique.',
+    )).toBeInTheDocument()
+    await user.clear(maxAttempts)
+    await user.type(maxAttempts, '1')
+    expect(await screen.findByRole('group', {
+      name: '21 objectives multiplied by up to 1 technique per objective, the smaller of 5 compatible candidates from 14 selected and limit 1, equals up to 21 technique attempts.',
+    })).toBeInTheDocument()
+    expect(screen.getAllByText(
+      /5 compatible candidates from 14 selected · limit 1/,
+    )).toHaveLength(2)
+
+    await user.clear(maxAttempts)
+    expect(await screen.findByRole('group', {
+      name: '21 objectives multiplied by up to 3 techniques per objective, the smaller of 5 compatible candidates from 14 selected and limit 3, equals up to 63 technique attempts.',
+    })).toBeInTheDocument()
+
+    await user.type(maxAttempts, '0')
+    expect(maxAttempts).toHaveAttribute('aria-invalid', 'true')
+    expect(screen.getByText('Enter a whole number of 1 or more.')).toBeInTheDocument()
+    expect(screen.queryByText(/up to 0 technique/i)).not.toBeInTheDocument()
+    expect(screen.queryByText(/objective envelope/i)).not.toBeInTheDocument()
+  })
+
+  it('validates the Adaptive attempt limit locally and recomputes after correction', async () => {
+    jest.useFakeTimers()
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(
+      async (
+        _scenarioName: string,
+        request: ScenarioRunSizeEstimateRequest,
+      ): Promise<ScenarioDefaultRunSizeEstimate> => makeAdaptiveEstimateForRequest(scenario, request),
+    )
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime })
+
+    renderDetail('/scenarios/adaptive.text_adaptive')
+    await flushRenderedPromises()
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    await advanceTimers(300)
+    await flushRenderedPromises()
+
+    const maxAttempts = screen.getByRole('spinbutton', { name: 'Maximum techniques per objective' })
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
+    expect(maxAttempts).toHaveAttribute('min', '1')
+    expect(maxAttempts).toHaveAttribute('step', '1')
+    expect(maxAttempts).toHaveAttribute('inputmode', 'numeric')
+    expect(maxAttempts).toHaveAttribute('pattern', '[0-9]*')
+    expect(screen.getByText(
+      /Blank restores the bounded default of 2 techniques per objective for this target\./,
+    )).toBeInTheDocument()
+    expect(screen.queryByText(/Leave blank to use the default of 3/)).not.toBeInTheDocument()
+    expect(maxAttempts).toHaveValue(2)
+    expect(within(preview).getByText('up to 42')).toBeInTheDocument()
+    const initialRequestCount = mockEstimateRun.mock.calls.length
+
+    await user.clear(maxAttempts)
+    await user.type(maxAttempts, '-8')
+    expect(maxAttempts).toHaveValue(null)
+    expect(maxAttempts).toHaveAttribute('aria-invalid', 'true')
+    expect(screen.getByText('Enter a whole number of 1 or more.')).toBeInTheDocument()
+    expect(within(preview).getByText(CORRECT_HIGHLIGHTED_SETTING_MESSAGE))
+      .toBeInTheDocument()
+    expect(within(preview).queryByTestId('run-calculation')).not.toBeInTheDocument()
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+    await advanceTimers(300)
+    expect(mockEstimateRun).toHaveBeenCalledTimes(initialRequestCount)
+
+    await user.tab()
+    await user.click(maxAttempts)
+    await user.paste('-8')
+    expect(maxAttempts).toHaveValue(null)
+    expect(maxAttempts).toHaveAttribute('aria-invalid', 'true')
+    await advanceTimers(300)
+    expect(mockEstimateRun).toHaveBeenCalledTimes(initialRequestCount)
+
+    await user.tab()
+    await user.click(maxAttempts)
+    await user.paste('0')
+    expect(maxAttempts).toHaveValue(null)
+    expect(maxAttempts).toHaveAttribute('aria-invalid', 'true')
+    await advanceTimers(300)
+    expect(mockEstimateRun).toHaveBeenCalledTimes(initialRequestCount)
+
+    for (const invalidValue of ['1.5', '1e3', '+8']) {
+      await user.tab()
+      await user.click(maxAttempts)
+      await user.type(maxAttempts, invalidValue)
+      expect(maxAttempts).toHaveValue(null)
+      expect(maxAttempts).toHaveAttribute('aria-invalid', 'true')
+      expect(screen.getByText('Enter a whole number of 1 or more.')).toBeInTheDocument()
+      expect(within(preview).getByText(CORRECT_HIGHLIGHTED_SETTING_MESSAGE))
+        .toBeInTheDocument()
+      expect(within(preview).queryByTestId('run-calculation')).not.toBeInTheDocument()
+      expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+      expect(screen.queryByText(/max_attempts_per_objective must/i)).not.toBeInTheDocument()
+      await advanceTimers(300)
+      expect(mockEstimateRun).toHaveBeenCalledTimes(initialRequestCount)
+    }
+
+    await user.tab()
+    await user.click(maxAttempts)
+    await user.type(maxAttempts, '0')
+    expect(maxAttempts).toHaveValue(null)
+    expect(maxAttempts).toHaveAttribute('aria-invalid', 'true')
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+    await advanceTimers(300)
+    expect(mockEstimateRun).toHaveBeenCalledTimes(initialRequestCount)
+
+    await user.tab()
+    await user.click(maxAttempts)
+    await user.type(maxAttempts, '1')
+    await user.clear(maxAttempts)
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    expect(maxAttempts).toHaveAttribute('aria-invalid', 'false')
+    expect(maxAttempts).toHaveValue(2)
+    expect(mockEstimateRun.mock.calls.at(-1)?.[1].scenario_params).toEqual({
+      max_attempts_per_objective: 2,
+    })
+    expect(within(preview).getByText('up to 42')).toBeInTheDocument()
+
+    await user.clear(maxAttempts)
+    await user.type(maxAttempts, '1')
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    expect(maxAttempts).toHaveAttribute('aria-invalid', 'false')
+    expect(mockEstimateRun.mock.calls.at(-1)?.[1].scenario_params).toEqual({
+      max_attempts_per_objective: 1,
+    })
+    expect(within(within(preview).getByTestId('adaptive-work-calculation')).getByText('up to 21'))
+      .toBeInTheDocument()
+    expect(screen.getByTestId('launch-scenario-btn')).toBeEnabled()
+
+    const correctedRequestCount = mockEstimateRun.mock.calls.length
+    Object.defineProperty(window.getSelection(), 'modify', { value: jest.fn(), configurable: true })
+    await user.keyboard('{ArrowDown}')
+    expect(maxAttempts).toHaveValue(1)
+    await advanceTimers(300)
+    expect(mockEstimateRun).toHaveBeenCalledTimes(correctedRequestCount)
+  })
+
+  it('does not let a superseded estimate repopulate arithmetic after the limit becomes invalid', async () => {
+    jest.useFakeTimers()
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    let resolveEstimate: (estimate: ScenarioDefaultRunSizeEstimate) => void = () => {}
+    mockEstimateRun
+      .mockResolvedValueOnce(makeAdaptiveEstimateForRequest(scenario, {
+        target_name: 'target-a',
+        techniques: ['default'],
+        include_baseline: true,
+      }))
+      .mockReturnValueOnce(new Promise((resolve) => {
+        resolveEstimate = resolve
+      }))
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime })
+
+    renderDetail('/scenarios/adaptive.text_adaptive')
+    await flushRenderedPromises()
+    await advanceTimers(300)
+    await flushRenderedPromises()
+    const maxAttempts = screen.getByRole('spinbutton', { name: 'Maximum techniques per objective' })
+    await user.type(maxAttempts, '1')
+    await advanceTimers(300)
+    const requestSignal = mockEstimateRun.mock.calls[1][2] as AbortSignal
+
+    await user.clear(maxAttempts)
+    await user.type(maxAttempts, '-8')
+    expect(requestSignal.aborted).toBe(true)
+    expect(screen.getByText(CORRECT_HIGHLIGHTED_SETTING_MESSAGE)).toBeInTheDocument()
+
+    resolveEstimate(makeAdaptiveEstimateForRequest(scenario, {
+      target_name: 'target-a',
+      techniques: ['default'],
+      include_baseline: true,
+      scenario_params: { max_attempts_per_objective: 3 },
+    }))
+    await flushRenderedPromises()
+
+    expect(screen.queryByTestId('run-calculation')).not.toBeInTheDocument()
+    expect(screen.getByText(CORRECT_HIGHLIGHTED_SETTING_MESSAGE)).toBeInTheDocument()
+    expect(mockEstimateRun).toHaveBeenCalledTimes(2)
+  })
+
+  it('maps backend attempt-limit validation to the field without exposing internal copy', async () => {
+    jest.useFakeTimers()
+    mockGetScenario.mockResolvedValue(makeAdaptiveScenario())
+    mockEstimateRun.mockRejectedValue({
+      isAxiosError: true,
+      response: {
+        status: 400,
+        data: { detail: 'max_attempts_per_objective must be >= 1, got -8' },
+      },
+    })
+
+    renderDetail('/scenarios/adaptive.text_adaptive')
+    await flushRenderedPromises()
+    await advanceTimers(300)
+    await flushRenderedPromises()
+
+    const maxAttempts = screen.getByRole('spinbutton', { name: 'Maximum techniques per objective' })
+    expect(maxAttempts).toHaveAttribute('aria-invalid', 'true')
+    expect(screen.getByText('Enter a whole number of 1 or more.')).toBeInTheDocument()
+    expect(screen.getByText(CORRECT_HIGHLIGHTED_SETTING_MESSAGE)).toBeInTheDocument()
+    expect(screen.queryByText(/max_attempts_per_objective must/i)).not.toBeInTheDocument()
+    expect(screen.queryByTestId('run-calculation')).not.toBeInTheDocument()
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+  })
+
+  it('presents Adaptive attempts clearly while preserving the scenario parameter wire key', async () => {
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(
+      async (
+        _scenarioName: string,
+        request: ScenarioRunSizeEstimateRequest,
+      ): Promise<ScenarioDefaultRunSizeEstimate> => makeAdaptiveEstimateForRequest(scenario, request),
+    )
+    const user = userEvent.setup()
+    renderDetail('/scenarios/adaptive.text_adaptive')
+
+    const maxAttempts = await screen.findByRole('spinbutton', { name: 'Maximum techniques per objective' })
+    await screen.findByRole('group', {
+      name: '21 objectives multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 2, equals up to 42 technique attempts.',
+    })
+    expect(maxAttempts).toHaveAttribute('max', '2')
+    expect(maxAttempts).toHaveValue(2)
+    expect(screen.getByText(
+      'The scenario default of 3 is reduced to 2 because Recommended (default) provides 2 compatible techniques for this target.',
+    )).toBeInTheDocument()
+    expect(screen.queryByText(/Maximum reached:/)).not.toBeInTheDocument()
+    expect(screen.getByText(
+      /Blank restores the bounded default of 2 techniques per objective for this target\./,
+    )).toBeInTheDocument()
+    expect(screen.queryByText('max_attempts_per_objective')).not.toBeInTheDocument()
+    expect(screen.getByText(/This is separate from retries/)).toBeInTheDocument()
+
+    await user.clear(maxAttempts)
+    await user.type(maxAttempts, '5')
+    expect(maxAttempts).toHaveValue(2)
+    expect(screen.getByText(
+      'Maximum reached: Recommended (default) provides 2 compatible techniques for this target.',
+    )).toBeInTheDocument()
+    expect(mockEstimateRun).not.toHaveBeenCalledWith(
+      'adaptive.text_adaptive',
+      expect.objectContaining({
+        scenario_params: { max_attempts_per_objective: 5 },
       }),
+      expect.any(AbortSignal),
     )
 
-    renderDetail('/scanner/foundry.red_team_agent')
-    await screen.findByTestId('scenario-target-select')
+    await user.clear(maxAttempts)
+    await waitFor(() => expect(maxAttempts).toHaveValue(2))
+    expect(screen.getByText(
+      'The scenario default of 3 is reduced to 2 because Recommended (default) provides 2 compatible techniques for this target.',
+    )).toBeInTheDocument()
+
+    await user.paste('3')
+    expect(maxAttempts).toHaveValue(2)
+    expect(screen.getByText(
+      'Maximum reached: Recommended (default) provides 2 compatible techniques for this target.',
+    )).toBeInTheDocument()
+
+    await user.clear(maxAttempts)
+    await user.type(maxAttempts, '1')
+    await waitFor(() => expect(mockEstimateRun).toHaveBeenLastCalledWith(
+      'adaptive.text_adaptive',
+      expect.objectContaining({
+        scenario_params: { max_attempts_per_objective: 1 },
+      }),
+      expect.any(AbortSignal),
+    ))
+    expect(screen.queryByText(/Maximum reached:/)).not.toBeInTheDocument()
+
+    await user.clear(maxAttempts)
+    await user.type(maxAttempts, '2')
+    await waitFor(() => expect(mockEstimateRun).toHaveBeenLastCalledWith(
+      'adaptive.text_adaptive',
+      expect.objectContaining({
+        scenario_params: { max_attempts_per_objective: 2 },
+      }),
+      expect.any(AbortSignal),
+    ))
+    expect(await screen.findByRole('group', {
+      name: '21 objectives multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 2, equals up to 42 technique attempts.',
+    })).toBeInTheDocument()
+    expect(screen.getByText(
+      'Maximum reached: Recommended (default) provides 2 compatible techniques for this target.',
+    )).toBeInTheDocument()
+    Object.defineProperty(window.getSelection(), 'modify', { value: jest.fn(), configurable: true })
+    await user.keyboard('{ArrowUp}')
+    expect(maxAttempts).toHaveValue(2)
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
+    expect(within(preview).getByText('Maximum techniques per objective')).toBeInTheDocument()
+    expect(within(preview).queryByText('Techniques tried per objective')).not.toBeInTheDocument()
+    await user.click(screen.getByTestId('launch-scenario-btn'))
+    await waitFor(() => expect(mockStartRun).toHaveBeenCalledWith(
+      expect.objectContaining({
+        scenario_params: { max_attempts_per_objective: 2 },
+      }),
+    ))
+  })
+
+  it.each([
+    ['Light (9 techniques)', 'Light', 9, 10],
+    ['Core (14 techniques)', 'Core', 14, 22],
+    ['All (17 techniques)', 'All', 17, 22],
+  ])(
+    'clamps an over-limit attempt to the authoritative %s candidate count',
+    async (optionLabel, displayName, maximum, attemptedValue) => {
+      const scenario = makeAdaptiveScenario()
+      mockGetScenario.mockResolvedValue(scenario)
+      mockEstimateRun.mockImplementation(
+        async (
+          _scenarioName: string,
+          request: ScenarioRunSizeEstimateRequest,
+        ): Promise<ScenarioDefaultRunSizeEstimate> => {
+          const estimate = makeAdaptiveEstimateForRequest(scenario, request)
+          const adaptiveDetails = estimate.adaptive_details
+          if (adaptiveDetails) {
+            const candidateCount = adaptiveDetails.selected_candidate_technique_count ?? 0
+            const configuredMaximum = adaptiveDetails.max_attempts_per_objective
+            adaptiveDetails.candidate_technique_count = candidateCount
+            adaptiveDetails.techniques_per_objective_upper_bound = Math.min(
+              candidateCount,
+              configuredMaximum,
+            )
+            adaptiveDetails.technique_attempt_count_upper_bound =
+              21 * adaptiveDetails.techniques_per_objective_upper_bound
+          }
+          return estimate
+        },
+      )
+      const user = userEvent.setup()
+      renderDetail('/scenarios/adaptive.text_adaptive')
+
+      const maxAttempts = await screen.findByRole('spinbutton', {
+        name: 'Maximum techniques per objective',
+      })
+      await user.click(await screen.findByLabelText(optionLabel))
+      await waitFor(() => expect(maxAttempts).toHaveAttribute('max', String(maximum)))
+      expect(screen.getByText(/Leave blank to use the default of 3\./)).toBeInTheDocument()
+      expect(screen.queryByText(/Blank restores the bounded default/)).not.toBeInTheDocument()
+      await user.clear(maxAttempts)
+      await user.type(maxAttempts, String(attemptedValue))
+
+      expect(maxAttempts).toHaveValue(maximum)
+      expect(screen.getByText(
+        `Maximum reached: ${displayName} provides ${maximum} compatible techniques for this target.`,
+      )).toBeInTheDocument()
+      expect(await screen.findByRole('group', {
+        name: `21 objectives multiplied by up to ${maximum} techniques per objective, the smaller of ${maximum} selected candidates and limit ${maximum}, equals up to ${
+          21 * maximum
+        } technique attempts.`,
+      })).toBeInTheDocument()
+      expect(mockEstimateRun).not.toHaveBeenCalledWith(
+        'adaptive.text_adaptive',
+        expect.objectContaining({
+          scenario_params: { max_attempts_per_objective: attemptedValue },
+        }),
+        expect.any(AbortSignal),
+      )
+      expect(mockEstimateRun).toHaveBeenLastCalledWith(
+        'adaptive.text_adaptive',
+        expect.objectContaining({
+          scenario_params: { max_attempts_per_objective: maximum },
+        }),
+        expect.any(AbortSignal),
+      )
+      expect(screen.getByRole('complementary', { name: 'Run preview' })).toHaveTextContent(
+        new RegExp(`Maximum techniques per objective\\s*${maximum}`),
+      )
+      await user.type(maxAttempts, '-8')
+      expect(maxAttempts).toHaveValue(maximum)
+      expect(maxAttempts).toHaveAttribute('aria-invalid', 'true')
+      expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+    },
+  )
+
+  it('clamps an explicit limit when the selected technique set lowers the compatible maximum', async () => {
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(
+      async (
+        _scenarioName: string,
+        request: ScenarioRunSizeEstimateRequest,
+      ): Promise<ScenarioDefaultRunSizeEstimate> => makeAdaptiveEstimateForRequest(scenario, request),
+    )
+    const user = userEvent.setup()
+    renderDetail('/scenarios/adaptive.text_adaptive')
+
+    const maxAttempts = await screen.findByRole('spinbutton', {
+      name: 'Maximum techniques per objective',
+    })
+    await screen.findByRole('group', {
+      name: '21 objectives multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 2, equals up to 42 technique attempts.',
+    })
+
+    await user.click(screen.getByLabelText('Core (14 techniques)'))
+    await waitFor(() => expect(maxAttempts).toHaveAttribute('max', '5'))
+    await user.type(maxAttempts, '5')
+    await screen.findByRole('group', {
+      name: '21 objectives multiplied by up to 5 techniques per objective, the smaller of 5 compatible candidates from 14 selected and limit 5, equals up to 105 technique attempts.',
+    })
+
+    await user.click(screen.getByLabelText('Recommended (default) — 2 techniques'))
+    expect(maxAttempts).toBeDisabled()
+    await waitFor(() => expect(maxAttempts).toHaveValue(2))
+    expect(maxAttempts).toHaveAttribute('max', '2')
+    expect(screen.getByText(
+      'Reduced to 2 because Recommended (default) provides 2 compatible techniques for this target.',
+    )).toBeInTheDocument()
+    await screen.findByRole('group', {
+      name: '21 objectives multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 2, equals up to 42 technique attempts.',
+    })
+    expect(mockEstimateRun).not.toHaveBeenCalledWith(
+      'adaptive.text_adaptive',
+      expect.objectContaining({
+        techniques: ['default'],
+        scenario_params: { max_attempts_per_objective: 5 },
+      }),
+      expect.any(AbortSignal),
+    )
+
+    await user.click(screen.getByTestId('launch-scenario-btn'))
+    await waitFor(() => expect(mockStartRun).toHaveBeenCalledWith(
+      expect.objectContaining({
+        techniques: ['default'],
+        scenario_params: { max_attempts_per_objective: 2 },
+      }),
+    ))
+  })
+
+  it('updates the bound for target compatibility and blocks a target with no eligible techniques', async () => {
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(
+      async (
+        _scenarioName: string,
+        request: ScenarioRunSizeEstimateRequest,
+      ): Promise<ScenarioDefaultRunSizeEstimate> => {
+        const estimate = makeAdaptiveEstimateForRequest(scenario, request)
+        if (request.target_name === 'target-b' && estimate.adaptive_details) {
+          const candidateCount = request.techniques?.[0] === 'core' ? 0 : 1
+          estimate.adaptive_details.candidate_technique_count = candidateCount
+          estimate.adaptive_details.techniques_per_objective_upper_bound = candidateCount
+          estimate.adaptive_details.technique_attempt_count_upper_bound = 21 * candidateCount
+        }
+        return estimate
+      },
+    )
+    const user = userEvent.setup()
+    renderDetail('/scenarios/adaptive.text_adaptive')
 
-    expect(screen.getByText('Sends the objective directly.')).toBeInTheDocument()
-    expect(screen.getByText('Places the jailbreak in the system prompt.')).toBeInTheDocument()
-    expect(screen.getAllByRole('button', { name: 'Clear Recommended techniques' })).toHaveLength(2)
-    expect(screen.getAllByRole('button', { name: 'Clear Single-turn techniques' })).toHaveLength(3)
+    const maxAttempts = await screen.findByRole('spinbutton', {
+      name: 'Maximum techniques per objective',
+    })
+    await waitFor(() => expect(maxAttempts).toHaveAttribute('max', '2'))
+    await user.type(maxAttempts, '2')
+    await waitFor(() => expect(maxAttempts).toHaveValue(2))
+    await user.selectOptions(screen.getByRole('combobox', { name: 'Target' }), 'target-b')
+
+    expect(maxAttempts).toBeDisabled()
+    await waitFor(() => expect(maxAttempts).toHaveValue(1))
+    expect(maxAttempts).toHaveAttribute('max', '1')
+    expect(screen.getByText(
+      'Reduced to 1 because Recommended (default) provides 1 compatible technique for this target.',
+    )).toBeInTheDocument()
+    expect(mockEstimateRun).not.toHaveBeenCalledWith(
+      'adaptive.text_adaptive',
+      expect.objectContaining({
+        target_name: 'target-b',
+        scenario_params: { max_attempts_per_objective: 2 },
+      }),
+      expect.any(AbortSignal),
+    )
+
+    await user.click(screen.getByLabelText('Core (14 techniques)'))
+    expect(await screen.findByText(
+      'No compatible techniques are available for this target. Choose a different technique set or target.',
+    )).toBeInTheDocument()
+    expect(maxAttempts).toBeDisabled()
+    expect(maxAttempts).not.toHaveAttribute('max')
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+    expect(screen.queryByTestId('run-calculation')).not.toBeInTheDocument()
   })
 
-  it('renders only concrete techniques and de-duplicates their names', async () => {
+  it('switches exclusively from a named set to Custom and initializes resolved members', async () => {
     mockGetScenario.mockResolvedValue(
       makeScenario({
         aggregate_techniques: ['default_technique', 'all_garak'],
@@ -499,17 +1388,25 @@ describe('ScenarioDetail', () => {
     )
     const user = userEvent.setup()
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
-    expect(screen.queryByTestId('technique-all_garak')).not.toBeInTheDocument()
-    expect(screen.getAllByTestId('technique-crescendo')).toHaveLength(1)
+    // 'all_garak' is both an aggregate and (accidentally) listed under all_techniques —
+    // it must render exactly once (deduped), under the aggregate group.
+    expect(screen.getAllByTestId('technique-all_garak')).toHaveLength(1)
 
-    await user.click(screen.getByTestId('technique-crescendo'))
+    expect(screen.queryByRole('group', { name: 'Individual techniques' })).not.toBeInTheDocument()
+    await user.click(screen.getByTestId('technique-mode-custom'))
+    expect(screen.getByTestId('technique-default_technique')).not.toBeChecked()
     expect(screen.getByTestId('technique-crescendo')).toBeChecked()
 
     await user.click(screen.getByTestId('technique-prompt_sending'))
-    await confirmRunPreview(user)
+    await waitFor(() => expect(mockEstimateRun).toHaveBeenLastCalledWith(
+      'foundry.red_team_agent',
+      expect.objectContaining({ techniques: ['crescendo', 'prompt_sending'] }),
+      expect.any(AbortSignal),
+    ))
+    await user.click(screen.getByTestId('launch-scenario-btn'))
 
     await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
     const request = mockStartRun.mock.calls[0][0]
@@ -517,30 +1414,39 @@ describe('ScenarioDetail', () => {
     expect(new Set(request.techniques).size).toBe(request.techniques.length)
   })
 
-  it('selects and clears all members of a tag', async () => {
+  it('preserves custom choices while named sets send exactly one token', async () => {
     mockGetScenario.mockResolvedValue(
       makeScenario({
-        default_techniques: ['default_technique'],
-        all_techniques: ['default_technique', 'crescendo', 'many_shot'],
-        technique_summaries: [
-          { name: 'default_technique', description: 'Direct attack.', tags: ['single_turn'] },
-          { name: 'crescendo', description: 'Escalating attack.', tags: ['multi_turn'] },
-          { name: 'many_shot', description: 'Many-shot attack.', tags: ['multi_turn'] },
-        ],
+        aggregate_techniques: ['default_technique', 'all_garak'],
+        aggregate_technique_expansions: {
+          default_technique: ['crescendo'],
+          all_garak: ['crescendo'],
+        },
+        all_techniques: ['default_technique', 'crescendo', 'prompt_sending'],
       }),
     )
     const user = userEvent.setup()
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
-    await user.click(screen.getAllByRole('button', { name: 'Select Multi-turn techniques' })[0])
-    expect(screen.getByTestId('technique-crescendo')).toBeChecked()
-    expect(screen.getByTestId('technique-many_shot')).toBeChecked()
+    await user.click(screen.getByTestId('technique-mode-custom'))
+    await user.click(screen.getByTestId('technique-prompt_sending'))
+    await user.click(screen.getByTestId('technique-all_garak'))
+    expect(screen.getByTestId('technique-all_garak')).toBeChecked()
+    expect(screen.queryByRole('group', { name: 'Individual techniques' })).not.toBeInTheDocument()
+    await waitFor(() => expect(mockEstimateRun).toHaveBeenLastCalledWith(
+      'foundry.red_team_agent',
+      expect.objectContaining({ techniques: ['all_garak'] }),
+      expect.any(AbortSignal),
+    ))
 
-    await user.click(screen.getAllByRole('button', { name: 'Clear Multi-turn techniques' })[0])
-    expect(screen.getByTestId('technique-crescendo')).not.toBeChecked()
-    expect(screen.getByTestId('technique-many_shot')).not.toBeChecked()
-    expect(screen.getByTestId('technique-default_technique')).toBeChecked()
+    await user.click(screen.getByTestId('launch-scenario-btn'))
+    await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
+    expect(mockStartRun.mock.calls[0][0].techniques).toEqual(['all_garak'])
+
+    await user.click(screen.getByTestId('technique-mode-custom'))
+    expect(screen.getByTestId('technique-crescendo')).toBeChecked()
+    expect(screen.getByTestId('technique-prompt_sending')).toBeChecked()
   })
 
   it('initializes a concrete default as custom and allows adding another concrete technique', async () => {
@@ -552,27 +1458,29 @@ describe('ScenarioDetail', () => {
       }),
     )
     const user = userEvent.setup()
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
+    expect(screen.getByTestId('technique-mode-custom')).toBeChecked()
     expect(screen.getByTestId('technique-prompt_sending')).toBeChecked()
     await user.click(screen.getByTestId('technique-crescendo'))
     expect(screen.getByTestId('technique-prompt_sending')).toBeChecked()
     expect(screen.getByTestId('technique-crescendo')).toBeChecked()
 
-    await confirmRunPreview(user)
+    await user.click(screen.getByTestId('launch-scenario-btn'))
     await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
     expect(mockStartRun.mock.calls[0][0].techniques).toEqual(['prompt_sending', 'crescendo'])
   })
 
   it('keeps an explicit invalid custom state when the last concrete technique is removed', async () => {
     const user = userEvent.setup()
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
-    await user.click(screen.getByTestId('technique-default_technique'))
+    await user.click(screen.getByTestId('technique-mode-custom'))
+    await user.click(screen.getByTestId('technique-crescendo'))
 
-    expect(await screen.findByRole('alert')).toHaveTextContent('Select at least one attack technique.')
+    expect(await screen.findByRole('alert')).toHaveTextContent('Select at least one technique.')
     expect(screen.getByTestId('technique-default_technique')).not.toBeChecked()
     expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
     expect(mockStartRun).not.toHaveBeenCalled()
@@ -580,39 +1488,170 @@ describe('ScenarioDetail', () => {
 
   it('defaults the baseline checkbox from include_baseline_by_default when enabled, and allows editing', async () => {
     const user = userEvent.setup()
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
     const checkbox = screen.getByTestId('baseline-checkbox')
     expect(checkbox).toBeChecked()
     expect(checkbox).toHaveAccessibleName('baseline')
+    expect(screen.getByText(
+      /Also send each selected objective directly, without an attack technique/,
+    )).toBeInTheDocument()
+    expect(screen.getByRole('complementary', { name: 'Run preview' })).toHaveTextContent(
+      'Included — direct objective without an attack technique',
+    )
 
     await user.click(checkbox)
-    await confirmRunPreview(user)
+    await waitFor(() => expect(mockEstimateRun).toHaveBeenLastCalledWith(
+      'foundry.red_team_agent',
+      expect.objectContaining({ include_baseline: false }),
+      expect.any(AbortSignal),
+    ))
+    await user.click(screen.getByTestId('launch-scenario-btn'))
 
     await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
     expect(mockStartRun.mock.calls[0][0].include_baseline).toBe(false)
   })
 
-  it('includes the baseline when a shared tag selects or clears its members', async () => {
+  it('updates Adaptive planned arithmetic ON to OFF to ON while preserving inner work', async () => {
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(
+      async (
+        _scenarioName: string,
+        request: ScenarioRunSizeEstimateRequest,
+      ): Promise<ScenarioDefaultRunSizeEstimate> =>
+        makeFullyCompatibleAdaptiveEstimateForRequest(scenario, request),
+    )
     const user = userEvent.setup()
-    renderDetail('/scanner/foundry.red_team_agent')
-    await screen.findByTestId('scenario-target-select')
+    renderDetail('/scenarios/adaptive.text_adaptive')
 
-    await user.click(screen.getAllByRole('button', { name: 'Clear Single-turn techniques' })[0])
-    expect(screen.getByTestId('baseline-checkbox')).not.toBeChecked()
-    expect(screen.getByTestId('technique-default_technique')).not.toBeChecked()
+    await user.click(await screen.findByLabelText('Core (14 techniques)'))
+    const maxAttempts = await screen.findByRole('spinbutton', {
+      name: 'Maximum techniques per objective',
+    })
+    await waitFor(() => expect(maxAttempts).toHaveAttribute('max', '14'))
+    await user.clear(maxAttempts)
+    await user.type(maxAttempts, '14')
+
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
+    expect(await within(preview).findByRole('group', {
+      name: 'Direct baseline comparison is included: 21 direct baseline attacks plus up to 21 Adaptive attacks equals 21–42 planned attacks.',
+    })).toBeInTheDocument()
+    expect(within(preview).getByTestId('adaptive-work-calculation')).toHaveTextContent(
+      'up to 294technique attempts',
+    )
+    expect(screen.getByText('Adds 21 direct baseline attacks for the current objectives.'))
+      .toBeInTheDocument()
+    expect(within(preview).getByText('Included — direct objective without an attack technique'))
+      .toBeInTheDocument()
+
+    const baselineCheckbox = screen.getByTestId('baseline-checkbox')
+    await user.click(baselineCheckbox)
+    expect(within(preview).getByText('Calculating planned attacks...')).toBeInTheDocument()
+    expect(within(preview).getByText('Not included')).toBeInTheDocument()
+    expect(await within(preview).findByRole('group', {
+      name: 'Direct baseline comparison is not included: up to 21 Adaptive attacks equals up to 21 planned attacks.',
+    })).toBeInTheDocument()
+    expect(within(preview).getByTestId('adaptive-work-calculation')).toHaveTextContent(
+      'up to 294technique attempts',
+    )
+    expect(mockEstimateRun).toHaveBeenLastCalledWith(
+      'adaptive.text_adaptive',
+      expect.objectContaining({
+        include_baseline: false,
+        scenario_params: { max_attempts_per_objective: 14 },
+      }),
+      expect.any(AbortSignal),
+    )
 
-    await user.click(screen.getAllByRole('button', { name: 'Select Single-turn techniques' })[0])
-    expect(screen.getByTestId('baseline-checkbox')).toBeChecked()
-    expect(screen.getByTestId('technique-default_technique')).toBeChecked()
+    await user.click(baselineCheckbox)
+    expect(within(preview).getByText('Calculating planned attacks...')).toBeInTheDocument()
+    expect(within(preview).getByText('Included — direct objective without an attack technique'))
+      .toBeInTheDocument()
+    expect(await within(preview).findByRole('group', {
+      name: 'Direct baseline comparison is included: 21 direct baseline attacks plus up to 21 Adaptive attacks equals 21–42 planned attacks.',
+    })).toBeInTheDocument()
+    expect(mockEstimateRun).toHaveBeenLastCalledWith(
+      'adaptive.text_adaptive',
+      expect.objectContaining({
+        include_baseline: true,
+        scenario_params: { max_attempts_per_objective: 14 },
+      }),
+      expect.any(AbortSignal),
+    )
+  })
+
+  it('ignores stale Adaptive baseline estimates after a rapid OFF to ON toggle', async () => {
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(
+      async (
+        _scenarioName: string,
+        request: ScenarioRunSizeEstimateRequest,
+      ): Promise<ScenarioDefaultRunSizeEstimate> =>
+        makeFullyCompatibleAdaptiveEstimateForRequest(scenario, request),
+    )
+    const user = userEvent.setup()
+    renderDetail('/scenarios/adaptive.text_adaptive')
+
+    await screen.findByRole('group', {
+      name: 'Direct baseline comparison is included: 21 direct baseline attacks plus up to 21 Adaptive attacks equals 21–42 planned attacks.',
+    })
+
+    let resolveOff: ((estimate: ScenarioDefaultRunSizeEstimate) => void) | null = null
+    let resolveOn: ((estimate: ScenarioDefaultRunSizeEstimate) => void) | null = null
+    mockEstimateRun.mockImplementation(
+      async (
+        _scenarioName: string,
+        request: ScenarioRunSizeEstimateRequest,
+      ): Promise<ScenarioDefaultRunSizeEstimate> => await new Promise((resolve) => {
+        if (request.include_baseline === false) {
+          resolveOff = resolve
+        } else {
+          resolveOn = resolve
+        }
+      }),
+    )
+
+    const baselineCheckbox = screen.getByTestId('baseline-checkbox')
+    await user.click(baselineCheckbox)
+    await waitFor(() => expect(resolveOff).not.toBeNull())
+    await user.click(baselineCheckbox)
+    await waitFor(() => expect(resolveOn).not.toBeNull())
+
+    if (!resolveOn || !resolveOff) {
+      throw new Error('Expected both baseline estimate requests to be pending.')
+    }
+    resolveOn(makeFullyCompatibleAdaptiveEstimateForRequest(scenario, {
+      target_name: 'target-a',
+      techniques: ['default'],
+      include_baseline: true,
+    }))
+    await flushRenderedPromises()
+    expect(screen.getByRole('group', {
+      name: 'Direct baseline comparison is included: 21 direct baseline attacks plus up to 21 Adaptive attacks equals 21–42 planned attacks.',
+    })).toBeInTheDocument()
+
+    resolveOff(makeFullyCompatibleAdaptiveEstimateForRequest(scenario, {
+      target_name: 'target-a',
+      techniques: ['default'],
+      include_baseline: false,
+    }))
+    await flushRenderedPromises()
+    expect(screen.getByRole('group', {
+      name: 'Direct baseline comparison is included: 21 direct baseline attacks plus up to 21 Adaptive attacks equals 21–42 planned attacks.',
+    })).toBeInTheDocument()
+    expect(screen.queryByRole('group', {
+      name: 'Direct baseline comparison is not included: up to 21 Adaptive attacks equals up to 21 planned attacks.',
+    })).not.toBeInTheDocument()
   })
 
   it('defaults the baseline checkbox to unchecked when the policy is disabled with include_baseline_by_default false', async () => {
     mockGetScenario.mockResolvedValue(
       makeScenario({ baseline_policy: 'disabled', include_baseline_by_default: false }),
     )
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
     expect(screen.getByTestId('baseline-checkbox')).not.toBeChecked()
@@ -620,16 +1659,23 @@ describe('ScenarioDetail', () => {
 
   it('disables and forces the baseline checkbox false when the policy is forbidden', async () => {
     mockGetScenario.mockResolvedValue(makeScenario({ baseline_policy: 'forbidden' }))
+    mockEstimateRun.mockResolvedValue(makeEstimate(8))
     const user = userEvent.setup()
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
     const checkbox = screen.getByTestId('baseline-checkbox')
     expect(checkbox).toBeDisabled()
     expect(checkbox).not.toBeChecked()
+    expect(checkbox).toHaveAccessibleName('Include direct baseline comparison')
+    expect(screen.getByText(
+      /This scenario does not support sending objectives directly without an attack technique/,
+    )).toBeInTheDocument()
+    expect(await screen.findByRole('group', { name: '8 planned attacks.' })).toBeInTheDocument()
+    expect(screen.queryByText(/direct baseline attack/)).not.toBeInTheDocument()
 
-    await confirmRunPreview(user)
+    await user.click(screen.getByTestId('launch-scenario-btn'))
     await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
     expect(mockStartRun.mock.calls[0][0].include_baseline).toBe(false)
   })
@@ -647,7 +1693,7 @@ describe('ScenarioDetail', () => {
       }),
     )
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
     expect(screen.queryByTestId('scenario-param-objective_target')).not.toBeInTheDocument()
@@ -665,27 +1711,29 @@ describe('ScenarioDetail', () => {
         ],
       }),
     )
-    const user = userEvent.setup()
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
     // A number-typed HTML input rejects non-numeric characters outright, so a
     // decimal (a valid *number* but not a valid *integer*) exercises the same
     // coercion/validation path a real user could actually trigger.
     fireEvent.change(screen.getByTestId('scenario-param-iterations'), { target: { value: '1.5' } })
-    await user.click(screen.getByTestId('launch-scenario-btn'))
 
-    expect(await screen.findByRole('alert')).toHaveTextContent('iterations must be an integer.')
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+    expect(screen.getByText('iterations must be an integer.')).toBeInTheDocument()
     expect(mockStartRun).not.toHaveBeenCalled()
   })
 
-  it('omits the dataset override and max dataset size when left blank, sending default concurrency/retries', async () => {
+  it('selects scenario default datasets initially and omits the unchanged override', async () => {
     const user = userEvent.setup()
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
-    await confirmRunPreview(user)
+    expect(screen.getByTestId('dataset-harmbench')).toBeChecked()
+    expect(screen.getByText('1 dataset selected')).toBeInTheDocument()
+    expect(screen.getByTestId('restore-default-datasets')).toBeDisabled()
+    await user.click(screen.getByTestId('launch-scenario-btn'))
 
     await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
     const request = mockStartRun.mock.calls[0][0]
@@ -695,101 +1743,197 @@ describe('ScenarioDetail', () => {
     expect(request.max_retries).toBe(0)
   })
 
-  it('shows the combined configured dataset size without submitting it as an override', async () => {
-    const user = userEvent.setup()
-    mockGetScenario.mockResolvedValueOnce(
-      makeScenario({
-        default_run_size: {
-          estimated_attack_count: null,
-          components: [],
-          datasets: [
-            {
-              name: 'harmbench',
-              kind: 'dataset',
-              logical_seed_group_count: 400,
-              selected_seed_group_count: 4,
-              configured_caps: [
-                {
-                  label: 'per-dataset cap',
-                  count: 4,
-                  configured_on: 'dataset',
-                  dataset_name: 'harmbench',
-                },
-              ],
-              selection_note: 'The default selection uses 4 of 400 logical seed groups.',
-            },
-            {
-              name: 'adv_bench',
-              kind: 'dataset',
-              logical_seed_group_count: 300,
-              selected_seed_group_count: 4,
-              configured_caps: [
-                {
-                  label: 'per-dataset cap',
-                  count: 4,
-                  configured_on: 'dataset',
-                  dataset_name: 'adv_bench',
-                },
-              ],
-              selection_note: 'The default selection uses 4 of 300 logical seed groups.',
-            },
-          ],
-          note: null,
-        },
-      }),
+  it('materializes the adaptive per-dataset default while omitting unchanged and restored overrides', async () => {
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(
+      async (_scenarioName, request: ScenarioRunSizeEstimateRequest) =>
+        makeFullyCompatibleAdaptiveEstimateForRequest(scenario, request),
     )
+    const user = userEvent.setup()
+    renderDetail('/scenarios/adaptive.text_adaptive')
+    await screen.findByTestId('scenario-target-select')
+    await user.click(screen.getByRole('button', { name: 'Advanced options' }))
 
-    renderDetail('/scanner/foundry.red_team_agent')
-
-    expect(await screen.findByRole('heading', { name: 'Parameters' })).toBeInTheDocument()
-    expect(screen.queryByText('Advanced options')).not.toBeInTheDocument()
-    expect(screen.getByTestId('max-dataset-size-input')).toHaveValue(8)
+    const input = screen.getByTestId('advanced-max_dataset_size')
+    expect(input).toHaveValue(4)
+    expect(input).toHaveAttribute('min', '1')
+    expect(input).toHaveAttribute('step', '1')
+    expect(input).toHaveAttribute('inputmode', 'numeric')
     expect(screen.getByText(
-      'The scenario default is 8. Edit it to override the default.',
+      'Scenario default: up to 4 objectives from each selected dataset. Enter another whole number to override it, or leave blank to use the scenario default.',
     )).toBeInTheDocument()
-    const estimate = screen.getByTestId('run-estimate')
-    expect(within(estimate).getByText('Dataset size')).toBeInTheDocument()
-    expect(within(estimate).getByText('8')).toBeInTheDocument()
-    expect(within(estimate).getByText('Number techniques')).toBeInTheDocument()
-    expect(within(estimate).getByText('2')).toBeInTheDocument()
+    expect(screen.getByRole('complementary', { name: 'Run preview' }))
+      .toHaveTextContent('4 per dataset (scenario default)')
     await waitFor(() => expect(mockEstimateRun).toHaveBeenCalled())
     expect(mockEstimateRun.mock.calls.at(-1)?.[1]).not.toHaveProperty('max_dataset_size')
 
-    await confirmRunPreview(user)
+    await user.clear(input)
+    expect(input).toHaveValue(null)
+    expect(screen.getByRole('complementary', { name: 'Run preview' }))
+      .toHaveTextContent('4 per dataset (scenario default)')
+    await user.type(input, '3')
+    expect(screen.getByRole('complementary', { name: 'Run preview' }))
+      .toHaveTextContent('3 per dataset (override)')
+    await waitFor(() => expect(mockEstimateRun.mock.calls.at(-1)?.[1]).toEqual(
+      expect.objectContaining({ max_dataset_size: 3 }),
+    ))
+    await user.click(screen.getByTestId('launch-scenario-btn'))
+    await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
+    expect(mockStartRun.mock.calls[0][0].max_dataset_size).toBe(3)
+    mockStartRun.mockClear()
+
+    await user.click(screen.getByTestId('restore-default-dataset-size'))
+    expect(input).toHaveValue(4)
+    expect(screen.getByRole('complementary', { name: 'Run preview' }))
+      .toHaveTextContent('4 per dataset (scenario default)')
+    await waitFor(() => expect(mockEstimateRun.mock.calls.at(-1)?.[1])
+      .not.toHaveProperty('max_dataset_size'))
+    await user.click(screen.getByTestId('launch-scenario-btn'))
     await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
     expect(mockStartRun.mock.calls[0][0]).not.toHaveProperty('max_dataset_size')
   })
 
-  it('includes dataset overrides and filters when provided', async () => {
+  it('keeps the inherited per-dataset default while dataset selections change', async () => {
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(
+      async (_scenarioName, request: ScenarioRunSizeEstimateRequest) =>
+        makeFullyCompatibleAdaptiveEstimateForRequest(scenario, request),
+    )
     const user = userEvent.setup()
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/adaptive.text_adaptive')
+    await screen.findByTestId('dataset-ds_a')
+
+    await user.click(screen.getByTestId('dataset-airt_hate'))
+    await waitFor(() => expect(mockEstimateRun.mock.calls.at(-1)?.[1]).toEqual(
+      expect.objectContaining({
+        dataset_names: expect.arrayContaining(['airt_fairness', 'airt_violence']),
+      }),
+    ))
+    expect(mockEstimateRun.mock.calls.at(-1)?.[1].dataset_names).toHaveLength(6)
+    expect(mockEstimateRun.mock.calls.at(-1)?.[1]).not.toHaveProperty('max_dataset_size')
+
+    for (const name of ['airt_fairness', 'airt_violence', 'airt_sexual', 'airt_harassment', 'airt_misinformation']) {
+      await user.click(screen.getByTestId(`dataset-${name}`))
+    }
+    await waitFor(() => expect(mockEstimateRun.mock.calls.at(-1)?.[1].dataset_names)
+      .toEqual(['airt_leakage']))
+    expect(mockEstimateRun.mock.calls.at(-1)?.[1]).not.toHaveProperty('max_dataset_size')
+
+    await user.click(screen.getByTestId('restore-default-datasets'))
+    await waitFor(() => expect(mockEstimateRun.mock.calls.at(-1)?.[1])
+      .not.toHaveProperty('dataset_names'))
+    await user.click(screen.getByTestId('dataset-ds_a'))
+    await waitFor(() => expect(mockEstimateRun.mock.calls.at(-1)?.[1].dataset_names)
+      .toEqual([...scenario.default_datasets, 'ds_a']))
+    expect(mockEstimateRun.mock.calls.at(-1)?.[1]).not.toHaveProperty('max_dataset_size')
+
+    await user.click(screen.getByTestId('launch-scenario-btn'))
+    await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
+    expect(mockStartRun.mock.calls[0][0].dataset_names).toEqual([...scenario.default_datasets, 'ds_a'])
+    expect(mockStartRun.mock.calls[0][0]).not.toHaveProperty('max_dataset_size')
+  })
+
+  it('renders accurate combined, no-cap, and heterogeneous dataset limit semantics', async () => {
+    const combinedScenario = makeScenario({
+      default_datasets: ['harmbench', 'xstest'],
+      dataset_size_limit: {
+        default_scope: 'combined',
+        default_count: 5,
+        override_scope: 'combined',
+      },
+    })
+    mockGetScenario.mockResolvedValue(combinedScenario)
+    const user = userEvent.setup()
+    const view = renderDetail('/scenarios/foundry.red_team_agent')
+    await screen.findByTestId('scenario-target-select')
+    await user.click(screen.getByRole('button', { name: 'Advanced options' }))
+    expect(screen.getByRole('spinbutton', {
+      name: 'Maximum objectives across selected datasets',
+    })).toHaveValue(5)
+    expect(screen.getByText(/Scenario default: up to 5 objectives across the selected datasets/))
+      .toBeInTheDocument()
+    expect(screen.getByRole('complementary', { name: 'Run preview' }))
+      .toHaveTextContent('5 total (scenario default)')
+
+    view.unmount()
+    mockGetScenario.mockResolvedValue(makeScenario())
+    const noCapView = renderDetail('/scenarios/foundry.red_team_agent')
+    await screen.findByTestId('scenario-target-select')
+    await user.click(screen.getByRole('button', { name: 'Advanced options' }))
+    expect(screen.getByText(/No scenario default cap/)).toBeInTheDocument()
+    expect(screen.getByRole('complementary', { name: 'Run preview' }))
+      .toHaveTextContent('No additional objective cap')
+
+    noCapView.unmount()
+    mockGetScenario.mockResolvedValue(makeScenario({
+      default_datasets: ['harmbench', 'xstest'],
+      dataset_size_limit: {
+        default_scope: 'heterogeneous',
+        default_count: null,
+        override_scope: 'per_dataset',
+      },
+    }))
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
+    await user.click(screen.getByRole('button', { name: 'Advanced options' }))
+    expect(screen.getByText(/Scenario defaults vary by dataset/)).toBeInTheDocument()
+    expect(screen.getByRole('complementary', { name: 'Run preview' }))
+      .toHaveTextContent('Varies by dataset (scenario default)')
+  })
+
+  it('disables dataset-size overrides when the scenario manages its population directly', async () => {
+    mockGetScenario.mockResolvedValue(makeScenario({
+      dataset_size_limit: {
+        default_scope: 'none',
+        default_count: null,
+        override_scope: 'unsupported',
+      },
+    }))
+    const user = userEvent.setup()
+    renderDetail('/scenarios/foundry.red_team_agent')
+    await screen.findByTestId('scenario-target-select')
+    await user.click(screen.getByRole('button', { name: 'Advanced options' }))
 
-    await user.type(screen.getByTestId('dataset-override-input'), 'ds_a, ds_b')
-    await user.type(screen.getByTestId('max-dataset-size-input'), '25')
-    await user.type(screen.getByTestId('harm-categories-filter-input'), 'cyber, violence')
-    await user.type(screen.getByTestId('data-types-filter-input'), 'text, image_path')
-    await confirmRunPreview(user)
+    expect(screen.getByRole('spinbutton', { name: 'Maximum objectives' })).toBeDisabled()
+    expect(screen.getByText(
+      'This scenario manages its objective population directly and does not support a dataset-size override.',
+    )).toBeInTheDocument()
+    expect(screen.queryByTestId('restore-default-dataset-size')).not.toBeInTheDocument()
+    expect(screen.getByRole('complementary', { name: 'Run preview' }))
+      .toHaveTextContent('No additional objective cap')
+  })
+
+  it('filters datasets and sends the exact changed selection to estimate and launch', async () => {
+    const user = userEvent.setup()
+    renderDetail('/scenarios/foundry.red_team_agent')
+    await screen.findByTestId('scenario-target-select')
+
+    await user.type(screen.getByRole('textbox', { name: 'Search datasets' }), 'ds_')
+    expect(screen.queryByTestId('dataset-harmbench')).not.toBeInTheDocument()
+    expect(screen.getByTestId('dataset-ds_a')).toBeInTheDocument()
+    await user.click(screen.getByTestId('dataset-ds_a'))
+    await user.clear(screen.getByRole('textbox', { name: 'Search datasets' }))
+    await user.click(screen.getByTestId('dataset-harmbench'))
+    expect(screen.getByText('1 dataset selected')).toBeInTheDocument()
+    expect(screen.getByRole('complementary', { name: 'Run preview' })).toHaveTextContent('ds_a')
+    expect(screen.getByRole('complementary', { name: 'Run preview' })).not.toHaveTextContent('harmbench')
+    await user.click(screen.getByRole('button', { name: 'Advanced options' }))
+    await user.type(screen.getByTestId('advanced-max_dataset_size'), '25')
+    await user.click(screen.getByTestId('launch-scenario-btn'))
 
     await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
     const request = mockStartRun.mock.calls[0][0]
-    expect(request.dataset_names).toEqual(['ds_a', 'ds_b'])
+    expect(request.dataset_names).toEqual(['ds_a'])
     expect(request.max_dataset_size).toBe(25)
-    expect(request.dataset_filters).toEqual({
-      harm_categories: ['cyber', 'violence'],
-      data_types: ['text', 'image_path'],
-    })
     await waitFor(() => expect(mockEstimateRun).toHaveBeenLastCalledWith(
       'foundry.red_team_agent',
       expect.objectContaining({
         target_name: 'target-a',
         techniques: ['default_technique'],
-        dataset_names: ['ds_a', 'ds_b'],
+        dataset_names: ['ds_a'],
         max_dataset_size: 25,
-        dataset_filters: {
-          harm_categories: ['cyber', 'violence'],
-          data_types: ['text', 'image_path'],
-        },
         include_baseline: true,
       }),
       expect.any(AbortSignal),
@@ -797,32 +1941,134 @@ describe('ScenarioDetail', () => {
     expect(mockEstimateRun.mock.calls.at(-1)?.[1]).not.toHaveProperty('labels')
   })
 
-  it('rejects a non-positive-integer max dataset size', async () => {
+  it('restores dataset defaults and removes the estimate and launch override', async () => {
     const user = userEvent.setup()
-    renderDetail('/scanner/foundry.red_team_agent')
-    await screen.findByTestId('scenario-target-select')
+    renderDetail('/scenarios/foundry.red_team_agent')
+    await screen.findByTestId('dataset-ds_a')
+
+    await user.click(screen.getByTestId('dataset-ds_a'))
+    await user.click(screen.getByTestId('dataset-harmbench'))
+    expect(screen.getByTestId('restore-default-datasets')).toBeEnabled()
+    await user.click(screen.getByTestId('restore-default-datasets'))
+    expect(screen.getByTestId('dataset-harmbench')).toBeChecked()
+    expect(screen.getByTestId('dataset-ds_a')).not.toBeChecked()
 
-    await user.type(screen.getByTestId('max-dataset-size-input'), '0')
     await user.click(screen.getByTestId('launch-scenario-btn'))
+    await waitFor(() => expect(mockStartRun).toHaveBeenCalled())
+    expect(mockStartRun.mock.calls[0][0]).not.toHaveProperty('dataset_names')
+    await waitFor(() => expect(mockEstimateRun).toHaveBeenLastCalledWith(
+      'foundry.red_team_agent',
+      expect.not.objectContaining({ dataset_names: expect.anything() }),
+      expect.any(AbortSignal),
+    ))
+  })
+
+  it('requires one dataset when the scenario declares defaults', async () => {
+    const user = userEvent.setup()
+    renderDetail('/scenarios/foundry.red_team_agent')
+    await screen.findByTestId('dataset-harmbench')
+
+    await user.click(screen.getByTestId('dataset-harmbench'))
+
+    expect(screen.getAllByText('Select at least one dataset.')).not.toHaveLength(0)
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+    expect(mockStartRun).not.toHaveBeenCalled()
+  })
 
-    expect(await screen.findByRole('alert')).toHaveTextContent(
-      'Max dataset size must be a positive integer.',
+  it('keeps scenario defaults usable when the dataset catalog fails', async () => {
+    mockListDatasets.mockRejectedValueOnce({
+      isAxiosError: true,
+      response: { status: 503, data: { detail: 'Catalog unavailable' } },
+    })
+    renderDetail('/scenarios/foundry.red_team_agent')
+
+    expect(await screen.findByTestId('dataset-catalog-error')).toHaveTextContent(
+      'Registered datasets couldn’t be loaded. Scenario defaults remain available. Catalog unavailable',
     )
+    expect(screen.getByTestId('dataset-harmbench')).toBeChecked()
+    expect(screen.getByTestId('launch-scenario-btn')).not.toBeDisabled()
+  })
+
+  it('shows a loading state without hiding known scenario defaults', async () => {
+    mockListDatasets.mockReturnValueOnce(new Promise(() => {}))
+    renderDetail('/scenarios/foundry.red_team_agent')
+
+    expect(await screen.findByTestId('dataset-catalog-loading')).toBeInTheDocument()
+    expect(screen.getByTestId('dataset-harmbench')).toBeChecked()
+  })
+
+  it('exposes the bounded dataset picker to keyboard and assistive technology', async () => {
+    const user = userEvent.setup()
+    renderDetail('/scenarios/foundry.red_team_agent')
+    await screen.findByTestId('dataset-ds_a')
+
+    expect(screen.getByRole('group', { name: 'Datasets' })).toBeInTheDocument()
+    expect(screen.getByRole('textbox', { name: 'Search datasets' })).toBeInTheDocument()
+    const dataset = screen.getByRole('checkbox', { name: 'ds_a' })
+    dataset.focus()
+    await user.keyboard('[Space]')
+    expect(dataset).toBeChecked()
+  })
+
+  it('rejects a non-positive-integer max dataset size', async () => {
+    const user = userEvent.setup()
+    renderDetail('/scenarios/foundry.red_team_agent')
+    await screen.findByTestId('scenario-target-select')
+
+    await user.click(screen.getByRole('button', { name: 'Advanced options' }))
+    expect(screen.getByText(/Maximum times to resume the scenario after an exception/)).toBeInTheDocument()
+    expect(screen.queryByText(/separate from Adaptive trying another technique/)).not.toBeInTheDocument()
+    await user.type(screen.getByTestId('advanced-max_dataset_size'), '0')
+
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+    expect(screen.getByText('Enter a whole number of 1 or more.')).toBeInTheDocument()
     expect(mockStartRun).not.toHaveBeenCalled()
   })
 
+  it('blocks signed and decimal dataset-size input before it changes the controlled value', async () => {
+    const scenario = makeAdaptiveScenario()
+    mockGetScenario.mockResolvedValue(scenario)
+    mockEstimateRun.mockImplementation(
+      async (_scenarioName, request: ScenarioRunSizeEstimateRequest) =>
+        makeFullyCompatibleAdaptiveEstimateForRequest(scenario, request),
+    )
+    const user = userEvent.setup()
+    renderDetail('/scenarios/adaptive.text_adaptive')
+    await screen.findByTestId('scenario-target-select')
+    await user.click(screen.getByRole('button', { name: 'Advanced options' }))
+    const input = screen.getByTestId('advanced-max_dataset_size')
+    await waitFor(() => expect(mockEstimateRun).toHaveBeenCalled())
+    const requestCount = mockEstimateRun.mock.calls.length
+
+    await user.clear(input)
+    await user.type(input, '-8')
+    expect(input).toHaveValue(null)
+    expect(input).toHaveAttribute('aria-invalid', 'true')
+    expect(screen.getByText('Enter a whole number of 1 or more.')).toBeInTheDocument()
+    await new Promise((resolve) => window.setTimeout(resolve, 350))
+    expect(mockEstimateRun).toHaveBeenCalledTimes(requestCount)
+
+    await user.click(input)
+    await user.paste('1.5')
+    expect(input).toHaveValue(null)
+    expect(screen.getByRole('complementary', { name: 'Run preview' }))
+      .toHaveTextContent('4 per dataset (scenario default)')
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+  })
+
   it('validates advanced concurrency and retry bounds before launching', async () => {
     const user = userEvent.setup()
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
+    await user.click(screen.getByRole('button', { name: 'Advanced options' }))
     fireEvent.change(screen.getByTestId('max-concurrency-input'), { target: { value: '500' } })
     fireEvent.blur(screen.getByTestId('max-concurrency-input'))
-    await user.click(screen.getByTestId('launch-scenario-btn'))
 
-    expect(await screen.findByRole('alert')).toHaveTextContent(
+    expect(screen.getByTestId('launch-scenario-btn')).toBeDisabled()
+    expect(screen.getByText(
       'Max concurrency must be an integer from 1 to 100.',
-    )
+    )).toBeInTheDocument()
     expect(mockStartRun).not.toHaveBeenCalled()
   })
 
@@ -830,10 +2076,10 @@ describe('ScenarioDetail', () => {
     const user = userEvent.setup()
     mockStartRun.mockResolvedValueOnce({ scenario_result_id: 'sr-1' })
 
-    renderDetail('/scanner/foundry.red_team_agent', { labels: { operator: 'roakey', operation: 'op1' } })
+    renderDetail('/scenarios/foundry.red_team_agent', { labels: { operator: 'roakey', operation: 'op1' } })
     await screen.findByTestId('scenario-target-select')
 
-    await confirmRunPreview(user)
+    await user.click(screen.getByTestId('launch-scenario-btn'))
 
     await waitFor(() => expect(mockStartRun).toHaveBeenCalledTimes(1))
     expect(mockStartRun).toHaveBeenCalledWith({
@@ -847,7 +2093,7 @@ describe('ScenarioDetail', () => {
     })
   })
 
-  it('uses effective Jailbreak defaults and sends only prompt_sending', async () => {
+  it('sends only prompt_sending for the Jailbreak regression and displays the backend total of 8', async () => {
     const user = userEvent.setup()
     mockGetScenario.mockResolvedValue(
       makeScenario({
@@ -884,11 +2130,22 @@ describe('ScenarioDetail', () => {
       }),
     )
     mockEstimateRun.mockResolvedValue({
-      estimated_attack_count: 8,
+      version: 1,
+      status: 'exact',
+      total_attack_count: 8,
+      minimum_attack_count: null,
+      maximum_attack_count: null,
+      condition: null,
       components: [
         {
           label: 'Prompt sending',
           count: 8,
+          factors: [
+            { label: 'selected seed groups', count: 4 },
+            { label: 'concrete techniques', count: 1 },
+            { label: 'jailbreak templates', count: 2 },
+            { label: 'attempts', count: 1 },
+          ],
           is_baseline: false,
           note: null,
         },
@@ -910,17 +2167,18 @@ describe('ScenarioDetail', () => {
           selection_note: 'One incompatible group is excluded.',
         },
       ],
-      effective_parameters: {
-        num_jailbreaks: 2,
-        num_jailbreak_attempts: 1,
-      },
-      note: 'The backend total is authoritative.',
+      adaptive_details: null,
+      note: 'The planned total is authoritative.',
+      retries_included: false,
     })
 
-    renderDetail('/scanner/airt.jailbreak')
+    renderDetail('/scenarios/airt.jailbreak')
     await screen.findByTestId('scenario-target-select')
 
+    await user.click(screen.getByTestId('technique-mode-custom'))
     await user.click(screen.getByTestId('technique-jailbreak_system_prompt'))
+    await user.clear(screen.getByTestId('scenario-param-num_jailbreaks'))
+    await user.type(screen.getByTestId('scenario-param-num_jailbreaks'), '2')
     await user.clear(screen.getByTestId('scenario-param-num_jailbreak_attempts'))
     await user.type(screen.getByTestId('scenario-param-num_jailbreak_attempts'), '1')
     await user.click(screen.getByTestId('baseline-checkbox'))
@@ -934,6 +2192,7 @@ describe('ScenarioDetail', () => {
       include_baseline: false,
       labels: { operator: 'roakey' },
       scenario_params: {
+        num_jailbreaks: 2,
         num_jailbreak_attempts: 1,
       },
     }
@@ -942,6 +2201,7 @@ describe('ScenarioDetail', () => {
       techniques: ['prompt_sending'],
       include_baseline: false,
       scenario_params: {
+        num_jailbreaks: 2,
         num_jailbreak_attempts: 1,
       },
     }
@@ -951,23 +2211,18 @@ describe('ScenarioDetail', () => {
       expectedEstimateRequest,
       expect.any(AbortSignal),
     ))
-    const estimate = screen.getByTestId('run-estimate')
-    expect(within(estimate).getByText('num_jailbreaks').parentElement).toHaveTextContent(
-      'num_jailbreaks2',
-    )
-    const preview = await openRunPreview(user)
-    expect(within(preview).getByText('target-a')).toBeInTheDocument()
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
     expect(within(preview).getByText('prompt_sending')).toBeInTheDocument()
     expect(within(preview).getByText('harmbench')).toBeInTheDocument()
-    expect(within(preview).getByText('num_jailbreaks').parentElement).toHaveTextContent(
-      'num_jailbreaks2',
-    )
-    expect(within(preview).getByText('8 attacks')).toBeInTheDocument()
-    expect(within(preview).getByText('Prompt sending: 8 = 8')).toBeInTheDocument()
-    expect(within(preview).queryByText('Backend estimate')).not.toBeInTheDocument()
-    expect(within(preview).queryByText('Current configuration')).not.toBeInTheDocument()
+    expect(within(preview).getByText('Not included')).toBeInTheDocument()
+    expect(within(preview).getByRole('group', {
+      name: '1 technique multiplied by 4 objectives multiplied by 2 jailbreak templates multiplied by 1 attempt equals 8 planned attacks.',
+    })).toBeInTheDocument()
+    expect(within(preview).getByText('4 objectives from harmbench · 5 available')).toBeInTheDocument()
+    expect(within(preview).getByText('Jailbreak templates: 2')).toBeInTheDocument()
+    expect(within(preview).queryByText(/logical seed groups|selected seed groups/i)).not.toBeInTheDocument()
 
-    await user.click(screen.getByTestId('confirm-launch-scenario-btn'))
+    await user.click(screen.getByTestId('launch-scenario-btn'))
 
     await waitFor(() => expect(mockStartRun).toHaveBeenCalledTimes(1))
     expect(mockStartRun).toHaveBeenCalledWith(expectedRunRequest)
@@ -982,10 +2237,10 @@ describe('ScenarioDetail', () => {
     const user = userEvent.setup()
     mockStartRun.mockResolvedValueOnce({ scenario_result_id: 'sr/1' })
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
-    await confirmRunPreview(user)
+    await user.click(screen.getByTestId('launch-scenario-btn'))
 
     await waitFor(() =>
       expect(mockNavigate).toHaveBeenCalledWith(
@@ -1002,10 +2257,10 @@ describe('ScenarioDetail', () => {
       response: { status: 400, data: { detail: 'Invalid target' } },
     })
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
-    await confirmRunPreview(user)
+    await user.click(screen.getByTestId('launch-scenario-btn'))
 
     expect(await screen.findByText('Invalid target')).toBeInTheDocument()
     expect(screen.getByTestId('launch-scenario-btn')).not.toBeDisabled()
@@ -1013,7 +2268,6 @@ describe('ScenarioDetail', () => {
   })
 
   it('guards against a duplicate submit from a fast double click', async () => {
-    const user = userEvent.setup()
     let resolveStartRun: (value: { scenario_result_id: string }) => void = () => {}
     mockStartRun.mockReturnValue(
       new Promise((resolve) => {
@@ -1021,11 +2275,10 @@ describe('ScenarioDetail', () => {
       }),
     )
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
-    await openRunPreview(user)
 
-    const button = screen.getByTestId('confirm-launch-scenario-btn')
+    const button = screen.getByTestId('launch-scenario-btn')
     // Fire two rapid clicks without waiting between them (userEvent.click awaits internally,
     // so dispatch native clicks to simulate a true double-click within one tick).
     act(() => {
@@ -1038,7 +2291,7 @@ describe('ScenarioDetail', () => {
     await waitFor(() => expect(button).not.toBeDisabled())
   })
 
-  it('preserves entered values and keeps the preview open after a failed submission', async () => {
+  it('preserves entered values and preview content after a failed submission', async () => {
     const user = userEvent.setup()
     mockGetScenario.mockResolvedValue(
       makeScenario({
@@ -1059,15 +2312,14 @@ describe('ScenarioDetail', () => {
       response: { status: 400, data: { detail: 'boom' } },
     })
 
-    renderDetail('/scanner/foundry.red_team_agent')
+    renderDetail('/scenarios/foundry.red_team_agent')
     await screen.findByTestId('scenario-target-select')
 
     await user.selectOptions(screen.getByTestId('scenario-target-select'), 'target-b')
-    await user.click(screen.getByTestId('technique-default_technique'))
-    await user.click(screen.getByTestId('technique-crescendo'))
+    await user.click(screen.getByTestId('technique-mode-custom'))
     await user.clear(screen.getByTestId('scenario-param-attempts'))
     await user.type(screen.getByTestId('scenario-param-attempts'), '3')
-    await confirmRunPreview(user)
+    await user.click(screen.getByTestId('launch-scenario-btn'))
 
     await screen.findByText('boom')
     expect(screen.getByTestId('scenario-target-select')).toHaveValue('target-b')
@@ -1075,10 +2327,10 @@ describe('ScenarioDetail', () => {
     expect(screen.getByTestId('technique-default_technique')).not.toBeChecked()
     expect(screen.getByTestId('scenario-param-attempts')).toHaveValue(3)
 
-    const preview = screen.getByRole('dialog', { name: 'Run preview' })
+    const preview = screen.getByRole('complementary', { name: 'Run preview' })
     expect(within(preview).getByText('target-b')).toBeInTheDocument()
     expect(within(preview).getByText('crescendo')).toBeInTheDocument()
     expect(within(preview).getByText('harmbench')).toBeInTheDocument()
-    expect(within(preview).getByText('attempts').parentElement).toHaveTextContent('attempts3')
+    expect(within(preview).getByText('3')).toBeInTheDocument()
   })
 })
diff --git a/frontend/src/components/Scenarios/ScenarioDetail.tsx b/frontend/src/components/Scenarios/ScenarioDetail.tsx
index 5612b08641..2a5565ec79 100644
--- a/frontend/src/components/Scenarios/ScenarioDetail.tsx
+++ b/frontend/src/components/Scenarios/ScenarioDetail.tsx
@@ -1,54 +1,47 @@
 import { type FormEvent, useEffect, useMemo, useRef, useState } from 'react'
 
 import {
+  Accordion,
+  AccordionHeader,
+  AccordionItem,
+  AccordionPanel,
   Badge,
   Button,
   Checkbox,
-  Dialog,
-  DialogActions,
-  DialogBody,
-  DialogContent,
-  DialogSurface,
-  DialogTitle,
   Field,
   Input,
   MessageBar,
   MessageBarBody,
-  mergeClasses,
+  Radio,
+  RadioGroup,
   Select,
   Spinner,
   SpinButton,
   Text,
-  Tooltip,
-  ToggleButton,
 } from '@fluentui/react-components'
-import {
-  ArrowLeftRegular,
-  ArrowSyncRegular,
-  InfoRegular,
-  SettingsRegular,
-} from '@fluentui/react-icons'
+import { ArrowLeftRegular, ArrowSyncRegular, SettingsRegular } from '@fluentui/react-icons'
 import { Link, useNavigate, useParams } from 'react-router'
 
 import MarkdownContent from '@/components/Markdown/MarkdownContent'
-import ParameterField from '@/components/Parameters/ParameterField'
+import ParameterField, {
+  type RejectedNumberInputReason,
+} from '@/components/Parameters/ParameterField'
 import {
   buildParametersFromForm,
   getInitialFormValues,
   type ParameterFormValue,
 } from '@/components/Parameters/parameterForm'
 import type { ViewName } from '@/components/Sidebar/Navigation'
-import { scenariosApi, targetsApi } from '@/services/api'
+import { datasetsApi, scenariosApi, targetsApi } from '@/services/api'
 import { toApiError } from '@/services/errors'
 import type {
   Parameter,
   RegisteredScenario,
   RunScenarioRequest,
-  ScenarioRunEstimate,
+  ScenarioDatasetSizeLimit,
   ScenarioRunEstimateResult,
   ScenarioRunSizeEstimateRequest,
   ScenarioRunEstimateState,
-  ScenarioTechniqueSummary,
   TargetInstance,
 } from '@/types'
 import { fetchAllPages } from '@/utils/fetchAllPages'
@@ -57,13 +50,25 @@ import { targetModelName } from '@/utils/targetIdentity'
 
 import { useScenarioDetailStyles } from './ScenarioDetail.styles'
 import { ScenarioRunEstimateDetails } from './ScenarioRunEstimate'
+import { formatAdaptiveCapFeedback } from './scenarioAdaptiveCap'
 import { normalizeScenarioMarkdown } from './scenarioMarkdown'
 import { mapScenarioRunEstimate } from './scenarioRunEstimateAdapter'
-import { techniqueSetName } from './scenarioTechniqueSets'
+import {
+  techniqueSetDisplayName,
+  techniqueSetMembers,
+  techniqueSetOptionLabel,
+} from './scenarioTechniqueSets'
 
 /** Items requested per target page while paging through the full list. */
 const TARGET_PAGE_SIZE = 200
 
+function targetOptionLabel(target: TargetInstance): string {
+  const modelName = targetModelName(target)
+  return modelName
+    ? `${target.target_registry_name} (${modelName})`
+    : target.target_registry_name
+}
+
 /**
  * Common/opaque parameters every scenario declares via
  * `Scenario._common_scenario_parameters` — the launch form already exposes a
@@ -89,31 +94,26 @@ const MAX_MAX_RETRIES = 20
 const DEFAULT_MAX_CONCURRENCY = 10
 const DEFAULT_MAX_RETRIES = 0
 const ESTIMATE_DEBOUNCE_MS = 300
-
-function targetOptionLabel(target: TargetInstance): string {
-  const modelName = targetModelName(target)
-  return modelName
-    ? `${target.target_registry_name} (${modelName})`
-    : target.target_registry_name
-}
-
-function defaultMaxDatasetSize(scenario: RegisteredScenario): string {
-  const datasets = scenario.default_run_size.datasets
-  if (datasets.length === 0) {
-    return ''
-  }
-
-  for (const dataset of datasets) {
-    if (dataset.configured_caps.length === 0) {
-      return ''
-    }
-  }
-
-  const selectedGroupCount = datasets.reduce(
-    (total, dataset) => total + dataset.selected_seed_group_count,
-    0,
-  )
-  return selectedGroupCount > 0 ? String(selectedGroupCount) : ''
+const TEXT_ADAPTIVE_SCENARIO_NAME = 'adaptive.text_adaptive'
+const CUSTOM_TECHNIQUE_SET_VALUE = '__custom__'
+const MAX_ATTEMPTS_PARAMETER_NAME = 'max_attempts_per_objective'
+const MAX_ATTEMPTS_DISPLAY_LABEL = 'Maximum techniques per objective'
+const MAX_ATTEMPTS_DEFAULT_HINT = 'Leave blank to use the default of 3.'
+const MAX_ATTEMPTS_BEHAVIOR_HINT = [
+  'This is a per-objective limit, not a total-run budget.',
+  'Adaptive stops after the first success, and incompatible techniques are skipped.',
+  'This is separate from retries.',
+].join(' ')
+const MAX_ATTEMPTS_VALIDATION_MESSAGE = 'Enter a whole number of 1 or more.'
+const MAX_DATASET_SIZE_VALIDATION_MESSAGE = 'Enter a whole number of 1 or more.'
+const CORRECT_HIGHLIGHTED_SETTING_MESSAGE = 'Correct the highlighted setting to calculate this run.'
+const MAX_DATASET_SIZE_PARAMETER: Parameter = {
+  name: 'max_dataset_size',
+  type_name: 'int',
+  required: false,
+  default: null,
+  choices: null,
+  is_list: false,
 }
 
 /** Resolves a Fluent `SpinButton` change event to a numeric value, preferring the parsed `value` over the raw `displayValue`. */
@@ -127,48 +127,62 @@ function resolveSpinButtonValue(data: { value?: number | null; displayValue?: st
 
 type LoadStatus = 'loading' | 'success' | 'not-found' | 'error'
 
+type TechniqueSelection =
+  | {
+      mode: 'preset'
+      preset: string
+    }
+  | {
+      mode: 'custom'
+    }
+
 interface TechniqueOptions {
-  techniques: ScenarioTechniqueSummary[]
-  defaultTechniques: string[]
+  presets: string[]
+  concrete: string[]
+  defaultSelection: TechniqueSelection
+  initialCustomTechniques: string[]
 }
 
+/** Options rendered for technique selection: exclusive presets first, then concrete techniques. */
 function uniqueTechniqueOptions(scenario: RegisteredScenario): TechniqueOptions {
   const aggregateNames = new Set(scenario.aggregate_techniques)
-  const summariesByName = new Map(
-    scenario.technique_summaries.map((summary) => [summary.name, summary]),
-  )
-  const techniques: ScenarioTechniqueSummary[] = []
-  const seen = new Set<string>()
-  for (const name of scenario.all_techniques) {
-    if (!aggregateNames.has(name) && !seen.has(name)) {
-      techniques.push(summariesByName.get(name) ?? { name, description: null, tags: [] })
-      seen.add(name)
+  const defaultIsPreset = aggregateNames.has(scenario.default_technique)
+  const seenPresets = new Set<string>()
+  const presets: string[] = []
+  for (const name of scenario.aggregate_techniques) {
+    if (!seenPresets.has(name)) {
+      seenPresets.add(name)
+      presets.push(name)
     }
   }
-  const concreteNames = new Set(techniques.map((technique) => technique.name))
-  const defaultTechniques = scenario.default_techniques.filter((name) => concreteNames.has(name))
-  if (defaultTechniques.length === 0 && concreteNames.has(scenario.default_technique)) {
-    defaultTechniques.push(scenario.default_technique)
+  const seenConcrete = new Set<string>()
+  const concrete: string[] = []
+  const concreteCandidates = defaultIsPreset
+    ? scenario.all_techniques
+    : [scenario.default_technique, ...scenario.all_techniques]
+  for (const name of concreteCandidates) {
+    if (!aggregateNames.has(name) && !seenConcrete.has(name)) {
+      seenConcrete.add(name)
+      concrete.push(name)
+    }
   }
-  return { techniques, defaultTechniques }
+  const defaultSelection: TechniqueSelection = defaultIsPreset
+    ? { mode: 'preset', preset: scenario.default_technique }
+    : { mode: 'custom' }
+  const initialCustomTechniques = defaultIsPreset ? [] : [scenario.default_technique]
+  return { presets, concrete, defaultSelection, initialCustomTechniques }
 }
 
-interface SelectableTechnique extends ScenarioTechniqueSummary {
-  isBaseline: boolean
-  disabled: boolean
-}
-
-const BASELINE_TECHNIQUE: ScenarioTechniqueSummary = {
-  name: 'baseline',
-  description: 'Sends each objective directly to the target for comparison.',
-  tags: ['baseline', 'single_turn'],
+function sameStringSet(left: string[], right: string[]): boolean {
+  const leftSet = new Set(left)
+  const rightSet = new Set(right)
+  return leftSet.size === rightSet.size && [...leftSet].every((value) => rightSet.has(value))
 }
 
-function parseDatasetNames(datasetOverride: string): string[] {
-  return datasetOverride
-    .split(',')
-    .map((entry) => entry.trim())
-    .filter((entry) => entry.length > 0)
+function parameterDisplayLabel(parameter: Parameter, usesAdaptiveTechniqueSelection: boolean): string {
+  return usesAdaptiveTechniqueSelection && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME
+    ? MAX_ATTEMPTS_DISPLAY_LABEL
+    : parameter.name
 }
 
 function formatParameterPreview(value: ParameterFormValue | undefined): string {
@@ -178,96 +192,97 @@ function formatParameterPreview(value: ParameterFormValue | undefined): string {
   return value?.trim() || 'Not set'
 }
 
-function formatEffectiveParameterPreview(
-  parameterName: string,
-  value: ParameterFormValue | undefined,
-  estimate: ScenarioRunEstimate | undefined,
-): string {
-  const configuredValue = formatParameterPreview(value)
-  if (configuredValue !== 'Not set') {
-    return configuredValue
-  }
-  const effectiveValue = estimate?.effectiveParameters[parameterName]
-  if (Array.isArray(effectiveValue)) {
-    return effectiveValue.length > 0 ? effectiveValue.join(', ') : 'Not set'
+function maxAttemptsValidationError(value: ParameterFormValue | undefined): string | undefined {
+  const raw = typeof value === 'string' ? value.trim() : ''
+  if (raw.length === 0) {
+    return undefined
   }
-  return effectiveValue?.toString() ?? 'Not set'
+  const parsed = Number(raw)
+  return Number.isSafeInteger(parsed) && parsed >= 1
+    ? undefined
+    : MAX_ATTEMPTS_VALIDATION_MESSAGE
 }
-function estimateFromState(state: ScenarioRunEstimateState): ScenarioRunEstimate | undefined {
-  switch (state.status) {
-    case 'available':
-    case 'conditional':
-    case 'refreshing':
-    case 'stale':
-      return state.estimate
-    default:
-      return undefined
+
+function datasetSizeFieldLabel(limit: ScenarioDatasetSizeLimit): string {
+  if (limit.override_scope === 'unsupported') {
+    return 'Maximum objectives'
   }
+  return limit.override_scope === 'per_dataset'
+    ? 'Maximum objectives per dataset'
+    : 'Maximum objectives across selected datasets'
 }
 
-function formatAtomicAttackCount(state: ScenarioRunEstimateState): string {
-  const estimate = estimateFromState(state)
-  if (!estimate) {
-    return state.status === 'loading' ? 'Calculating...' : 'Unavailable'
+function datasetSizeHint(limit: ScenarioDatasetSizeLimit): string {
+  if (limit.override_scope === 'unsupported') {
+    return 'This scenario manages its objective population directly and does not support a dataset-size override.'
+  }
+  if (limit.default_scope === 'per_dataset' && limit.default_count !== null) {
+    return `Scenario default: up to ${limit.default_count.toLocaleString()} objectives from each selected dataset. Enter another whole number to override it, or leave blank to use the scenario default.`
+  }
+  if (limit.default_scope === 'combined' && limit.default_count !== null) {
+    return `Scenario default: up to ${limit.default_count.toLocaleString()} objectives across the selected datasets. Enter another whole number to override it, or leave blank to use the scenario default.`
   }
-  if (estimate.total !== null) {
-    return estimate.total.toLocaleString()
+  if (limit.default_scope === 'heterogeneous') {
+    const replacement = limit.override_scope === 'per_dataset'
+      ? 'a uniform per-dataset maximum'
+      : 'a combined maximum'
+    return `Scenario defaults vary by dataset. Enter a whole number to replace them with ${replacement}, or leave blank to keep the scenario defaults.`
+  }
+  const scope = limit.override_scope === 'per_dataset'
+    ? 'objectives from each selected dataset'
+    : 'objectives across the selected datasets'
+  return `No scenario default cap. Enter a whole number to limit ${scope}, or leave blank for no additional cap.`
+}
+
+function formatDatasetSizePreview(
+  limit: ScenarioDatasetSizeLimit,
+  maxDatasetSize: string,
+  hasOverride: boolean,
+): string {
+  const parsed = Number(maxDatasetSize.trim())
+  if (hasOverride && Number.isSafeInteger(parsed) && parsed >= 1) {
+    return limit.override_scope === 'per_dataset'
+      ? `${parsed.toLocaleString()} per dataset (override)`
+      : `${parsed.toLocaleString()} total (override)`
   }
-  if (estimate.minimum != null && estimate.maximum != null) {
-    return estimate.minimum === estimate.maximum
-      ? estimate.minimum.toLocaleString()
-      : `${estimate.minimum.toLocaleString()}-${estimate.maximum.toLocaleString()}`
+  if (limit.default_scope === 'per_dataset' && limit.default_count !== null) {
+    return `${limit.default_count.toLocaleString()} per dataset (scenario default)`
   }
-  if (estimate.minimum != null) {
-    return `At least ${estimate.minimum.toLocaleString()}`
+  if (limit.default_scope === 'combined' && limit.default_count !== null) {
+    return `${limit.default_count.toLocaleString()} total (scenario default)`
   }
-  if (estimate.maximum != null) {
-    return `Up to ${estimate.maximum.toLocaleString()}`
+  if (limit.default_scope === 'heterogeneous') {
+    return 'Varies by dataset (scenario default)'
   }
-  return 'Varies'
+  return 'No additional objective cap'
 }
 
-function estimateNotes(state: ScenarioRunEstimateState): string | null {
-  const estimate = estimateFromState(state)
-  if (!estimate) {
-    return state.status === 'unavailable' ? state.note ?? state.label : null
+function maxDatasetSizeValidationError(value: string): string | undefined {
+  const raw = value.trim()
+  if (raw.length === 0) {
+    return undefined
   }
-  const notes = [
-    estimate.note,
-    ...estimate.components.map((component) => component.note),
-  ].filter((note): note is string => Boolean(note))
-  return notes.length > 0 ? notes.join('\n\n') : null
+  const parsed = Number(raw)
+  return Number.isSafeInteger(parsed) && parsed >= 1
+    ? undefined
+    : MAX_DATASET_SIZE_VALIDATION_MESSAGE
 }
 
-interface BuildEstimateRequestInput {
+interface BuildRunRequestInput {
   scenario: RegisteredScenario
   targetName: string
   techniques: string[]
   dynamicParameters: Parameter[]
   scenarioParamValues: Record<string, ParameterFormValue>
-  datasetOverride: string
+  selectedDatasets: string[]
   maxDatasetSize: string
-  harmCategoriesFilter: string
-  dataTypesFilter: string
-  includeBaseline: boolean
-}
-
-interface BuildRunRequestInput extends BuildEstimateRequestInput {
+  hasMaxDatasetSizeOverride: boolean
   maxConcurrency: number
   maxRetries: number
+  includeBaseline: boolean
   labels: Record<string, string>
 }
 
-type BuildEstimateRequestResult =
-  | {
-      ok: true
-      request: ScenarioRunSizeEstimateRequest
-    }
-  | {
-      ok: false
-      error: string
-    }
-
 type BuildRunRequestResult =
   | {
       ok: true
@@ -278,11 +293,6 @@ type BuildRunRequestResult =
       error: string
     }
 
-type SuccessfulEstimateResult = Extract<
-  ScenarioRunEstimateResult,
-  { status: 'available' | 'conditional' }
->
-
 type EstimateRequestState =
   | {
       status: 'resolved'
@@ -292,23 +302,73 @@ type EstimateRequestState =
   | {
       status: 'error'
       requestKey: string
-      error: string
+      summary: string
+      note?: string
+      maxAttemptsError?: string
+    }
+
+interface MappedEstimateError {
+  summary: string
+  note?: string
+  maxAttemptsError?: string
+}
+
+interface AdaptiveCandidateMetadata {
+  scopeKey: string
+  maximum: number
+}
+
+interface AdaptiveLimitNotice {
+  scopeKey: string
+  message: string
+  validationState: 'none' | 'warning'
+}
+
+function mapEstimateError(error: unknown): MappedEstimateError {
+  const detail = toApiError(error).detail
+  if (detail.includes(MAX_ATTEMPTS_PARAMETER_NAME)) {
+    return {
+      summary: CORRECT_HIGHLIGHTED_SETTING_MESSAGE,
+      maxAttemptsError: MAX_ATTEMPTS_VALIDATION_MESSAGE,
     }
+  }
+  return {
+    summary: 'Run size couldn’t be updated.',
+    note: detail,
+  }
+}
 
-function buildEstimateRequest({
+function buildRunRequest({
+  scenario,
   targetName,
   techniques,
   dynamicParameters,
   scenarioParamValues,
-  datasetOverride,
+  selectedDatasets,
   maxDatasetSize,
-  harmCategoriesFilter,
-  dataTypesFilter,
+  hasMaxDatasetSizeOverride,
+  maxConcurrency,
+  maxRetries,
   includeBaseline,
-}: BuildEstimateRequestInput): BuildEstimateRequestResult {
+  labels,
+}: BuildRunRequestInput): BuildRunRequestResult {
+  if (!targetName) {
+    return { ok: false, error: 'Select a target.' }
+  }
   if (techniques.length === 0) {
     return { ok: false, error: 'Select at least one technique.' }
   }
+  if (scenario.default_datasets.length > 0 && selectedDatasets.length === 0) {
+    return { ok: false, error: 'Select at least one dataset.' }
+  }
+  if (dynamicParameters.some((parameter) => parameter.name === MAX_ATTEMPTS_PARAMETER_NAME)) {
+    const maxAttemptsError = maxAttemptsValidationError(
+      scenarioParamValues[MAX_ATTEMPTS_PARAMETER_NAME],
+    )
+    if (maxAttemptsError) {
+      return { ok: false, error: maxAttemptsError }
+    }
+  }
 
   let scenarioParams: Record<string, unknown> | null = null
   if (dynamicParameters.length > 0) {
@@ -326,48 +386,17 @@ function buildEstimateRequest({
     if (!Number.isInteger(parsed) || parsed < 1) {
       return { ok: false, error: 'Max dataset size must be a positive integer.' }
     }
-    maxDatasetSizeValue = parsed
-  }
-  const datasetNames = parseDatasetNames(datasetOverride)
-  const request: ScenarioRunSizeEstimateRequest = {
-    techniques,
-    include_baseline: includeBaseline,
-  }
-  if (targetName) {
-    request.target_name = targetName
-  }
-  if (datasetNames.length > 0) {
-    request.dataset_names = datasetNames
-  }
-  if (maxDatasetSizeValue !== undefined) {
-    request.max_dataset_size = maxDatasetSizeValue
-  }
-  const harmCategories = parseDatasetNames(harmCategoriesFilter)
-  const dataTypes = parseDatasetNames(dataTypesFilter)
-  if (harmCategories.length > 0 || dataTypes.length > 0) {
-    request.dataset_filters = {
-      ...(harmCategories.length > 0 ? { harm_categories: harmCategories } : {}),
-      ...(dataTypes.length > 0 ? { data_types: dataTypes } : {}),
+    if (hasMaxDatasetSizeOverride) {
+      if (scenario.dataset_size_limit.override_scope === 'unsupported') {
+        return { ok: false, error: 'This scenario does not support a dataset-size override.' }
+      }
+      maxDatasetSizeValue = parsed
     }
   }
-  if (scenarioParams) {
-    request.scenario_params = scenarioParams
-  }
-  return { ok: true, request }
-}
-
-function buildRunRequest(input: BuildRunRequestInput): BuildRunRequestResult {
-  if (!input.targetName) {
-    return { ok: false, error: 'Select a target.' }
-  }
-  const estimateResult = buildEstimateRequest(input)
-  if (!estimateResult.ok) {
-    return estimateResult
-  }
   if (
-    !Number.isInteger(input.maxConcurrency)
-    || input.maxConcurrency < MIN_MAX_CONCURRENCY
-    || input.maxConcurrency > MAX_MAX_CONCURRENCY
+    !Number.isInteger(maxConcurrency)
+    || maxConcurrency < MIN_MAX_CONCURRENCY
+    || maxConcurrency > MAX_MAX_CONCURRENCY
   ) {
     return {
       ok: false,
@@ -375,9 +404,9 @@ function buildRunRequest(input: BuildRunRequestInput): BuildRunRequestResult {
     }
   }
   if (
-    !Number.isInteger(input.maxRetries)
-    || input.maxRetries < MIN_MAX_RETRIES
-    || input.maxRetries > MAX_MAX_RETRIES
+    !Number.isInteger(maxRetries)
+    || maxRetries < MIN_MAX_RETRIES
+    || maxRetries > MAX_MAX_RETRIES
   ) {
     return {
       ok: false,
@@ -385,31 +414,163 @@ function buildRunRequest(input: BuildRunRequestInput): BuildRunRequestResult {
     }
   }
 
-  const estimateRequest = estimateResult.request
   const request: RunScenarioRequest = {
-    scenario_name: input.scenario.scenario_name,
-    target_name: input.targetName,
-    techniques: estimateRequest.techniques,
-    max_concurrency: input.maxConcurrency,
-    max_retries: input.maxRetries,
-    include_baseline: estimateRequest.include_baseline,
-    labels: input.labels,
-  }
-  if (estimateRequest.dataset_names !== undefined) {
-    request.dataset_names = estimateRequest.dataset_names
+    scenario_name: scenario.scenario_name,
+    target_name: targetName,
+    techniques,
+    max_concurrency: maxConcurrency,
+    max_retries: maxRetries,
+    include_baseline: includeBaseline,
+    labels,
   }
-  if (estimateRequest.max_dataset_size !== undefined) {
-    request.max_dataset_size = estimateRequest.max_dataset_size
+  if (!sameStringSet(selectedDatasets, scenario.default_datasets)) {
+    request.dataset_names = selectedDatasets
   }
-  if (estimateRequest.dataset_filters !== undefined) {
-    request.dataset_filters = estimateRequest.dataset_filters
+  if (maxDatasetSizeValue !== undefined) {
+    request.max_dataset_size = maxDatasetSizeValue
   }
-  if (estimateRequest.scenario_params !== undefined) {
-    request.scenario_params = estimateRequest.scenario_params
+  if (scenarioParams) {
+    request.scenario_params = scenarioParams
   }
   return { ok: true, request }
 }
 
+function buildEstimateRequest(request: RunScenarioRequest): ScenarioRunSizeEstimateRequest {
+  const estimateRequest: ScenarioRunSizeEstimateRequest = {
+    target_name: request.target_name,
+    techniques: request.techniques,
+    include_baseline: request.include_baseline,
+  }
+  if (request.dataset_names !== undefined) {
+    estimateRequest.dataset_names = request.dataset_names
+  }
+  if (request.max_dataset_size !== undefined) {
+    estimateRequest.max_dataset_size = request.max_dataset_size
+  }
+  if (request.dataset_filters !== undefined) {
+    estimateRequest.dataset_filters = request.dataset_filters
+  }
+  if (request.scenario_params !== undefined) {
+    estimateRequest.scenario_params = request.scenario_params
+  }
+  return estimateRequest
+}
+
+type DatasetCatalogStatus = 'loading' | 'success' | 'error'
+
+interface DatasetPickerProps {
+  availableDatasets: string[]
+  defaultDatasets: string[]
+  selectedDatasets: string[]
+  status: DatasetCatalogStatus
+  error: string | null
+  disabled: boolean
+  invalid: boolean
+  onChange: (name: string, checked: boolean) => void
+  onRestoreDefaults: () => void
+}
+
+function DatasetPicker({
+  availableDatasets,
+  defaultDatasets,
+  selectedDatasets,
+  status,
+  error,
+  disabled,
+  invalid,
+  onChange,
+  onRestoreDefaults,
+}: DatasetPickerProps) {
+  const styles = useScenarioDetailStyles()
+  const [query, setQuery] = useState('')
+  const selectedSet = useMemo(() => new Set(selectedDatasets), [selectedDatasets])
+  const defaultSet = useMemo(() => new Set(defaultDatasets), [defaultDatasets])
+  const orderedDatasets = useMemo(() => {
+    const names = [...new Set([...availableDatasets, ...defaultDatasets])]
+    return names.sort((left, right) => {
+      const leftPriority = selectedSet.has(left) ? 0 : defaultSet.has(left) ? 1 : 2
+      const rightPriority = selectedSet.has(right) ? 0 : defaultSet.has(right) ? 1 : 2
+      return leftPriority - rightPriority || left.localeCompare(right)
+    })
+  }, [availableDatasets, defaultDatasets, defaultSet, selectedSet])
+  const normalizedQuery = query.trim().toLocaleLowerCase()
+  const visibleDatasets = normalizedQuery.length === 0
+    ? orderedDatasets
+    : orderedDatasets.filter((name) => name.toLocaleLowerCase().includes(normalizedQuery))
+  const selectedCount = selectedDatasets.length
+
+  return (
+    <>
+      <div className={styles.datasetPickerHeader}>
+        <Text aria-live="polite">
+          {selectedCount.toLocaleString()} dataset{selectedCount === 1 ? '' : 's'} selected
+        </Text>
+        <Button
+          className={styles.touchTarget}
+          appearance="subtle"
+          icon={<ArrowSyncRegular />}
+          disabled={disabled || sameStringSet(selectedDatasets, defaultDatasets)}
+          onClick={onRestoreDefaults}
+          data-testid="restore-default-datasets"
+        >
+          Restore defaults
+        </Button>
+      </div>
+      <Field
+        label="Search datasets"
+        hint="Search registered datasets, then select the datasets this run should use."
+        validationState={invalid ? 'error' : 'none'}
+        validationMessage={invalid ? 'Select at least one dataset.' : undefined}
+      >
+        <Input
+          className={styles.control}
+          value={query}
+          disabled={disabled}
+          onChange={(_, data) => setQuery(data.value)}
+          placeholder="Search datasets"
+          aria-label="Search datasets"
+          data-testid="dataset-search-input"
+        />
+      </Field>
+      {status === 'loading' && (
+        <Text size={200} className={styles.hint} role="status" data-testid="dataset-catalog-loading">
+          Loading registered datasets…
+        </Text>
+      )}
+      {status === 'error' && (
+        <MessageBar intent="error" data-testid="dataset-catalog-error">
+          <MessageBarBody role="alert">
+            Registered datasets couldn’t be loaded. Scenario defaults remain available.
+            {error ? ` ${error}` : ''}
+          </MessageBarBody>
+        </MessageBar>
+      )}
+      <div
+        className={styles.datasetList}
+        role="group"
+        aria-label="Datasets"
+        data-testid="dataset-picker-list"
+      >
+        {visibleDatasets.length > 0 ? (
+          visibleDatasets.map((name) => (
+            <Checkbox
+              className={styles.selectionControl}
+              key={name}
+              label={name}
+              checked={selectedSet.has(name)}
+              disabled={disabled}
+              onChange={(_, data) => onChange(name, data.checked === true)}
+              data-testid={`dataset-${name}`}
+            />
+          ))
+        ) : (
+          <Text className={styles.datasetEmptyState}>No datasets match this search.</Text>
+        )}
+      </div>
+    </>
+  )
+}
+
 interface ScenarioDetailProps {
   activeTarget: TargetInstance | null
   labels: Record<string, string>
@@ -510,8 +671,8 @@ function ScenarioDetailContent({
     return (
       <section className={styles.root} data-testid="scenario-detail" aria-label="Scenario detail">
         <div className={styles.content}>
-          <Link to="/scanner" className={styles.backLink}>
-            <ArrowLeftRegular /> Back to scanners
+          <Link to="/scenarios" className={styles.backLink}>
+            <ArrowLeftRegular /> Back to scenarios
           </Link>
           <div className={styles.centeredState} data-testid="scenario-not-found">
             <Text size={400}>Scenario &quot;{decodedScenarioName}&quot; was not found</Text>
@@ -526,8 +687,8 @@ function ScenarioDetailContent({
     return (
       <section className={styles.root} data-testid="scenario-detail" aria-label="Scenario detail">
         <div className={styles.content}>
-          <Link to="/scanner" className={styles.backLink}>
-            <ArrowLeftRegular /> Back to scanners
+          <Link to="/scenarios" className={styles.backLink}>
+            <ArrowLeftRegular /> Back to scenarios
           </Link>
           <div className={styles.centeredState} data-testid="scenario-error">
             <MessageBar intent="error">
@@ -560,7 +721,6 @@ function ScenarioDetailContent({
       targets={targets}
       activeTarget={activeTarget}
       labels={labels}
-      onNavigate={onNavigate}
     />
   )
 }
@@ -570,24 +730,21 @@ interface ScenarioLaunchFormProps {
   targets: TargetInstance[]
   activeTarget: TargetInstance | null
   labels: Record<string, string>
-  onNavigate: (view: ViewName) => void
 }
 
-function ScenarioLaunchForm({
-  scenario,
-  targets,
-  activeTarget,
-  labels,
-  onNavigate,
-}: ScenarioLaunchFormProps) {
+function ScenarioLaunchForm({ scenario, targets, activeTarget, labels }: ScenarioLaunchFormProps) {
   const styles = useScenarioDetailStyles()
   const navigate = useNavigate()
   const formId = `scenario-launch-${encodeURIComponent(scenario.scenario_name).replace(/%/g, '-')}`
 
-  const { techniques: techniqueOptions, defaultTechniques } = useMemo(
+  const { presets, concrete, defaultSelection, initialCustomTechniques } = useMemo(
     () => uniqueTechniqueOptions(scenario),
     [scenario],
   )
+  const techniqueSummaries = useMemo(
+    () => new Map(scenario.technique_summaries.map((summary) => [summary.name, summary])),
+    [scenario.technique_summaries],
+  )
   const dynamicParameters = useMemo(
     () => scenario.supported_parameters.filter(
       (parameter) => !COMMON_SCENARIO_PARAMETER_NAMES.has(parameter.name),
@@ -595,88 +752,73 @@ function ScenarioLaunchForm({
     [scenario.supported_parameters],
   )
   const isBaselineForbidden = scenario.baseline_policy === 'forbidden'
+  const usesAdaptiveTechniqueSelection = scenario.scenario_name === TEXT_ADAPTIVE_SCENARIO_NAME
 
   const [targetName, setTargetName] = useState(() => {
     if (activeTarget && targets.some((target) =>
       target.target_registry_name === activeTarget.target_registry_name)) {
       return activeTarget.target_registry_name
     }
-    return targets[0]?.target_registry_name ?? ''
+    return targets[0].target_registry_name
   })
-  const [selectedTechniques, setSelectedTechniques] = useState<string[]>(() => defaultTechniques)
+  const [techniqueSelection, setTechniqueSelection] = useState<TechniqueSelection>(() => defaultSelection)
+  const [customTechniques, setCustomTechniques] = useState<string[]>(() => initialCustomTechniques)
   const [baselineChecked, setBaselineChecked] = useState(
     () => !isBaselineForbidden && scenario.include_baseline_by_default,
   )
-  const [datasetOverride, setDatasetOverride] = useState('')
-  const configuredDefaultMaxDatasetSize = useMemo(
-    () => defaultMaxDatasetSize(scenario),
-    [scenario],
-  )
-  const [maxDatasetSize, setMaxDatasetSize] = useState(configuredDefaultMaxDatasetSize)
-  const [harmCategoriesFilter, setHarmCategoriesFilter] = useState('')
-  const [dataTypesFilter, setDataTypesFilter] = useState('')
+  const [availableDatasets, setAvailableDatasets] = useState<string[]>(() => [...scenario.default_datasets])
+  const [selectedDatasets, setSelectedDatasets] = useState<string[]>(() => [...scenario.default_datasets])
+  const [datasetCatalogStatus, setDatasetCatalogStatus] = useState<DatasetCatalogStatus>('loading')
+  const [datasetCatalogError, setDatasetCatalogError] = useState<string | null>(null)
+  const [maxDatasetSize, setMaxDatasetSize] = useState(() => {
+    const limit = scenario.dataset_size_limit
+    return limit.default_count !== null && limit.default_scope === limit.override_scope
+      ? String(limit.default_count)
+      : ''
+  })
+  const [hasMaxDatasetSizeOverride, setHasMaxDatasetSizeOverride] = useState(false)
+  const [maxDatasetSizeInputRejected, setMaxDatasetSizeInputRejected] = useState(false)
   const [maxConcurrency, setMaxConcurrency] = useState(DEFAULT_MAX_CONCURRENCY)
   const [maxRetries, setMaxRetries] = useState(DEFAULT_MAX_RETRIES)
-  const [scenarioParamValues, setScenarioParamValues] = useState<Record<string, ParameterFormValue>>(() =>
-    getInitialFormValues(dynamicParameters),
-  )
+  const [scenarioParamValues, setScenarioParamValues] = useState<Record<string, ParameterFormValue>>(() => {
+    const initialValues = getInitialFormValues(dynamicParameters)
+    if (usesAdaptiveTechniqueSelection && MAX_ATTEMPTS_PARAMETER_NAME in initialValues) {
+      initialValues[MAX_ATTEMPTS_PARAMETER_NAME] = ''
+    }
+    return initialValues
+  })
   const [validationError, setValidationError] = useState<string | null>(null)
   const [apiError, setApiError] = useState<string | null>(null)
   const [submitting, setSubmitting] = useState(false)
-  const [previewOpen, setPreviewOpen] = useState(false)
   const [estimateRequestState, setEstimateRequestState] = useState<EstimateRequestState | null>(null)
-  const [lastGoodEstimate, setLastGoodEstimate] = useState<SuccessfulEstimateResult | null>(null)
+  const [launchMaxAttemptsError, setLaunchMaxAttemptsError] = useState<string | null>(null)
+  const [maxAttemptsInputRejected, setMaxAttemptsInputRejected] = useState(false)
+  const [adaptiveCandidateMetadata, setAdaptiveCandidateMetadata] =
+    useState<AdaptiveCandidateMetadata | null>(null)
+  const [adaptiveLimitNotice, setAdaptiveLimitNotice] = useState<AdaptiveLimitNotice | null>(null)
   // Synchronous guard against a double-submit racing ahead of the state update.
   const isSubmittingRef = useRef(false)
   const estimateSequenceRef = useRef(0)
-
-  const selectableTechniques = useMemo<SelectableTechnique[]>(
-    () => [
-      {
-        ...BASELINE_TECHNIQUE,
-        isBaseline: true,
-        disabled: isBaselineForbidden,
-      },
-      ...techniqueOptions.map((technique) => ({
-        ...technique,
-        isBaseline: false,
-        disabled: false,
-      })),
-    ],
-    [isBaselineForbidden, techniqueOptions],
+  const customTechniquesInitializedRef = useRef(defaultSelection.mode === 'custom')
+  const hasResolvedAdaptiveMetadataRef = useRef(false)
+
+  const techniques = useMemo(
+    () => techniqueSelection.mode === 'preset'
+      ? [techniqueSelection.preset]
+      : customTechniques,
+    [customTechniques, techniqueSelection],
   )
-  const techniques = selectedTechniques
-  const maxDatasetSizeOverride = maxDatasetSize.trim()
-    && maxDatasetSize !== configuredDefaultMaxDatasetSize
-    ? maxDatasetSize
-    : ''
-  const estimateResult = useMemo(
-    () => buildEstimateRequest({
-      scenario,
-      targetName,
-      techniques,
-      dynamicParameters,
-      scenarioParamValues,
-      datasetOverride,
-      maxDatasetSize: maxDatasetSizeOverride,
-      harmCategoriesFilter,
-      dataTypesFilter,
-      includeBaseline: isBaselineForbidden ? false : baselineChecked,
-    }),
-    [
-      baselineChecked,
-      datasetOverride,
-      dataTypesFilter,
-      dynamicParameters,
-      harmCategoriesFilter,
-      isBaselineForbidden,
-      maxDatasetSizeOverride,
-      scenario,
-      scenarioParamValues,
-      targetName,
-      techniques,
-    ],
+  const adaptiveCandidateScopeKey = useMemo(
+    () => JSON.stringify({ targetName, techniques }),
+    [targetName, techniques],
   )
+  const knownAdaptiveCandidateMaximum =
+    adaptiveCandidateMetadata?.scopeKey === adaptiveCandidateScopeKey
+      ? adaptiveCandidateMetadata.maximum
+      : null
+  const adaptiveSelectionDisplayName = techniqueSelection.mode === 'preset'
+    ? techniqueSetDisplayName(scenario, techniqueSelection.preset)
+    : 'Custom selection'
   const requestResult = useMemo(
     () => buildRunRequest({
       scenario,
@@ -684,10 +826,9 @@ function ScenarioLaunchForm({
       techniques,
       dynamicParameters,
       scenarioParamValues,
-      datasetOverride,
-      maxDatasetSize: maxDatasetSizeOverride,
-      harmCategoriesFilter,
-      dataTypesFilter,
+      selectedDatasets,
+      maxDatasetSize,
+      hasMaxDatasetSizeOverride,
       maxConcurrency,
       maxRetries,
       includeBaseline: isBaselineForbidden ? false : baselineChecked,
@@ -695,24 +836,51 @@ function ScenarioLaunchForm({
     }),
     [
       baselineChecked,
-      datasetOverride,
-      dataTypesFilter,
       dynamicParameters,
-      harmCategoriesFilter,
       isBaselineForbidden,
       labels,
       maxConcurrency,
-      maxDatasetSizeOverride,
+      maxDatasetSize,
+      hasMaxDatasetSizeOverride,
       maxRetries,
       scenario,
       scenarioParamValues,
+      selectedDatasets,
       targetName,
       techniques,
     ],
   )
   const estimateRequest = useMemo(
-    () => estimateResult.ok ? estimateResult.request : null,
-    [estimateResult],
+    () => {
+      if (!requestResult.ok || maxAttemptsInputRejected || maxDatasetSizeInputRejected) {
+        return null
+      }
+      const request = buildEstimateRequest(requestResult.request)
+      if (!usesAdaptiveTechniqueSelection || !request.scenario_params) {
+        return request
+      }
+      const scenarioParams = { ...request.scenario_params }
+      const configuredMaximum = scenarioParams[MAX_ATTEMPTS_PARAMETER_NAME]
+      if (knownAdaptiveCandidateMaximum === null || knownAdaptiveCandidateMaximum === 0) {
+        delete scenarioParams[MAX_ATTEMPTS_PARAMETER_NAME]
+      } else if (
+        typeof configuredMaximum === 'number'
+        && configuredMaximum > knownAdaptiveCandidateMaximum
+      ) {
+        scenarioParams[MAX_ATTEMPTS_PARAMETER_NAME] = knownAdaptiveCandidateMaximum
+      }
+      return {
+        ...request,
+        scenario_params: Object.keys(scenarioParams).length > 0 ? scenarioParams : undefined,
+      }
+    },
+    [
+      knownAdaptiveCandidateMaximum,
+      maxAttemptsInputRejected,
+      maxDatasetSizeInputRejected,
+      requestResult,
+      usesAdaptiveTechniqueSelection,
+    ],
   )
   const estimateRequestKey = useMemo(
     () => estimateRequest === null
@@ -722,12 +890,36 @@ function ScenarioLaunchForm({
   )
 
   useEffect(() => {
-    if (estimateRequest === null || estimateRequestKey === null) {
-      return
+    let cancelled = false
+    datasetsApi
+      .listDatasets()
+      .then((response) => {
+        if (cancelled) return
+        setAvailableDatasets([...new Set([
+          ...scenario.default_datasets,
+          ...response.items.map((item) => item.name),
+        ])])
+        setDatasetCatalogStatus('success')
+        setDatasetCatalogError(null)
+      })
+      .catch((err: unknown) => {
+        if (cancelled) return
+        setAvailableDatasets([...scenario.default_datasets])
+        setDatasetCatalogStatus('error')
+        setDatasetCatalogError(toApiError(err).detail)
+      })
+    return () => {
+      cancelled = true
     }
+  }, [scenario.default_datasets])
 
+  useEffect(() => {
     const requestSequence = estimateSequenceRef.current + 1
     estimateSequenceRef.current = requestSequence
+    if (estimateRequest === null || estimateRequestKey === null) {
+      return
+    }
+
     const controller = new AbortController()
 
     const debounceTimer = window.setTimeout(() => {
@@ -741,14 +933,60 @@ function ScenarioLaunchForm({
             return
           }
           const result = mapScenarioRunEstimate(response, 'request')
+          const adaptiveDetails =
+            result.status === 'available' || result.status === 'conditional'
+              ? result.estimate.adaptiveDetails
+              : null
+          if (usesAdaptiveTechniqueSelection && adaptiveDetails) {
+            const maximum = adaptiveDetails.candidateTechniqueCount
+            const hadResolvedAdaptiveMetadata = hasResolvedAdaptiveMetadataRef.current
+            hasResolvedAdaptiveMetadataRef.current = true
+            setAdaptiveCandidateMetadata({ scopeKey: adaptiveCandidateScopeKey, maximum })
+            const rawValue = scenarioParamValues[MAX_ATTEMPTS_PARAMETER_NAME]
+            const parsedValue = typeof rawValue === 'string' && rawValue.trim() !== ''
+              ? Number(rawValue)
+              : null
+            const configuredValue = parsedValue ?? adaptiveDetails.maxAttemptsPerObjective
+            const isDefaultReduction = parsedValue === null
+            if (
+              maximum > 0
+              && Number.isSafeInteger(configuredValue)
+              && configuredValue > maximum
+            ) {
+              setScenarioParamValues((current) => ({
+                ...current,
+                [MAX_ATTEMPTS_PARAMETER_NAME]: String(maximum),
+              }))
+              setAdaptiveLimitNotice(
+                isDefaultReduction
+                  ? {
+                      scopeKey: adaptiveCandidateScopeKey,
+                      message: `The scenario default of ${configuredValue.toLocaleString()} is reduced to ${
+                        maximum.toLocaleString()
+                      } because ${adaptiveSelectionDisplayName} provides ${maximum.toLocaleString()} compatible ${
+                        maximum === 1 ? 'technique' : 'techniques'
+                      } for this target.`,
+                      validationState: 'none',
+                    }
+                  : hadResolvedAdaptiveMetadata
+                  ? {
+                      scopeKey: adaptiveCandidateScopeKey,
+                      message: `Reduced to ${maximum.toLocaleString()} because ${
+                        adaptiveSelectionDisplayName
+                      } provides ${maximum.toLocaleString()} compatible ${
+                        maximum === 1 ? 'technique' : 'techniques'
+                      } for this target.`,
+                      validationState: 'warning',
+                    }
+                  : null,
+              )
+            }
+          }
           setEstimateRequestState({
             status: 'resolved',
             requestKey: estimateRequestKey,
             result,
           })
-          if (result.status === 'available' || result.status === 'conditional') {
-            setLastGoodEstimate(result)
-          }
         })
         .catch((err: unknown) => {
           if (
@@ -757,10 +995,11 @@ function ScenarioLaunchForm({
           ) {
             return
           }
+          const mappedError = mapEstimateError(err)
           setEstimateRequestState({
             status: 'error',
             requestKey: estimateRequestKey,
-            error: toApiError(err).detail,
+            ...mappedError,
           })
         })
     }, ESTIMATE_DEBOUNCE_MS)
@@ -769,103 +1008,244 @@ function ScenarioLaunchForm({
       window.clearTimeout(debounceTimer)
       controller.abort()
     }
-  }, [estimateRequest, estimateRequestKey, scenario.scenario_name])
+  }, [
+    adaptiveCandidateScopeKey,
+    adaptiveSelectionDisplayName,
+    estimateRequest,
+    estimateRequestKey,
+    scenario.scenario_name,
+    scenarioParamValues,
+    usesAdaptiveTechniqueSelection,
+  ])
+
+  const currentResolvedEstimate = estimateRequestState?.requestKey === estimateRequestKey
+    && estimateRequestState.status === 'resolved'
+    ? estimateRequestState.result
+    : null
+  const currentResolvedRunEstimate = currentResolvedEstimate
+    && (currentResolvedEstimate.status === 'available' || currentResolvedEstimate.status === 'conditional')
+    ? currentResolvedEstimate.estimate
+    : null
+  const currentResolvedAdaptiveDetails = currentResolvedRunEstimate
+    ? currentResolvedRunEstimate.adaptiveDetails
+    : null
+  const adaptiveCandidateMaximum = currentResolvedAdaptiveDetails?.candidateTechniqueCount
+    ?? knownAdaptiveCandidateMaximum
+  const adaptiveCandidateAvailability = adaptiveCandidateMaximum === null
+    ? undefined
+    : `${adaptiveSelectionDisplayName} provides ${adaptiveCandidateMaximum.toLocaleString()} compatible ${
+      adaptiveCandidateMaximum === 1 ? 'technique' : 'techniques'
+    } for this target.`
+  const maxAttemptsParameter = dynamicParameters.find(
+    (parameter) => parameter.name === MAX_ATTEMPTS_PARAMETER_NAME,
+  )
+  const maxAttemptsDefault = Number(maxAttemptsParameter?.default ?? 3)
+  const adaptiveDefaultIsReduced = usesAdaptiveTechniqueSelection
+    && adaptiveCandidateMaximum !== null
+    && adaptiveCandidateMaximum > 0
+    && Number.isSafeInteger(maxAttemptsDefault)
+    && maxAttemptsDefault > adaptiveCandidateMaximum
+  const adaptiveDefaultHint = adaptiveDefaultIsReduced
+    ? `Blank restores the bounded default of ${adaptiveCandidateMaximum.toLocaleString()} techniques per objective for this target.`
+    : MAX_ATTEMPTS_DEFAULT_HINT
+  const maxAttemptsRawValue = scenarioParamValues[MAX_ATTEMPTS_PARAMETER_NAME]
+  const maxAttemptsNumericValue = typeof maxAttemptsRawValue === 'string'
+    && maxAttemptsRawValue.trim() !== ''
+    ? Number(maxAttemptsRawValue)
+    : null
+  const maxAttemptsExceedsCandidateMaximum = adaptiveCandidateMaximum !== null
+    && maxAttemptsNumericValue !== null
+    && maxAttemptsNumericValue > adaptiveCandidateMaximum
+  const adaptiveMetadataUnavailable = usesAdaptiveTechniqueSelection
+    && adaptiveCandidateMaximum === null
+  const noAdaptiveCandidatesError = usesAdaptiveTechniqueSelection && adaptiveCandidateMaximum === 0
+    ? 'No compatible techniques are available for this target. Choose a different technique set or target.'
+    : undefined
+  const maxAttemptsClientError = usesAdaptiveTechniqueSelection
+    ? maxAttemptsInputRejected
+      ? MAX_ATTEMPTS_VALIDATION_MESSAGE
+      : maxAttemptsValidationError(scenarioParamValues[MAX_ATTEMPTS_PARAMETER_NAME])
+    : undefined
+  const currentEstimateError = estimateRequestState?.requestKey === estimateRequestKey
+    && estimateRequestState.status === 'error'
+    ? estimateRequestState
+    : null
+  const maxAttemptsFieldError = maxAttemptsClientError
+    ?? noAdaptiveCandidatesError
+    ?? currentEstimateError?.maxAttemptsError
+    ?? launchMaxAttemptsError
+    ?? undefined
+  const maxDatasetSizeFieldError = maxDatasetSizeInputRejected
+    ? MAX_DATASET_SIZE_VALIDATION_MESSAGE
+    : maxDatasetSizeValidationError(maxDatasetSize)
 
   let estimateState: ScenarioRunEstimateState
-  if (!estimateResult.ok) {
+  if (maxAttemptsFieldError || maxDatasetSizeFieldError) {
+    estimateState = {
+      status: 'unavailable',
+      scope: 'request',
+      label: CORRECT_HIGHLIGHTED_SETTING_MESSAGE,
+    }
+  } else if (!requestResult.ok) {
     estimateState = {
       status: 'unavailable',
       scope: 'request',
       label: 'Complete the required configuration to request an estimate.',
-      note: estimateResult.error,
+      note: requestResult.error,
     }
-  } else if (
-    estimateRequestState?.requestKey === estimateRequestKey
-    && estimateRequestState.status === 'resolved'
-  ) {
-    estimateState = estimateRequestState.result
-  } else if (
-    estimateRequestState?.requestKey === estimateRequestKey
-    && estimateRequestState.status === 'error'
-  ) {
-    estimateState = lastGoodEstimate
-      ? {
-          status: 'stale',
-          estimate: lastGoodEstimate.estimate,
-          label: 'Showing the last successful estimate.',
-          error: estimateRequestState.error,
-        }
-      : {
-          status: 'unavailable',
-          scope: 'request',
-          label: 'The backend estimate could not be refreshed.',
-          note: estimateRequestState.error,
-        }
-  } else if (lastGoodEstimate) {
+  } else if (currentResolvedEstimate) {
+    estimateState = currentResolvedEstimate
+  } else if (currentEstimateError) {
     estimateState = {
-      status: 'refreshing',
-      estimate: lastGoodEstimate.estimate,
-      label: 'Updating for the current configuration…',
+      status: 'unavailable',
+      scope: 'request',
+      label: currentEstimateError.summary,
+      note: currentEstimateError.note,
     }
   } else {
     estimateState = { status: 'loading', scope: 'request' }
   }
+  const estimateRequestBlocked = estimateRequestState?.requestKey === estimateRequestKey
+    && estimateRequestState.status === 'error'
 
-  const handleTechniqueChange = (technique: SelectableTechnique, checked: boolean): void => {
-    if (technique.isBaseline) {
-      setBaselineChecked(checked)
+  const handleTechniqueModeChange = (value: string): void => {
+    if (value === CUSTOM_TECHNIQUE_SET_VALUE) {
+      if (!customTechniquesInitializedRef.current) {
+        const members = techniqueSelection.mode === 'preset'
+          ? techniqueSetMembers(scenario, techniqueSelection.preset)
+          : []
+        const concreteSet = new Set(concrete)
+        setCustomTechniques(members.filter((member) => concreteSet.has(member)))
+        customTechniquesInitializedRef.current = true
+      }
+      setTechniqueSelection({ mode: 'custom' })
     } else {
-      setSelectedTechniques((current) => {
-        if (checked) {
-          return current.includes(technique.name)
-            ? current
-            : [...current, technique.name]
-        }
-        return current.filter((name) => name !== technique.name)
-      })
+      setTechniqueSelection({ mode: 'preset', preset: value })
     }
     setValidationError(null)
   }
 
-  const isTechniqueSelected = (technique: SelectableTechnique): boolean => (
-    technique.isBaseline ? baselineChecked : selectedTechniques.includes(technique.name)
-  )
+  const handleConcreteChange = (name: string, checked: boolean): void => {
+    setCustomTechniques((current) => {
+      if (checked) {
+        return current.includes(name)
+          ? current
+          : [...current, name]
+      }
+      return current.filter((technique) => technique !== name)
+    })
+    setValidationError(null)
+  }
 
-  const handleTagChange = (tag: string): void => {
-    const members = selectableTechniques.filter(
-      (technique) => !technique.disabled && technique.tags.includes(tag),
-    )
-    const shouldSelect = members.some((technique) => !isTechniqueSelected(technique))
-    const memberNames = new Set(
-      members.filter((technique) => !technique.isBaseline).map((technique) => technique.name),
-    )
-    setSelectedTechniques((current) => {
-      const selected = new Set(current)
-      for (const name of memberNames) {
-        if (shouldSelect) selected.add(name)
-        else selected.delete(name)
+  const handleDatasetChange = (name: string, checked: boolean): void => {
+    setSelectedDatasets((current) => {
+      if (checked) {
+        return current.includes(name) ? current : [...current, name]
       }
-      return techniqueOptions.map((technique) => technique.name).filter((name) => selected.has(name))
+      return current.filter((dataset) => dataset !== name)
     })
-    if (members.some((technique) => technique.isBaseline)) {
-      setBaselineChecked(shouldSelect)
-    }
     setValidationError(null)
   }
 
   const updateScenarioParam = (name: string, value: ParameterFormValue): void => {
     setScenarioParamValues((current) => ({ ...current, [name]: value }))
+    if (name === MAX_ATTEMPTS_PARAMETER_NAME) {
+      setMaxAttemptsInputRejected(false)
+      setAdaptiveLimitNotice(null)
+      setLaunchMaxAttemptsError(null)
+      setApiError(null)
+    }
+    setValidationError(null)
+  }
+
+  const rejectScenarioParamInput = (
+    name: string,
+    reason: RejectedNumberInputReason,
+    retainedValue: string,
+  ): void => {
+    if (name !== MAX_ATTEMPTS_PARAMETER_NAME) {
+      return
+    }
+
+    if (reason === 'above-max' && adaptiveCandidateMaximum !== null) {
+      setScenarioParamValues((current) => ({
+        ...current,
+        [name]: String(adaptiveCandidateMaximum),
+      }))
+      setMaxAttemptsInputRejected(false)
+      setAdaptiveLimitNotice({
+        scopeKey: adaptiveCandidateScopeKey,
+        message: `Maximum reached: ${adaptiveCandidateAvailability}`,
+        validationState: 'warning',
+      })
+      setLaunchMaxAttemptsError(null)
+      setApiError(null)
+      setValidationError(null)
+      return
+    }
+    setScenarioParamValues((current) => ({ ...current, [name]: retainedValue }))
+    setMaxAttemptsInputRejected(true)
+    setAdaptiveLimitNotice(null)
+    setLaunchMaxAttemptsError(null)
+    setApiError(null)
+    setValidationError(null)
+  }
+
+  const updateMaxDatasetSize = (_name: string, value: ParameterFormValue): void => {
+    const nextValue = typeof value === 'string' ? value : ''
+    const parsed = Number(nextValue.trim())
+    const limit = scenario.dataset_size_limit
+    const matchesRepresentableDefault = nextValue.trim() !== ''
+      && limit.default_count !== null
+      && limit.default_scope === limit.override_scope
+      && parsed === limit.default_count
+    setMaxDatasetSize(nextValue)
+    setHasMaxDatasetSizeOverride(nextValue.trim() !== '' && !matchesRepresentableDefault)
+    setMaxDatasetSizeInputRejected(false)
+    setValidationError(null)
+    setApiError(null)
+  }
+
+  const rejectMaxDatasetSizeInput = (
+    _name: string,
+    _reason: RejectedNumberInputReason,
+    retainedValue: string,
+  ): void => {
+    setMaxDatasetSize(retainedValue)
+    setMaxDatasetSizeInputRejected(true)
+    setValidationError(null)
+    setApiError(null)
   }
 
-  const handleLaunchConfirmed = async (): Promise<void> => {
+  const restoreDefaultDatasetSize = (): void => {
+    const limit = scenario.dataset_size_limit
+    setMaxDatasetSize(
+      limit.default_count !== null && limit.default_scope === limit.override_scope
+        ? String(limit.default_count)
+        : '',
+    )
+    setHasMaxDatasetSizeOverride(false)
+    setMaxDatasetSizeInputRejected(false)
+    setValidationError(null)
+    setApiError(null)
+  }
+
+  const handleSubmit = async (): Promise<void> => {
     if (isSubmittingRef.current) {
       return
     }
 
     setApiError(null)
+    if (
+      adaptiveMetadataUnavailable
+      || adaptiveCandidateMaximum === 0
+      || maxAttemptsExceedsCandidateMaximum
+    ) {
+      setValidationError('Wait for the compatible technique limit to update.')
+      return
+    }
     if (!requestResult.ok) {
       setValidationError(requestResult.error)
-      setPreviewOpen(false)
       return
     }
 
@@ -875,12 +1255,17 @@ function ScenarioLaunchForm({
 
     try {
       const summary = await scenariosApi.startRun(requestResult.request)
-      setPreviewOpen(false)
       navigate(`/scenario-history/${encodeURIComponent(summary.scenario_result_id)}`, {
         state: { scenarioName: scenario.scenario_name },
       })
-    } catch (err) {
-      setApiError(toApiError(err).detail)
+    } catch (err: unknown) {
+      const mappedError = mapEstimateError(err)
+      if (mappedError.maxAttemptsError) {
+        setLaunchMaxAttemptsError(mappedError.maxAttemptsError)
+        setApiError(null)
+      } else {
+        setApiError(mappedError.note ?? mappedError.summary)
+      }
     } finally {
       isSubmittingRef.current = false
       setSubmitting(false)
@@ -889,23 +1274,51 @@ function ScenarioLaunchForm({
 
   const handleFormSubmit = (event: FormEvent<HTMLFormElement>): void => {
     event.preventDefault()
-    setApiError(null)
-    if (!requestResult.ok) {
-      setValidationError(requestResult.error)
-      return
-    }
-    setValidationError(null)
-    setPreviewOpen(true)
+    void handleSubmit()
   }
 
-  const techniqueSelectionInvalid = selectedTechniques.length === 0
-  const displayedEstimateNotes = estimateNotes(estimateState)
-  const displayedEstimate = estimateFromState(estimateState)
-  const selectedTechniqueCount = selectedTechniques.length + (baselineChecked ? 1 : 0)
-  const previewDatasets = parseDatasetNames(datasetOverride)
-  const effectiveDatasets = previewDatasets.length > 0 ? previewDatasets : scenario.default_datasets
-  const previewHarmCategories = parseDatasetNames(harmCategoriesFilter)
-  const previewDataTypes = parseDatasetNames(dataTypesFilter)
+  const techniqueSelectionInvalid =
+    techniqueSelection.mode === 'custom' && customTechniques.length === 0
+  const datasetSelectionInvalid = scenario.default_datasets.length > 0 && selectedDatasets.length === 0
+  const datasetsAreDefaults = sameStringSet(selectedDatasets, scenario.default_datasets)
+  const datasetSizePreview = formatDatasetSizePreview(
+    scenario.dataset_size_limit,
+    maxDatasetSize,
+    hasMaxDatasetSizeOverride,
+  )
+  const presetMembers = techniqueSelection.mode === 'preset'
+    ? techniqueSetMembers(scenario, techniqueSelection.preset)
+    : []
+  const atAdaptiveCandidateMaximum = adaptiveCandidateMaximum !== null
+    && adaptiveCandidateMaximum > 0
+    && maxAttemptsNumericValue === adaptiveCandidateMaximum
+  const scopedAdaptiveLimitNotice = adaptiveLimitNotice?.scopeKey === adaptiveCandidateScopeKey
+    ? adaptiveLimitNotice
+    : null
+  const currentAdaptiveLimitNotice = scopedAdaptiveLimitNotice?.message
+    ?? (atAdaptiveCandidateMaximum && adaptiveCandidateAvailability
+      ? `Maximum reached: ${adaptiveCandidateAvailability}`
+      : undefined)
+  const currentAdaptiveLimitValidationState = scopedAdaptiveLimitNotice?.validationState
+    ?? (atAdaptiveCandidateMaximum && adaptiveCandidateAvailability ? 'warning' : 'none')
+  const currentBaselineCount = currentResolvedRunEstimate?.components
+    .filter((component) => component.isBaseline)
+    .reduce((sum, component) => sum + component.count, 0)
+  const baselineHint = isBaselineForbidden
+    ? 'This scenario does not support sending objectives directly without an attack technique, so a direct comparison cannot be included.'
+    : baselineChecked && currentBaselineCount
+      ? `Adds ${currentBaselineCount.toLocaleString()} direct ${
+        currentBaselineCount === 1 ? 'baseline attack' : 'baseline attacks'
+      } for the current objectives.`
+      : 'Also send each selected objective directly, without an attack technique. This provides a comparison point for measuring whether the selected techniques improve results and adds one planned attack per objective.'
+  const adaptiveCapFeedback = currentResolvedAdaptiveDetails
+    ? formatAdaptiveCapFeedback({
+        selectedCandidateCount: currentResolvedAdaptiveDetails.selectedCandidateTechniqueCount,
+        compatibleCandidateCount: currentResolvedAdaptiveDetails.candidateTechniqueCount,
+        limit: currentResolvedAdaptiveDetails.maxAttemptsPerObjective,
+        effectiveMaximum: currentResolvedAdaptiveDetails.techniquesPerObjectiveUpperBound,
+      })
+    : undefined
 
   return (
     <section
@@ -914,14 +1327,24 @@ function ScenarioLaunchForm({
       aria-labelledby="scenario-detail-title"
     >
       <div className={styles.content}>
-        <Link to="/scanner" className={styles.backLink}>
-          <ArrowLeftRegular /> Back to scanners
+        <Link to="/scenarios" className={styles.backLink}>
+          <ArrowLeftRegular /> Back to scenarios
         </Link>
 
         <div className={styles.headerText}>
           <Text id="scenario-detail-title" as="h1" size={600} weight="semibold">
             {scenario.scenario_name}
           </Text>
+          <Text size={200} className={styles.scenarioMetadata}>
+            {scenario.scenario_type} · v{scenario.scenario_version}
+          </Text>
+          <MarkdownContent
+            content={normalizeScenarioMarkdown(
+              scenario.description_markdown || scenario.description,
+            )}
+            className={styles.description}
+            testId="scenario-detail-description"
+          />
         </div>
 
         <div className={styles.layout}>
@@ -943,16 +1366,6 @@ function ScenarioLaunchForm({
               </MessageBar>
             )}
 
-            <section className={styles.section} aria-label="Scenario description">
-              <MarkdownContent
-                content={normalizeScenarioMarkdown(
-                  scenario.description_markdown || scenario.description,
-                )}
-                className={styles.description}
-                testId="scenario-detail-description"
-              />
-            </section>
-
             <section className={styles.section} aria-labelledby="target-section-title">
               <Text id="target-section-title" as="h2" size={400} weight="semibold">Target</Text>
               <Field hint="The registered target this scenario will run against.">
@@ -990,354 +1403,396 @@ function ScenarioLaunchForm({
                 Techniques
               </Text>
               <Text size={200} className={styles.hint}>
-                Select individual techniques, or use a tag to select or clear all techniques with that tag.
+                Choose a predefined set, or choose Custom to select techniques individually.
               </Text>
-              {techniqueSelectionInvalid && (
-                <Text className={styles.errorText} role="alert">
-                  Select at least one attack technique.
-                </Text>
+              {usesAdaptiveTechniqueSelection && (
+                <>
+                  <Text size={200} className={styles.hint}>
+                    Core, Extra, Light, Multi-turn, and Single-turn reflect tags on PyRIT&apos;s registered
+                    techniques. All is generated from the catalog; Recommended is curated for this scenario.
+                  </Text>
+                  <MessageBar intent="info">
+                    <MessageBarBody>
+                      Adaptive uses these as a candidate pool. It tracks one progress step per compatible objective.
+                      Adaptive tries no more than the configured maximum or the compatible candidate count, whichever
+                      is smaller, and stops after the first success. Adding techniques changes the candidate pool, not
+                      the number of progress steps; compatibility can still change how many objectives can run.
+                    </MessageBarBody>
+                  </MessageBar>
+                </>
               )}
-              <div className={styles.techniqueList} role="group" aria-label="Techniques">
-                {selectableTechniques.map((technique) => {
-                  const selected = isTechniqueSelected(technique)
-                  return (
-                    <div className={styles.techniqueOption} key={technique.name}>
-                    <Checkbox
+              <div className={styles.techniqueGroups}>
+                <Field label="Technique set">
+                  <RadioGroup
+                    value={techniqueSelection.mode === 'preset'
+                      ? techniqueSelection.preset
+                      : CUSTOM_TECHNIQUE_SET_VALUE}
+                    onChange={(_, data) => handleTechniqueModeChange(data.value)}
+                    aria-label="Technique set"
+                  >
+                    {presets.map((name) => (
+                      <Radio
+                        className={styles.selectionControl}
+                        key={name}
+                        label={techniqueSetOptionLabel(scenario, name)}
+                        value={name}
+                        disabled={submitting}
+                        data-testid={`technique-${name}`}
+                      />
+                    ))}
+                    <Radio
                       className={styles.selectionControl}
-                      label={technique.name}
-                      checked={selected}
-                      disabled={submitting || technique.disabled}
-                      onChange={(_, data) => handleTechniqueChange(technique, data.checked === true)}
-                      data-testid={technique.isBaseline ? 'baseline-checkbox' : `technique-${technique.name}`}
+                      label="Custom"
+                      value={CUSTOM_TECHNIQUE_SET_VALUE}
+                      disabled={submitting}
+                      data-testid="technique-mode-custom"
                     />
-                    <div className={styles.techniqueDetails}>
-                      {technique.description && (
-                        <Text size={200} className={styles.hint}>{technique.description}</Text>
-                      )}
-                      {technique.tags.length > 0 && (
-                        <div className={styles.techniqueTags} aria-label={`${technique.name} tags`}>
-                          {technique.tags.map((tag) => {
-                            const tagMembers = selectableTechniques.filter(
-                              (candidate) => !candidate.disabled && candidate.tags.includes(tag),
-                            )
-                            const tagSelected = tagMembers.length > 0 && tagMembers.every(isTechniqueSelected)
-                            return (
-                              <ToggleButton
-                                className={styles.techniqueTag}
-                                key={tag}
-                                size="small"
-                                appearance="outline"
-                                checked={tagSelected}
-                                disabled={submitting || tagMembers.length === 0}
-                                onClick={() => handleTagChange(tag)}
-                                aria-label={`${tagSelected ? 'Clear' : 'Select'} ${techniqueSetName(tag)} techniques`}
-                              >
-                                {techniqueSetName(tag)}
-                              </ToggleButton>
-                            )
-                          })}
-                        </div>
-                      )}
-                      {technique.disabled && (
-                        <Text size={200} className={styles.hint}>
-                          This scenario does not support a baseline comparison.
-                        </Text>
-                      )}
-                    </div>
+                  </RadioGroup>
+                </Field>
+                {techniqueSelection.mode === 'preset' && (
+                  <div
+                    className={styles.resolvedMembers}
+                    data-testid="selected-technique-set-members"
+                    aria-live="polite"
+                  >
+                    <Text size={200} weight="semibold">Included techniques</Text>
+                    {presetMembers.length > 0 ? (
+                      <div className={styles.previewBadges}>
+                        {presetMembers.map((name) => (
+                          <Badge key={name} appearance="outline">{name}</Badge>
+                        ))}
+                      </div>
+                    ) : (
+                      <Text size={200} className={styles.hint}>
+                        No concrete members were supplied for this technique set.
+                      </Text>
+                    )}
                   </div>
-                  )
-                })}
+                )}
+                {techniqueSelection.mode === 'custom' && (
+                  <Field
+                    label="Individual techniques"
+                    validationState={techniqueSelectionInvalid ? 'error' : 'none'}
+                    validationMessage={techniqueSelectionInvalid
+                      ? 'Select at least one technique.'
+                      : undefined}
+                  >
+                    {concrete.length > 0 ? (
+                      <div className={styles.checkboxGroup} role="group" aria-label="Individual techniques">
+                        {concrete.map((name) => {
+                          const summary = techniqueSummaries.get(name)
+                          return (
+                            <div key={name}>
+                              <Checkbox
+                                className={styles.selectionControl}
+                                label={name}
+                                checked={customTechniques.includes(name)}
+                                disabled={submitting}
+                                onChange={(_, data) => handleConcreteChange(name, data.checked === true)}
+                                data-testid={`technique-${name}`}
+                              />
+                              {summary?.description && (
+                                <Text size={200} className={styles.hint}>{summary.description}</Text>
+                              )}
+                            </div>
+                          )
+                        })}
+                      </div>
+                    ) : (
+                      <Text size={200} className={styles.hint}>
+                        No concrete techniques are registered for custom selection.
+                      </Text>
+                    )}
+                  </Field>
+                )}
               </div>
             </section>
 
-            <section className={styles.section} aria-labelledby="parameters-section-title">
-              <Text id="parameters-section-title" as="h2" size={400} weight="semibold">
-                Parameters
+            <section className={styles.section} aria-labelledby="baseline-section-title">
+              <Text id="baseline-section-title" as="h2" size={400} weight="semibold">
+                Baseline
               </Text>
-              <div className={styles.dynamicParameters}>
-                {dynamicParameters.map((parameter) => (
-                  <ParameterField
-                    key={parameter.name}
-                    parameter={parameter}
-                    value={scenarioParamValues[parameter.name]}
-                    disabled={submitting}
-                    onChange={updateScenarioParam}
-                    testIdPrefix="scenario-param"
-                  />
-                ))}
-                <Field
-                  label="Dataset override"
-                  hint="Comma-separated dataset names. Leave blank to use the scenario's default datasets."
-                >
-                  <Input
-                    className={styles.control}
-                    value={datasetOverride}
-                    disabled={submitting}
-                    onChange={(_, data) => setDatasetOverride(data.value)}
-                    placeholder={scenario.default_datasets.join(', ') || undefined}
-                    data-testid="dataset-override-input"
-                  />
-                </Field>
-                <Field
-                  label="Max dataset size"
-                  hint={configuredDefaultMaxDatasetSize
-                    ? `The scenario default is ${configuredDefaultMaxDatasetSize}. Edit it to override the default.`
-                    : 'Enter a positive integer to limit the selected dataset size.'}
-                >
-                  <Input
-                    className={styles.numberInput}
-                    type="number"
-                    min={1}
-                    value={maxDatasetSize}
-                    disabled={submitting}
-                    onChange={(_, data) => setMaxDatasetSize(data.value)}
-                    data-testid="max-dataset-size-input"
-                  />
-                </Field>
-                <Field
-                  label="Harm categories"
-                  hint="Comma-separated values. A seed must match every listed category."
-                >
-                  <Input
-                    className={styles.control}
-                    value={harmCategoriesFilter}
-                    disabled={submitting}
-                    placeholder="cyber, violence"
-                    onChange={(_, data) => setHarmCategoriesFilter(data.value)}
-                    data-testid="harm-categories-filter-input"
-                  />
-                </Field>
-                <Field
-                  label="Data types"
-                  hint="Comma-separated values. A seed can match any listed data type."
-                >
-                  <Input
-                    className={styles.control}
-                    value={dataTypesFilter}
-                    disabled={submitting}
-                    placeholder="text, image_path"
-                    onChange={(_, data) => setDataTypesFilter(data.value)}
-                    data-testid="data-types-filter-input"
-                  />
-                </Field>
-                <Field label="Max concurrency">
-                  <SpinButton
-                    className={styles.numberInput}
-                    value={maxConcurrency}
-                    min={MIN_MAX_CONCURRENCY}
-                    max={MAX_MAX_CONCURRENCY}
-                    disabled={submitting}
-                    onChange={(_, data) => setMaxConcurrency(resolveSpinButtonValue(data, maxConcurrency))}
-                    data-testid="max-concurrency-input"
-                  />
-                </Field>
-                <Field label="Max retries">
-                  <SpinButton
-                    className={styles.numberInput}
-                    value={maxRetries}
-                    min={MIN_MAX_RETRIES}
-                    max={MAX_MAX_RETRIES}
-                    disabled={submitting}
-                    onChange={(_, data) => setMaxRetries(resolveSpinButtonValue(data, maxRetries))}
-                    data-testid="max-retries-input"
-                  />
-                </Field>
-              </div>
+              <Field hint={baselineHint}>
+                <Checkbox
+                  className={styles.selectionControl}
+                  checked={baselineChecked}
+                  disabled={submitting || isBaselineForbidden}
+                  label="Include direct baseline comparison"
+                  onChange={(_, data) => setBaselineChecked(data.checked === true)}
+                  data-testid="baseline-checkbox"
+                />
+              </Field>
             </section>
 
-            <section
-              className={styles.section}
-              aria-labelledby="run-estimate-title"
-              data-testid="run-estimate"
-            >
-              <div className={styles.estimateHeader}>
-                <Text id="run-estimate-title" as="h2" size={400} weight="semibold">
-                  Run estimate
+            {dynamicParameters.length > 0 && (
+              <section className={styles.section} aria-labelledby="parameters-section-title">
+                <Text id="parameters-section-title" as="h2" size={400} weight="semibold">
+                  Scenario parameters
                 </Text>
-                {displayedEstimateNotes && (
-                  <Tooltip
-                    content={displayedEstimateNotes}
-                    relationship="description"
-                    positioning="above"
-                  >
-                    <Button
-                      appearance="subtle"
-                      icon={<InfoRegular />}
-                      aria-label="Estimate notes"
-                      size="small"
+                <div className={styles.dynamicParameters}>
+                  {dynamicParameters.map((parameter) => (
+                    <ParameterField
+                      key={parameter.name}
+                      parameter={parameter}
+                      value={scenarioParamValues[parameter.name]}
+                      disabled={
+                        submitting
+                        || (
+                          usesAdaptiveTechniqueSelection
+                          && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME
+                          && (adaptiveMetadataUnavailable || adaptiveCandidateMaximum === 0)
+                        )
+                      }
+                      onChange={updateScenarioParam}
+                      displayLabel={usesAdaptiveTechniqueSelection
+                        && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME
+                        ? MAX_ATTEMPTS_DISPLAY_LABEL
+                        : undefined}
+                      displayHint={usesAdaptiveTechniqueSelection
+                        && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME
+                        ? `${adaptiveDefaultHint} ${MAX_ATTEMPTS_BEHAVIOR_HINT}${adaptiveCapFeedback
+                          ? ` ${adaptiveCapFeedback}`
+                          : ''}`
+                        : undefined}
+                      validationState={usesAdaptiveTechniqueSelection
+                        && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME
+                        ? maxAttemptsFieldError
+                          ? 'error'
+                          : currentAdaptiveLimitNotice
+                            ? currentAdaptiveLimitValidationState
+                            : 'none'
+                        : 'none'}
+                      validationMessage={usesAdaptiveTechniqueSelection
+                        && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME
+                        ? maxAttemptsFieldError ?? currentAdaptiveLimitNotice
+                        : undefined}
+                      numberMin={usesAdaptiveTechniqueSelection
+                        && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME
+                        ? 1
+                        : undefined}
+                      numberMax={usesAdaptiveTechniqueSelection
+                        && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME
+                        && adaptiveCandidateMaximum !== null
+                        && adaptiveCandidateMaximum > 0
+                        ? adaptiveCandidateMaximum
+                        : undefined}
+                      numberStep={usesAdaptiveTechniqueSelection
+                        && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME
+                        ? 1
+                        : undefined}
+                      numberWholeOnly={usesAdaptiveTechniqueSelection
+                        && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME}
+                      onRejectedNumberInput={usesAdaptiveTechniqueSelection
+                        && parameter.name === MAX_ATTEMPTS_PARAMETER_NAME
+                        ? rejectScenarioParamInput
+                        : undefined}
+                      testIdPrefix="scenario-param"
                     />
-                  </Tooltip>
-                )}
-              </div>
-              <dl className={styles.costEstimateList}>
-                <div className={mergeClasses(styles.costEstimateRow, styles.totalEstimateRow)}>
-                  <dt>Total atomic attacks</dt>
-                  <dd>{formatAtomicAttackCount(estimateState)}</dd>
-                </div>
-                <div className={styles.costEstimateRow}>
-                  <dt>Dataset size</dt>
-                  <dd>
-                    {maxDatasetSizeOverride.trim()
-                      || configuredDefaultMaxDatasetSize
-                      || 'Not configured'}
-                  </dd>
-                </div>
-                <div className={styles.costEstimateRow}>
-                  <dt>Number techniques</dt>
-                  <dd>{selectedTechniqueCount}</dd>
-                </div>
-                {dynamicParameters.map((parameter) => (
-                  <div className={styles.costEstimateRow} key={parameter.name}>
-                    <dt>{parameter.name}</dt>
-                    <dd>
-                      {formatEffectiveParameterPreview(
-                        parameter.name,
-                        scenarioParamValues[parameter.name],
-                        displayedEstimate,
-                      )}
-                    </dd>
-                  </div>
-                ))}
-              </dl>
-              {estimateState.status === 'refreshing' && (
-                <div className={styles.inlineStatus}>
-                  <Spinner size="tiny" />
-                  <Text size={200} className={styles.hint}>Updating estimate...</Text>
+                  ))}
                 </div>
-              )}
-              {estimateState.status === 'stale' && (
-                <Text size={200} className={styles.warningText}>
-                  {estimateState.error}
-                </Text>
-              )}
+              </section>
+            )}
+
+            <section className={styles.section} aria-labelledby="datasets-section-title">
+              <Text id="datasets-section-title" as="h2" size={400} weight="semibold">
+                Datasets
+              </Text>
+              <Text size={200} className={styles.hint}>
+                Choose the registered datasets that provide objectives for this run.
+              </Text>
+              <DatasetPicker
+                availableDatasets={availableDatasets}
+                defaultDatasets={scenario.default_datasets}
+                selectedDatasets={selectedDatasets}
+                status={datasetCatalogStatus}
+                error={datasetCatalogError}
+                disabled={submitting}
+                invalid={datasetSelectionInvalid}
+                onChange={handleDatasetChange}
+                onRestoreDefaults={() => {
+                  setSelectedDatasets([...scenario.default_datasets])
+                  setValidationError(null)
+                }}
+              />
             </section>
 
-            <section className={styles.launchSection} aria-label="Launch scan">
+            <Accordion collapsible className={styles.advancedSection}>
+              <AccordionItem value="advanced">
+                <AccordionHeader>Advanced options</AccordionHeader>
+                <AccordionPanel>
+                  <div className={styles.advancedFields}>
+                    <ParameterField
+                      parameter={MAX_DATASET_SIZE_PARAMETER}
+                      value={maxDatasetSize}
+                      disabled={submitting || scenario.dataset_size_limit.override_scope === 'unsupported'}
+                      onChange={updateMaxDatasetSize}
+                      displayLabel={datasetSizeFieldLabel(scenario.dataset_size_limit)}
+                      displayHint={datasetSizeHint(scenario.dataset_size_limit)}
+                      validationState={maxDatasetSizeFieldError ? 'error' : 'none'}
+                      validationMessage={maxDatasetSizeFieldError}
+                      numberMin={1}
+                      numberStep={1}
+                      numberWholeOnly
+                      onRejectedNumberInput={rejectMaxDatasetSizeInput}
+                      testIdPrefix="advanced"
+                    />
+                    {scenario.dataset_size_limit.override_scope !== 'unsupported'
+                      && (hasMaxDatasetSizeOverride || maxDatasetSize.trim() === '') && (
+                      <Button
+                        className={styles.touchTarget}
+                        appearance="subtle"
+                        icon={<ArrowSyncRegular />}
+                        type="button"
+                        disabled={submitting}
+                        onClick={restoreDefaultDatasetSize}
+                        data-testid="restore-default-dataset-size"
+                      >
+                        Restore scenario default
+                      </Button>
+                    )}
+                    <Field label="Max concurrency">
+                      <SpinButton
+                        className={styles.numberInput}
+                        value={maxConcurrency}
+                        min={MIN_MAX_CONCURRENCY}
+                        max={MAX_MAX_CONCURRENCY}
+                        disabled={submitting}
+                        onChange={(_, data) => setMaxConcurrency(resolveSpinButtonValue(data, maxConcurrency))}
+                        data-testid="max-concurrency-input"
+                      />
+                    </Field>
+                    <Field
+                      label="Max retries"
+                      hint={usesAdaptiveTechniqueSelection
+                        ? 'Maximum times to resume the scenario after an exception. This is separate from Adaptive trying another technique.'
+                        : 'Maximum times to resume the scenario after an exception.'}
+                    >
+                      <SpinButton
+                        className={styles.numberInput}
+                        value={maxRetries}
+                        min={MIN_MAX_RETRIES}
+                        max={MAX_MAX_RETRIES}
+                        disabled={submitting}
+                        onChange={(_, data) => setMaxRetries(resolveSpinButtonValue(data, maxRetries))}
+                        data-testid="max-retries-input"
+                      />
+                    </Field>
+                  </div>
+                </AccordionPanel>
+              </AccordionItem>
+            </Accordion>
+          </form>
+
+          <aside className={styles.previewRail} aria-labelledby="run-preview-title">
+            <div className={styles.previewHeader}>
+              <Text id="run-preview-title" as="h2" size={500} weight="semibold">Run preview</Text>
+              <Text size={200} className={styles.hint}>
+                Review the exact configuration used for this run.
+              </Text>
+            </div>
+            <dl className={styles.previewList}>
+              <div className={styles.previewGroup}>
+                <dt>Target</dt>
+                <dd>{targetName}</dd>
+              </div>
+              <div className={styles.previewGroup}>
+                <dt>Techniques</dt>
+                <dd>
+                  {techniqueSelection.mode === 'preset' ? (
+                    <div className={styles.previewStack}>
+                      <Text weight="semibold">
+                        Technique set: {techniqueSetDisplayName(scenario, techniqueSelection.preset)}
+                      </Text>
+                      {presetMembers.length > 0 && (
+                        <Text size={200} className={styles.hint}>
+                          Resolves to {presetMembers.join(', ')}
+                        </Text>
+                      )}
+                    </div>
+                  ) : customTechniques.length > 0 ? (
+                    <div className={styles.previewBadges}>
+                      {customTechniques.map((name) => (
+                        <Badge key={name} appearance="outline">{name}</Badge>
+                      ))}
+                    </div>
+                  ) : (
+                    <Text className={styles.errorText}>No custom techniques selected</Text>
+                  )}
+                </dd>
+              </div>
+              <div className={styles.previewGroup}>
+                <dt>Datasets</dt>
+                <dd>
+                  <div className={styles.previewStack}>
+                    <Text>
+                      {selectedDatasets.length > 0 ? selectedDatasets.join(', ') : 'No datasets selected'}
+                    </Text>
+                    <Text size={200} className={styles.hint}>
+                      {datasetsAreDefaults ? 'Scenario defaults' : 'Selected datasets'}
+                      {' · '}
+                      {datasetSizePreview}
+                    </Text>
+                  </div>
+                </dd>
+              </div>
+              <div className={styles.previewGroup}>
+                <dt>Scenario parameters</dt>
+                <dd>
+                  {dynamicParameters.length > 0 ? (
+                    <dl className={styles.parameterPreview}>
+                      {dynamicParameters.map((parameter) => (
+                        <div className={styles.parameterPreviewRow} key={parameter.name}>
+                          <dt>{parameterDisplayLabel(parameter, usesAdaptiveTechniqueSelection)}</dt>
+                          <dd>{formatParameterPreview(scenarioParamValues[parameter.name])}</dd>
+                        </div>
+                      ))}
+                    </dl>
+                  ) : (
+                    'No scenario-specific parameters'
+                  )}
+                </dd>
+              </div>
+              <div className={styles.previewGroup}>
+                <dt>Baseline</dt>
+                <dd>
+                  {isBaselineForbidden
+                    ? 'Not included — this scenario does not support direct comparison'
+                    : baselineChecked
+                      ? 'Included — direct objective without an attack technique'
+                      : 'Not included'}
+                </dd>
+              </div>
+            </dl>
+            <div className={styles.estimateGroup}>
+              <Text as="h3" size={400} weight="semibold">Planned run size</Text>
+              <ScenarioRunEstimateDetails
+                state={estimateState}
+                idPrefix={`${formId}-estimate`}
+              />
+            </div>
+            <div className={styles.previewActions}>
               <Button
                 className={styles.launchButton}
                 appearance="primary"
                 type="submit"
-                disabled={submitting || techniqueSelectionInvalid}
+                form={formId}
+                disabled={
+                  submitting
+                  || techniqueSelectionInvalid
+                  || datasetSelectionInvalid
+                  || !requestResult.ok
+                  || Boolean(maxAttemptsFieldError)
+                  || Boolean(maxDatasetSizeFieldError)
+                  || estimateRequestBlocked
+                  || adaptiveMetadataUnavailable
+                  || maxAttemptsExceedsCandidateMaximum
+                }
                 data-testid="launch-scenario-btn"
               >
-                Launch scan
+                {submitting ? 'Launching...' : 'Launch scenario'}
               </Button>
-            </section>
-          </form>
-
-          <Dialog
-            open={previewOpen}
-            onOpenChange={(_, data) => {
-              if (!submitting) {
-                setPreviewOpen(data.open)
-              }
-            }}
-          >
-            <DialogSurface>
-              <DialogBody>
-                <DialogTitle>Run preview</DialogTitle>
-                <DialogContent className={styles.dialogContent}>
-                  <dl className={styles.previewList}>
-                    <div className={styles.previewGroup}>
-                      <dt>Target</dt>
-                      <dd>{targetName}</dd>
-                    </div>
-                    <div className={styles.previewGroup}>
-                      <dt>Techniques</dt>
-                      <dd>
-                        <div className={styles.previewBadges}>
-                          {baselineChecked && <Badge appearance="outline">baseline</Badge>}
-                          {selectedTechniques.map((name) => (
-                            <Badge key={name} appearance="outline">{name}</Badge>
-                          ))}
-                        </div>
-                      </dd>
-                    </div>
-                    <div className={styles.previewGroup}>
-                      <dt>Datasets</dt>
-                      <dd>
-                        <div className={styles.previewStack}>
-                          <Text>
-                            {effectiveDatasets.length > 0
-                              ? effectiveDatasets.join(', ')
-                              : 'No datasets declared'}
-                          </Text>
-                          <Text size={200} className={styles.hint}>
-                            {previewDatasets.length > 0 ? 'Custom override' : 'Scenario defaults'}
-                            {maxDatasetSize.trim() ? ` - capped at ${maxDatasetSize.trim()} each` : ''}
-                          </Text>
-                        </div>
-                      </dd>
-                    </div>
-                    <div className={styles.previewGroup}>
-                      <dt>Dataset filters</dt>
-                      <dd>
-                        {previewHarmCategories.length > 0 || previewDataTypes.length > 0 ? (
-                          <dl className={styles.parameterPreview}>
-                            {previewHarmCategories.length > 0 && (
-                              <div className={styles.parameterPreviewRow}>
-                                <dt>Harm categories</dt>
-                                <dd>{previewHarmCategories.join(', ')}</dd>
-                              </div>
-                            )}
-                            {previewDataTypes.length > 0 && (
-                              <div className={styles.parameterPreviewRow}>
-                                <dt>Data types</dt>
-                                <dd>{previewDataTypes.join(', ')}</dd>
-                              </div>
-                            )}
-                          </dl>
-                        ) : (
-                          'None'
-                        )}
-                      </dd>
-                    </div>
-                    <div className={styles.previewGroup}>
-                      <dt>Parameters</dt>
-                      <dd>
-                        {dynamicParameters.length > 0 ? (
-                          <dl className={styles.parameterPreview}>
-                            {dynamicParameters.map((parameter) => (
-                              <div className={styles.parameterPreviewRow} key={parameter.name}>
-                                <dt>{parameter.name}</dt>
-                                <dd>
-                                  {formatEffectiveParameterPreview(
-                                    parameter.name,
-                                    scenarioParamValues[parameter.name],
-                                    displayedEstimate,
-                                  )}
-                                </dd>
-                              </div>
-                            ))}
-                          </dl>
-                        ) : (
-                          'No scenario-specific parameters'
-                        )}
-                      </dd>
-                    </div>
-                  </dl>
-                  <ScenarioRunEstimateDetails state={estimateState} />
-                </DialogContent>
-                <DialogActions>
-                  <Button
-                    appearance="secondary"
-                    disabled={submitting}
-                    onClick={() => setPreviewOpen(false)}
-                  >
-                    Cancel
-                  </Button>
-                  <Button
-                    appearance="primary"
-                    disabled={submitting}
-                    onClick={() => void handleLaunchConfirmed()}
-                    data-testid="confirm-launch-scenario-btn"
-                  >
-                    {submitting ? 'Launching...' : 'Launch scan'}
-                  </Button>
-                </DialogActions>
-              </DialogBody>
-            </DialogSurface>
-          </Dialog>
+            </div>
+          </aside>
         </div>
       </div>
     </section>
diff --git a/frontend/src/components/Scenarios/ScenarioFlow.test.tsx b/frontend/src/components/Scenarios/ScenarioFlow.test.tsx
index 1d660cf10c..03a7345597 100644
--- a/frontend/src/components/Scenarios/ScenarioFlow.test.tsx
+++ b/frontend/src/components/Scenarios/ScenarioFlow.test.tsx
@@ -4,7 +4,7 @@ import { FluentProvider, webLightTheme } from '@fluentui/react-components'
 import { MemoryRouter, Route, Routes, useLocation } from 'react-router'
 
 import { useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
-import { scenariosApi, targetsApi } from '@/services/api'
+import { datasetsApi, scenariosApi, targetsApi } from '@/services/api'
 import type {
   RegisteredScenario,
   ScenarioDefaultRunSizeEstimate,
@@ -31,6 +31,9 @@ jest.mock('@/services/api', () => ({
   targetsApi: {
     listTargets: jest.fn(),
   },
+  datasetsApi: {
+    listDatasets: jest.fn(),
+  },
 }))
 
 const mockUseScenarioRunProgress = useScenarioRunProgress as jest.Mock
@@ -39,6 +42,7 @@ const mockGetScenario = scenariosApi.getScenario as jest.Mock
 const mockListCatalog = scenariosApi.listCatalog as jest.Mock
 const mockStartRun = scenariosApi.startRun as jest.Mock
 const mockListTargets = targetsApi.listTargets as jest.Mock
+const mockListDatasets = datasetsApi.listDatasets as jest.Mock
 
 const SCENARIO_NAME = 'foundry.red_team_agent'
 const RUN_ID = '123e4567-e89b-12d3-a456-426614174000'
@@ -57,7 +61,11 @@ const SCENARIO: RegisteredScenario = {
   },
   all_techniques: ['crescendo'],
   default_datasets: ['harmbench'],
-  default_dataset_summaries: [],
+  dataset_size_limit: {
+    default_scope: 'none',
+    default_count: null,
+    override_scope: 'per_dataset',
+  },
   baseline_policy: 'enabled',
   include_baseline_by_default: true,
   supported_parameters: [],
@@ -65,8 +73,12 @@ const SCENARIO: RegisteredScenario = {
     version: 1,
     status: 'exact',
     total_attack_count: 2,
+    minimum_attack_count: null,
+    maximum_attack_count: null,
+    condition: null,
     components: [],
     datasets: [],
+    adaptive_details: null,
     note: null,
     retries_included: false,
   },
@@ -84,6 +96,9 @@ const ESTIMATE: ScenarioDefaultRunSizeEstimate = {
   version: 1,
   status: 'exact',
   total_attack_count: 2,
+  minimum_attack_count: null,
+  maximum_attack_count: null,
+  condition: null,
   components: [{
     label: 'Configured attacks',
     count: 2,
@@ -92,6 +107,7 @@ const ESTIMATE: ScenarioDefaultRunSizeEstimate = {
     note: null,
   }],
   datasets: [],
+  adaptive_details: null,
   note: null,
   retries_included: false,
 }
@@ -162,6 +178,7 @@ describe('Scenario catalog-to-run integration', () => {
       items: [TARGET],
       pagination: { limit: 200, has_more: false },
     })
+    mockListDatasets.mockResolvedValue({ items: [{ name: 'harmbench' }] })
     mockEstimateRun.mockResolvedValue(ESTIMATE)
     mockStartRun.mockResolvedValue({ scenario_result_id: RUN_ID })
     mockUseScenarioRunProgress.mockReturnValue({
@@ -171,12 +188,13 @@ describe('Scenario catalog-to-run integration', () => {
     })
   })
 
-  it('carries one configured request from catalog detail through estimate, launch, and run hydration', async () => {
+  it('carries one configured request from catalog through estimate, launch, and run hydration', async () => {
     const user = userEvent.setup()
     renderFlow()
 
-    await user.click(await screen.findByRole('link', { name: SCENARIO_NAME }))
+    await user.click(await screen.findByRole('button', { name: 'Configure run' }))
     expect(await screen.findByRole('heading', { level: 1, name: SCENARIO_NAME })).toBeInTheDocument()
+    expect(screen.getByText('RedTeamAgentScenario · v1')).toBeInTheDocument()
 
     const expectedEstimateRequest = {
       target_name: TARGET.target_registry_name,
@@ -189,7 +207,7 @@ describe('Scenario catalog-to-run integration', () => {
       expect.any(AbortSignal),
     ))
     expect(within(screen.getByRole('complementary', { name: 'Run preview' }))
-      .getByText('2 planned attacks')).toBeInTheDocument()
+      .getByRole('group', { name: '2 planned attacks.' })).toBeInTheDocument()
 
     await user.click(screen.getByTestId('launch-scenario-btn'))
 
diff --git a/frontend/src/components/Scenarios/ScenarioRunEstimate.styles.ts b/frontend/src/components/Scenarios/ScenarioRunEstimate.styles.ts
index 1edd185b6a..0fcc38296e 100644
--- a/frontend/src/components/Scenarios/ScenarioRunEstimate.styles.ts
+++ b/frontend/src/components/Scenarios/ScenarioRunEstimate.styles.ts
@@ -27,112 +27,74 @@ export const useScenarioRunEstimateStyles = makeStyles({
     gap: tokens.spacingVerticalM,
     minWidth: 0,
   },
-  detailGroup: {
+  calculationSection: {
     display: 'flex',
     flexDirection: 'column',
-    gap: tokens.spacingVerticalXS,
-    minWidth: 0,
-  },
-  componentList: {
-    display: 'grid',
     gap: tokens.spacingVerticalS,
-    margin: 0,
-    padding: 0,
-    listStyleType: 'none',
+    minWidth: 0,
   },
-  component: {
+  equation: {
     display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalXXS,
-    paddingLeft: tokens.spacingHorizontalS,
-    borderLeft: `${tokens.strokeWidthThick} solid ${tokens.colorNeutralStroke2}`,
+    alignItems: 'stretch',
+    flexWrap: 'wrap',
+    gap: `${tokens.spacingVerticalXS} ${tokens.spacingHorizontalXS}`,
     minWidth: 0,
-    overflowWrap: 'anywhere',
   },
-  componentHeader: {
-    display: 'flex',
+  operand: {
+    display: 'inline-flex',
     alignItems: 'baseline',
-    justifyContent: 'space-between',
-    gap: tokens.spacingHorizontalS,
-  },
-  componentCount: {
-    display: 'flex',
-    alignItems: 'center',
-    gap: tokens.spacingHorizontalXS,
-    flexShrink: 0,
-    fontVariantNumeric: 'tabular-nums',
-  },
-  factorList: {
-    display: 'flex',
     flexWrap: 'wrap',
-    gap: `${tokens.spacingVerticalXXS} ${tokens.spacingHorizontalS}`,
-    margin: 0,
-    padding: 0,
-    listStyleType: 'none',
-    color: tokens.colorNeutralForeground2,
-  },
-  datasetList: {
-    display: 'grid',
-    gap: tokens.spacingVerticalS,
-  },
-  dataset: {
-    display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalXXS,
+    gap: tokens.spacingHorizontalXXS,
+    minWidth: 0,
     padding: `${tokens.spacingVerticalXS} ${tokens.spacingHorizontalS}`,
+    color: tokens.colorNeutralForeground1,
     backgroundColor: tokens.colorNeutralBackground3,
-    borderRadius: tokens.borderRadiusSmall,
-    minWidth: 0,
+    border: `${tokens.strokeWidthThin} solid ${tokens.colorNeutralStroke2}`,
+    borderRadius: tokens.borderRadiusMedium,
     overflowWrap: 'anywhere',
   },
-  datasetHeader: {
-    display: 'flex',
-    alignItems: 'center',
+  resultOperand: {
+    display: 'inline-flex',
+    alignItems: 'baseline',
     flexWrap: 'wrap',
-    gap: tokens.spacingHorizontalXS,
-  },
-  countList: {
-    display: 'grid',
-    gap: tokens.spacingVerticalXXS,
-    margin: 0,
+    gap: tokens.spacingHorizontalXXS,
+    minWidth: 0,
+    padding: `${tokens.spacingVerticalXS} ${tokens.spacingHorizontalS}`,
+    color: tokens.colorBrandForeground2,
+    backgroundColor: tokens.colorBrandBackground2,
+    border: `${tokens.strokeWidthThin} solid ${tokens.colorBrandStroke1}`,
+    borderRadius: tokens.borderRadiusMedium,
+    overflowWrap: 'anywhere',
   },
-  countRow: {
-    display: 'grid',
-    gridTemplateColumns: 'minmax(0, 1fr) auto',
-    gap: tokens.spacingHorizontalS,
+  operandValue: {
     fontVariantNumeric: 'tabular-nums',
-    '& dd': {
-      margin: 0,
-      fontWeight: tokens.fontWeightSemibold,
-    },
   },
-  capGroup: {
-    display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalXXS,
+  operandDetail: {
+    flexBasis: '100%',
+    color: tokens.colorNeutralForeground3,
   },
-  capList: {
-    display: 'grid',
-    gap: tokens.spacingVerticalXXS,
-    margin: 0,
-    paddingLeft: tokens.spacingHorizontalL,
+  operator: {
+    display: 'inline-flex',
+    alignItems: 'center',
+    minHeight: '2rem',
+    color: tokens.colorNeutralForeground2,
+    fontSize: tokens.fontSizeBase400,
   },
-  formula: {
-    display: 'block',
-    padding: `${tokens.spacingVerticalXS} ${tokens.spacingHorizontalS}`,
-    overflowWrap: 'anywhere',
-    fontFamily: tokens.fontFamilyMonospace,
-    fontSize: tokens.fontSizeBase200,
-    backgroundColor: tokens.colorNeutralBackground3,
-    borderRadius: tokens.borderRadiusSmall,
+  calculationContext: {
+    maxWidth: '72ch',
+    color: tokens.colorNeutralForeground2,
+  },
+  sources: {
+    display: 'grid',
+    gap: tokens.spacingVerticalXS,
+    paddingTop: tokens.spacingVerticalXS,
+    borderTop: `${tokens.strokeWidthThin} solid ${tokens.colorNeutralStroke2}`,
   },
-  staleNotice: {
+  source: {
     display: 'flex',
     flexDirection: 'column',
     gap: tokens.spacingVerticalXXS,
-    padding: `${tokens.spacingVerticalXS} ${tokens.spacingHorizontalS}`,
-    color: tokens.colorPaletteDarkOrangeForeground1,
-    backgroundColor: tokens.colorPaletteDarkOrangeBackground1,
-    borderRadius: tokens.borderRadiusSmall,
+    minWidth: 0,
+    overflowWrap: 'anywhere',
   },
 })
diff --git a/frontend/src/components/Scenarios/ScenarioRunEstimate.test.tsx b/frontend/src/components/Scenarios/ScenarioRunEstimate.test.tsx
index 765f89d453..4ecf198111 100644
--- a/frontend/src/components/Scenarios/ScenarioRunEstimate.test.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunEstimate.test.tsx
@@ -1,9 +1,9 @@
 import type { ReactNode } from 'react'
 
-import { render, screen } from '@testing-library/react'
+import { render, screen, within } from '@testing-library/react'
 import { FluentProvider, webLightTheme } from '@fluentui/react-components'
 
-import type { ScenarioRunEstimateState, ScenarioRunSizeEstimateResponse } from '@/types'
+import type { ScenarioDefaultRunSizeEstimate, ScenarioRunEstimateState } from '@/types'
 
 import {
   ScenarioRunEstimateDetails,
@@ -15,126 +15,714 @@ function TestWrapper({ children }: { children: ReactNode }) {
   return <FluentProvider theme={webLightTheme}>{children}</FluentProvider>
 }
 
-const EXACT_ESTIMATE: ScenarioRunSizeEstimateResponse = {
-  estimated_attack_count: 8,
-  components: [
-    {
-      label: 'Prompt sending',
-      count: 6,
-      is_baseline: false,
-      note: 'One planned attack per selected objective and template.',
-    },
-    {
-      label: 'Baseline attack',
-      count: 2,
-      is_baseline: true,
-      note: null,
+function makeEstimate(
+  overrides: Partial<ScenarioDefaultRunSizeEstimate> = {},
+): ScenarioDefaultRunSizeEstimate {
+  return {
+    version: 1,
+    status: 'exact',
+    total_attack_count: 16,
+    minimum_attack_count: null,
+    maximum_attack_count: null,
+    condition: null,
+    components: [
+      {
+        label: 'Default technique sweep',
+        count: 16,
+        factors: [
+          { label: 'selected logical seed groups', count: 4 },
+          { label: 'default concrete techniques', count: 4 },
+        ],
+        is_baseline: false,
+        note: null,
+      },
+    ],
+    datasets: [
+      {
+        name: 'harmbench',
+        kind: 'dataset',
+        logical_seed_group_count: 400,
+        selected_seed_group_count: 4,
+        configured_caps: [],
+        selection_note: 'The default selection uses 4 of 400 available objectives.',
+      },
+    ],
+    adaptive_details: null,
+    note: null,
+    retries_included: false,
+    ...overrides,
+  }
+}
+
+function renderDetails(estimate: ScenarioDefaultRunSizeEstimate): void {
+  render(
+    <TestWrapper>
+      <ScenarioRunEstimateDetails state={mapScenarioRunEstimate(estimate, 'request')} />
+    </TestWrapper>,
+  )
+}
+
+describe('ScenarioRunEstimate', () => {
+  it('renders an exact technique-by-objective equation with a complete accessible sentence', () => {
+    renderDetails(makeEstimate())
+
+    const equation = screen.getByRole('group', {
+      name: '4 techniques multiplied by 4 objectives equals 16 planned attacks.',
+    })
+    expect(within(equation).getAllByText('4')).toHaveLength(2)
+    expect(within(equation).getByText('techniques')).toBeInTheDocument()
+    expect(within(equation).getByText('objectives')).toBeInTheDocument()
+    expect(within(equation).getByText('16')).toBeInTheDocument()
+    expect(within(equation).getByText('planned attacks')).toBeInTheDocument()
+    expect(screen.getByText('4 objectives from harmbench · 400 available')).toBeInTheDocument()
+    expect(screen.getByRole('heading', { name: 'Run calculation' })).toBeInTheDocument()
+  })
+
+  it.each([1, 4, 5])(
+    'renders a universal per-dataset cap of %i once before the objective-source rows',
+    (capCount) => {
+      renderDetails(makeEstimate({
+        datasets: [
+          {
+            name: 'airt_hate',
+            kind: 'dataset',
+            logical_seed_group_count: 4,
+            selected_seed_group_count: 4,
+            configured_caps: [{
+              label: 'per-dataset cap',
+              count: capCount,
+              configured_on: 'dataset',
+              dataset_name: 'airt_hate',
+            }],
+            selection_note: null,
+          },
+          {
+            name: 'airt_leakage',
+            kind: 'dataset',
+            logical_seed_group_count: 9,
+            selected_seed_group_count: 5,
+            configured_caps: [{
+              label: 'per-dataset cap',
+              count: capCount,
+              configured_on: 'dataset',
+              dataset_name: 'airt_leakage',
+            }],
+            selection_note: null,
+          },
+        ],
+      }))
+
+      const capText = `Per-dataset cap: ${capCount} ${capCount === 1 ? 'objective' : 'objectives'}`
+      expect(screen.getAllByText(capText)).toHaveLength(1)
+      expect(screen.getByText('4 objectives from airt_hate')).toBeInTheDocument()
+      expect(screen.getByText('5 objectives from airt_leakage · 9 available')).toBeInTheDocument()
+      const sources = screen.getByRole('group', { name: 'Objective sources' })
+      const sourceText = sources.textContent ?? ''
+      expect(sourceText.indexOf(capText)).toBeLessThan(sourceText.indexOf('4 objectives from airt_hate'))
     },
-  ],
-  datasets: [
-    {
-      name: 'harmbench',
-      kind: 'dataset',
-      logical_seed_group_count: 4,
-      selected_seed_group_count: 4,
-      configured_caps: [
-        {
-          label: 'Jailbreak templates',
+  )
+
+  it('keeps differing dataset caps with their affected objective-source rows', () => {
+    renderDetails(makeEstimate({
+      datasets: [
+        {
+          name: 'dataset_alpha',
+          kind: 'dataset',
+          logical_seed_group_count: 8,
+          selected_seed_group_count: 4,
+          configured_caps: [{
+            label: 'per-dataset cap',
+            count: 4,
+            configured_on: 'dataset',
+            dataset_name: 'dataset_alpha',
+          }],
+          selection_note: null,
+        },
+        {
+          name: 'dataset_beta',
+          kind: 'dataset',
+          logical_seed_group_count: 10,
+          selected_seed_group_count: 5,
+          configured_caps: [{
+            label: 'per-dataset cap',
+            count: 5,
+            configured_on: 'dataset',
+            dataset_name: 'dataset_beta',
+          }],
+          selection_note: null,
+        },
+      ],
+    }))
+
+    const alpha = screen.getByRole('group', { name: 'Objective source: dataset_alpha' })
+    const beta = screen.getByRole('group', { name: 'Objective source: dataset_beta' })
+    expect(within(alpha).getByText('Per-dataset cap: 4 objectives')).toBeInTheDocument()
+    expect(within(beta).getByText('Per-dataset cap: 5 objectives')).toBeInTheDocument()
+    expect(screen.getAllByText(/Per-dataset cap:/)).toHaveLength(2)
+  })
+
+  it('keeps a single-dataset cap attached to its objective-source row', () => {
+    renderDetails(makeEstimate({
+      datasets: [{
+        name: 'harmbench',
+        kind: 'dataset',
+        logical_seed_group_count: 8,
+        selected_seed_group_count: 4,
+        configured_caps: [{
+          label: 'per-dataset cap',
+          count: 4,
+          configured_on: 'dataset',
+          dataset_name: 'harmbench',
+        }],
+        selection_note: null,
+      }],
+    }))
+
+    const source = screen.getByRole('group', { name: 'Objective source: harmbench' })
+    expect(within(source).getByText('Per-dataset cap: 4 objectives')).toBeInTheDocument()
+  })
+
+  it('renders a global cap once while preserving differing per-dataset caps on rows', () => {
+    renderDetails(makeEstimate({
+      datasets: [
+        {
+          name: 'dataset_alpha',
+          kind: 'dataset',
+          logical_seed_group_count: 8,
+          selected_seed_group_count: 3,
+          configured_caps: [
+            {
+              label: 'per-dataset cap',
+              count: 3,
+              configured_on: 'dataset',
+              dataset_name: 'dataset_alpha',
+            },
+            {
+              label: 'combined compound cap',
+              count: 10,
+              configured_on: 'compound',
+              dataset_name: null,
+            },
+          ],
+          selection_note: null,
+        },
+        {
+          name: 'dataset_beta',
+          kind: 'dataset',
+          logical_seed_group_count: 8,
+          selected_seed_group_count: 4,
+          configured_caps: [
+            {
+              label: 'per-dataset cap',
+              count: 4,
+              configured_on: 'dataset',
+              dataset_name: 'dataset_beta',
+            },
+            {
+              label: 'combined compound cap',
+              count: 10,
+              configured_on: 'compound',
+              dataset_name: null,
+            },
+          ],
+          selection_note: null,
+        },
+      ],
+    }))
+
+    expect(screen.getAllByText('Combined compound cap: 10')).toHaveLength(1)
+    expect(within(screen.getByRole('group', {
+      name: 'Objective source: dataset_alpha',
+    })).getByText('Per-dataset cap: 3 objectives')).toBeInTheDocument()
+    expect(within(screen.getByRole('group', {
+      name: 'Objective source: dataset_beta',
+    })).getByText('Per-dataset cap: 4 objectives')).toBeInTheDocument()
+  })
+
+  it('keeps a configuration cap on only the rows where it applies', () => {
+    renderDetails(makeEstimate({
+      datasets: [
+        {
+          name: 'dataset_alpha',
+          kind: 'dataset',
+          logical_seed_group_count: 8,
+          selected_seed_group_count: 4,
+          configured_caps: [{
+            label: 'shared configuration cap',
+            count: 6,
+            configured_on: 'configuration',
+            dataset_name: null,
+          }],
+          selection_note: null,
+        },
+        {
+          name: 'dataset_beta',
+          kind: 'dataset',
+          logical_seed_group_count: 8,
+          selected_seed_group_count: 4,
+          configured_caps: [{
+            label: 'shared configuration cap',
+            count: 6,
+            configured_on: 'configuration',
+            dataset_name: null,
+          }],
+          selection_note: null,
+        },
+        {
+          name: 'dataset_gamma',
+          kind: 'dataset',
+          logical_seed_group_count: 8,
+          selected_seed_group_count: 8,
+          configured_caps: [],
+          selection_note: null,
+        },
+      ],
+    }))
+
+    expect(within(screen.getByRole('group', {
+      name: 'Objective source: dataset_alpha',
+    })).getByText('Shared configuration cap: 6')).toBeInTheDocument()
+    expect(within(screen.getByRole('group', {
+      name: 'Objective source: dataset_beta',
+    })).getByText('Shared configuration cap: 6')).toBeInTheDocument()
+    expect(within(screen.getByRole('group', {
+      name: 'Objective source: dataset_gamma',
+    })).queryByText(/Shared configuration cap/)).not.toBeInTheDocument()
+    expect(screen.getAllByText('Shared configuration cap: 6')).toHaveLength(2)
+  })
+
+  it('renders no cap summary for uncapped datasets and preserves the selection note', () => {
+    renderDetails(makeEstimate({
+      datasets: [{
+        name: 'harmbench',
+        kind: 'dataset',
+        logical_seed_group_count: 8,
+        selected_seed_group_count: 4,
+        configured_caps: [],
+        selection_note: 'Four compatible objectives remain after filtering.',
+      }],
+    }))
+
+    expect(screen.queryByText(/cap:/i)).not.toBeInTheDocument()
+    expect(screen.getByText('4 objectives from harmbench · 8 available')).toBeInTheDocument()
+    expect(screen.getByText('Four compatible objectives remain after filtering.')).toBeInTheDocument()
+  })
+
+  it('renders heterogeneous compatibility as truthful per-technique additive terms', () => {
+    renderDetails(makeEstimate({
+      total_attack_count: 6,
+      components: [
+        {
+          label: 'technique_alpha',
+          count: 4,
+          factors: [
+            { label: 'selected concrete techniques', count: 1 },
+            { label: 'compatible logical seed groups', count: 4 },
+          ],
+          is_baseline: false,
+          note: null,
+        },
+        {
+          label: 'technique_beta',
           count: 2,
-          configured_on: 'configuration',
-          dataset_name: null,
+          factors: [
+            { label: 'selected concrete techniques', count: 1 },
+            { label: 'compatible logical seed groups', count: 2 },
+          ],
+          is_baseline: false,
+          note: null,
         },
       ],
-      selection_note: 'Four compatible objective groups selected.',
-    },
-  ],
-  note: 'The backend total is authoritative.',
-}
+    }))
 
-describe('ScenarioRunEstimate', () => {
-  it('renders only the authoritative total and formula in the detailed preview', () => {
-    const state = mapScenarioRunEstimate(EXACT_ESTIMATE, 'request')
+    const equation = screen.getByTestId('run-calculation')
+    expect(within(equation).getByText('objectives · Technique alpha')).toBeInTheDocument()
+    expect(within(equation).getByText('objectives · Technique beta')).toBeInTheDocument()
+    expect(equation).toHaveTextContent('4objectives · Technique alpha+2objectives · Technique beta=6planned attacks')
+  })
+
+  it('uses parentheses to make baseline precedence explicit', () => {
+    renderDetails(makeEstimate({
+      total_attack_count: 20,
+      components: [
+        ...makeEstimate().components,
+        {
+          label: 'Baseline',
+          count: 4,
+          factors: [{ label: 'selected logical seed groups', count: 4 }],
+          is_baseline: true,
+          note: null,
+        },
+      ],
+    }))
+
+    const equation = screen.getByTestId('run-calculation')
+    expect(equation).toHaveTextContent('(4techniques×4objectives)+4direct baseline attacks=20planned attacks')
+    expect(screen.getByRole('group', {
+      name: '( 4 techniques multiplied by 4 objectives ) plus 4 direct baseline attacks equals 20 planned attacks.',
+    })).toBeInTheDocument()
+  })
+
+  it('keeps guaranteed and target-conditional terms in one bounded equation', () => {
+    renderDetails(makeEstimate({
+      status: 'conditional',
+      total_attack_count: null,
+      minimum_attack_count: 12,
+      maximum_attack_count: 20,
+      condition: 'target_capabilities',
+      components: [
+        {
+          label: 'Baseline',
+          count: 4,
+          factors: [{ label: 'objectives', count: 4 }],
+          is_baseline: true,
+          note: null,
+        },
+        {
+          label: 'Inline jailbreak delivery',
+          count: 8,
+          factors: [
+            { label: 'objectives', count: 4 },
+            { label: 'jailbreak templates', count: 2 },
+          ],
+          is_baseline: false,
+          note: null,
+        },
+        {
+          label: 'Native system-prompt jailbreak delivery',
+          count: 8,
+          factors: [
+            { label: 'objectives', count: 4 },
+            { label: 'jailbreak templates', count: 2 },
+          ],
+          is_baseline: false,
+          condition: 'target_capabilities',
+          note: null,
+        },
+      ],
+    }))
+
+    const equation = screen.getByTestId('run-calculation')
+    expect(equation).toHaveTextContent('4objectives · Inline jailbreak delivery')
+    expect(equation).toHaveTextContent('4objectives · Native system-prompt jailbreak delivery · if supported')
+    expect(equation).toHaveTextContent('4direct baseline attacks')
+    expect(equation).toHaveTextContent('12–20planned attacks')
+  })
 
+  it('shows adaptive progress objectives and the bounded underlying attempt work', () => {
+    const estimate = makeEstimate({
+      status: 'conditional',
+      total_attack_count: null,
+      components: [],
+      adaptive_details: {
+        objective_count: 21,
+        selected_candidate_technique_count: 2,
+        candidate_technique_count: 2,
+        max_attempts_per_objective: 3,
+        techniques_per_objective_upper_bound: 2,
+        technique_attempt_count_upper_bound: 42,
+        stop_on_first_success: true,
+        compatibility_may_reduce_attempts: true,
+      },
+    })
+    const state = mapScenarioRunEstimate(estimate, 'request')
     render(
       <TestWrapper>
+        <ScenarioRunEstimateSummary state={state} />
         <ScenarioRunEstimateDetails state={state} />
       </TestWrapper>,
     )
 
-    expect(screen.getByText('8 attacks')).toBeInTheDocument()
+    expect(screen.getByText('21 objectives · up to 42 technique attempts')).toBeInTheDocument()
+    expect(screen.getByRole('group', {
+      name: '21 objectives multiplied by up to 2 techniques per objective, the smaller of 2 selected candidates and limit 3, equals up to 42 technique attempts.',
+    })).toBeInTheDocument()
+    expect(screen.getByText('2 selected candidates · limit 3')).toBeInTheDocument()
+    expect(screen.getByRole('group', {
+      name: 'Direct baseline comparison is not included: up to 21 Adaptive attacks. Planned total is confirmed at launch.',
+    })).toBeInTheDocument()
+    expect(screen.queryByText('Exact total')).not.toBeInTheDocument()
     expect(screen.getByText(
-      'Prompt sending: 6 + Baseline attack: 2 = 8',
+      'Technique-attempt totals exclude multi-turn target exchanges and retries. Adaptive stops each objective after the first successful technique. Compatibility may reduce how many candidates each objective can try.',
     )).toBeInTheDocument()
-    expect(screen.queryByText('Backend estimate')).not.toBeInTheDocument()
-    expect(screen.queryByText('Current configuration')).not.toBeInTheDocument()
-    expect(screen.queryByText('Planned components')).not.toBeInTheDocument()
-    expect(screen.queryByText('Dataset populations')).not.toBeInTheDocument()
   })
 
-  it('supports loading, conditional null totals, unavailable, and stale states', () => {
-    const loading: ScenarioRunEstimateState = { status: 'loading', scope: 'request' }
-    const { rerender } = render(
+  it('shows baseline-aware planned attacks before unchanged Adaptive work', () => {
+    const estimate = makeEstimate({
+      status: 'conditional',
+      total_attack_count: null,
+      minimum_attack_count: 21,
+      maximum_attack_count: 42,
+      components: [
+        {
+          label: 'Baseline',
+          count: 21,
+          factors: [{ label: 'objectives', count: 21 }],
+          is_baseline: true,
+          note: null,
+        },
+        {
+          label: 'Adaptive objectives',
+          count: 21,
+          factors: [{ label: 'compatible objectives', count: 21 }],
+          is_baseline: false,
+          note: null,
+        },
+      ],
+      adaptive_details: {
+        objective_count: 21,
+        selected_candidate_technique_count: 2,
+        candidate_technique_count: 2,
+        max_attempts_per_objective: 3,
+        techniques_per_objective_upper_bound: 2,
+        technique_attempt_count_upper_bound: 42,
+        stop_on_first_success: true,
+        compatibility_may_reduce_attempts: true,
+      },
+    })
+    const state = mapScenarioRunEstimate(estimate, 'request')
+    render(
       <TestWrapper>
-        <ScenarioRunEstimateDetails state={loading} />
+        <ScenarioRunEstimateSummary state={state} />
+        <ScenarioRunEstimateDetails state={state} />
       </TestWrapper>,
     )
-    expect(screen.getByText('Calculating run estimate...')).toBeInTheDocument()
 
-    const conditional = mapScenarioRunEstimate({
-      ...EXACT_ESTIMATE,
-      estimated_attack_count: null,
-      minimum_attack_count: 12,
-      maximum_attack_count: 20,
-      components: [{ label: 'Possible attacks', count: 20, is_baseline: false, note: null }],
-      datasets: [],
-      note: null,
-    }, 'default')
-    rerender(
-      <TestWrapper>
-        <ScenarioRunEstimateDetails state={conditional} />
-      </TestWrapper>,
+    expect(screen.getByText('21–42 planned attacks · up to 42 technique attempts')).toBeInTheDocument()
+    const plannedEquation = screen.getByRole('group', {
+      name: 'Direct baseline comparison is included: 21 direct baseline attacks plus up to 21 Adaptive attacks equals 21–42 planned attacks.',
+    })
+    expect(plannedEquation).toHaveTextContent(
+      '21direct baseline attacks+up to 21Adaptive attacks=21–42planned attacks',
     )
-    expect(screen.getByText('12-20 attacks')).toBeInTheDocument()
-    expect(screen.getByText(
-      'Possible attacks: 20 = conditional total',
-    )).toBeInTheDocument()
+    expect(screen.getByRole('heading', { name: 'Planned attacks' })).toBeInTheDocument()
+    expect(screen.getByRole('heading', { name: 'Adaptive work' })).toBeInTheDocument()
+    const adaptiveWork = screen.getByTestId('adaptive-work-calculation')
+    expect(adaptiveWork).toHaveTextContent('21objectives×up to 2techniques per objective')
+    expect(adaptiveWork).toHaveTextContent('=up to 42technique attempts')
+    expect(screen.queryByText(/Attempt ceiling:/)).not.toBeInTheDocument()
+    expect(screen.queryByText(/Progress tracks/)).not.toBeInTheDocument()
+    expect(screen.queryByText(/objective envelope|logical seed groups|selected seed groups/i)).not.toBeInTheDocument()
+  })
 
-    const unavailable = mapScenarioRunEstimate({
-      ...EXACT_ESTIMATE,
-      estimated_attack_count: null,
+  it('removes the baseline term while keeping Adaptive work unchanged', () => {
+    renderDetails(makeEstimate({
+      status: 'conditional',
+      total_attack_count: null,
+      minimum_attack_count: null,
+      maximum_attack_count: 21,
+      components: [
+        {
+          label: 'Adaptive objectives',
+          count: 21,
+          factors: [{ label: 'compatible objectives', count: 21 }],
+          is_baseline: false,
+          note: null,
+        },
+      ],
+      adaptive_details: {
+        objective_count: 21,
+        selected_candidate_technique_count: 14,
+        candidate_technique_count: 14,
+        max_attempts_per_objective: 14,
+        techniques_per_objective_upper_bound: 14,
+        technique_attempt_count_upper_bound: 294,
+        stop_on_first_success: true,
+        compatibility_may_reduce_attempts: true,
+      },
+    }))
+
+    const plannedEquation = screen.getByRole('group', {
+      name: 'Direct baseline comparison is not included: up to 21 Adaptive attacks equals up to 21 planned attacks.',
+    })
+    expect(plannedEquation).toHaveTextContent('up to 21Adaptive attacks=up to 21planned attacks')
+    expect(within(plannedEquation).queryByText(/baseline attack/)).not.toBeInTheDocument()
+    const adaptiveWork = screen.getByTestId('adaptive-work-calculation')
+    expect(adaptiveWork).toHaveTextContent('21objectives×up to 14techniques per objective')
+    expect(adaptiveWork).toHaveTextContent('=up to 294technique attempts')
+  })
+
+  it('renders exact Adaptive planned values without inventing a range', () => {
+    renderDetails(makeEstimate({
+      status: 'exact',
+      total_attack_count: 42,
       minimum_attack_count: null,
       maximum_attack_count: null,
+      components: [
+        {
+          label: 'Baseline',
+          count: 21,
+          factors: [{ label: 'objectives', count: 21 }],
+          is_baseline: true,
+          note: null,
+        },
+        {
+          label: 'Adaptive objectives',
+          count: 21,
+          factors: [{ label: 'objectives', count: 21 }],
+          is_baseline: false,
+          note: null,
+        },
+      ],
+      adaptive_details: {
+        objective_count: 21,
+        selected_candidate_technique_count: 14,
+        candidate_technique_count: 14,
+        max_attempts_per_objective: 14,
+        techniques_per_objective_upper_bound: 14,
+        technique_attempt_count_upper_bound: 294,
+        stop_on_first_success: true,
+        compatibility_may_reduce_attempts: false,
+      },
+    }))
+
+    expect(screen.getByRole('group', {
+      name: 'Direct baseline comparison is included: 21 direct baseline attacks plus 21 Adaptive attacks equals 42 planned attacks.',
+    })).toBeInTheDocument()
+    expect(screen.queryByText('21–42')).not.toBeInTheDocument()
+  })
+
+  it('preserves a nonzero Adaptive planned range when no baseline is included', () => {
+    renderDetails(makeEstimate({
+      status: 'conditional',
+      total_attack_count: null,
+      minimum_attack_count: 5,
+      maximum_attack_count: 21,
+      components: [],
+      adaptive_details: {
+        objective_count: 21,
+        selected_candidate_technique_count: 2,
+        candidate_technique_count: 2,
+        max_attempts_per_objective: 2,
+        techniques_per_objective_upper_bound: 2,
+        technique_attempt_count_upper_bound: 42,
+        stop_on_first_success: true,
+        compatibility_may_reduce_attempts: true,
+      },
+    }))
+
+    expect(screen.getByRole('group', {
+      name: 'Direct baseline comparison is not included: 5–21 Adaptive attacks equals 5–21 planned attacks.',
+    })).toBeInTheDocument()
+  })
+
+  it('uses the configured max when it is lower than the adaptive candidate pool', () => {
+    renderDetails(makeEstimate({
+      status: 'conditional',
+      total_attack_count: null,
+      components: [],
+      adaptive_details: {
+        objective_count: 21,
+        selected_candidate_technique_count: 14,
+        candidate_technique_count: 5,
+        max_attempts_per_objective: 3,
+        techniques_per_objective_upper_bound: 3,
+        technique_attempt_count_upper_bound: 63,
+        stop_on_first_success: true,
+        compatibility_may_reduce_attempts: true,
+      },
+    }))
+
+    expect(screen.getByText('5 compatible candidates from 14 selected · limit 3')).toBeInTheDocument()
+    expect(screen.getByText('up to 63')).toBeInTheDocument()
+  })
+
+  it('uses the candidate pool when it is lower than the adaptive max', () => {
+    renderDetails(makeEstimate({
+      status: 'conditional',
+      total_attack_count: null,
+      components: [],
+      adaptive_details: {
+        objective_count: 21,
+        selected_candidate_technique_count: 2,
+        candidate_technique_count: 2,
+        max_attempts_per_objective: 5,
+        techniques_per_objective_upper_bound: 2,
+        technique_attempt_count_upper_bound: 42,
+        stop_on_first_success: true,
+        compatibility_may_reduce_attempts: true,
+      },
+    }))
+
+    expect(screen.getByText('techniques per objective')).toBeInTheDocument()
+    expect(screen.getByText('2 selected candidates · limit 5')).toBeInTheDocument()
+    expect(screen.getByText('up to 42')).toBeInTheDocument()
+  })
+
+  it('adapts legacy version-one payloads without the selected candidate count', () => {
+    const estimate = mapScenarioRunEstimate(makeEstimate({
+      status: 'conditional',
+      total_attack_count: null,
+      components: [],
+      adaptive_details: {
+        objective_count: 21,
+        candidate_technique_count: 2,
+        max_attempts_per_objective: 3,
+        techniques_per_objective_upper_bound: 2,
+        technique_attempt_count_upper_bound: 42,
+        stop_on_first_success: true,
+        compatibility_may_reduce_attempts: true,
+      },
+    }), 'request')
+
+    expect(estimate).toMatchObject({
+      status: 'conditional',
+      estimate: {
+        adaptiveDetails: {
+          selectedCandidateTechniqueCount: 2,
+        },
+      },
+    })
+  })
+
+  it('preserves loading, unavailable, and unknown conditional states', () => {
+    const loading: ScenarioRunEstimateState = { status: 'loading', scope: 'request' }
+    const { rerender } = render(
+      <TestWrapper><ScenarioRunEstimateDetails state={loading} /></TestWrapper>,
+    )
+    expect(screen.getByText('Calculating planned attacks...')).toBeInTheDocument()
+
+    const unavailable = mapScenarioRunEstimate(makeEstimate({
+      status: 'unavailable',
+      total_attack_count: null,
       components: [],
       datasets: [],
       note: 'Target capability is not available.',
-    }, 'request')
+    }), 'request')
+    rerender(<TestWrapper><ScenarioRunEstimateDetails state={unavailable} /></TestWrapper>)
+    expect(screen.getByText('Estimate unavailable')).toBeInTheDocument()
+    expect(screen.getByText('Configured run size unavailable')).toBeInTheDocument()
+
     rerender(
       <TestWrapper>
-        <ScenarioRunEstimateSummary state={unavailable} />
-        <ScenarioRunEstimateDetails state={unavailable} />
+        <ScenarioRunEstimateDetails state={mapScenarioRunEstimate(makeEstimate({
+          status: 'conditional',
+          total_attack_count: null,
+          minimum_attack_count: null,
+          maximum_attack_count: null,
+          components: [],
+          datasets: [],
+        }), 'default')}
+        />
       </TestWrapper>,
     )
-    expect(screen.getByText('Estimate unavailable')).toBeInTheDocument()
-    expect(screen.getByText('Configured run size unavailable')).toBeInTheDocument()
-    expect(screen.getByText('Target capability is not available.')).toBeInTheDocument()
-
-    const exact = mapScenarioRunEstimate(EXACT_ESTIMATE, 'request')
-    if (exact.status !== 'available') {
-      throw new Error('Expected exact estimate to map to an available state.')
-    }
-    const stale: ScenarioRunEstimateState = {
-      status: 'stale',
-      estimate: exact.estimate,
-      label: 'Showing the last successful estimate.',
-      error: 'Preview service timed out.',
-    }
-    rerender(
+    expect(screen.getByText('Exact total')).toBeInTheDocument()
+    expect(screen.getByText('unavailable')).toBeInTheDocument()
+  })
+
+  it('does not render implementation terminology in the shared estimate surfaces', () => {
+    const state = mapScenarioRunEstimate(makeEstimate(), 'request')
+    render(
       <TestWrapper>
-        <ScenarioRunEstimateDetails state={stale} />
+        <ScenarioRunEstimateSummary state={state} />
+        <ScenarioRunEstimateDetails state={state} />
       </TestWrapper>,
     )
-    expect(screen.getByText('8 attacks')).toBeInTheDocument()
-    expect(screen.queryByText('Showing the last successful estimate.')).not.toBeInTheDocument()
-    expect(screen.queryByText('Preview service timed out.')).not.toBeInTheDocument()
+
+    expect(screen.queryByText(/logical seed groups/i)).not.toBeInTheDocument()
+    expect(screen.queryByText(/selected seed groups/i)).not.toBeInTheDocument()
+    expect(screen.queryByText(/planned components/i)).not.toBeInTheDocument()
+    expect(screen.queryByText(/objective envelopes/i)).not.toBeInTheDocument()
+    expect(screen.queryByText(/how this count is calculated/i)).not.toBeInTheDocument()
   })
 })
diff --git a/frontend/src/components/Scenarios/ScenarioRunEstimate.tsx b/frontend/src/components/Scenarios/ScenarioRunEstimate.tsx
index 70f269acb0..f15d4d7583 100644
--- a/frontend/src/components/Scenarios/ScenarioRunEstimate.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunEstimate.tsx
@@ -3,18 +3,49 @@ import { Badge, Spinner, Text } from '@fluentui/react-components'
 import type {
   ScenarioRunEstimate,
   ScenarioRunEstimateComponent,
+  ScenarioRunEstimateDatasetCap,
+  ScenarioRunEstimateFactor,
   ScenarioRunEstimateState,
 } from '@/types'
 
+import {
+  formatAdaptiveCapAccessibleRule,
+  formatAdaptiveCapMetadata,
+} from './scenarioAdaptiveCap'
+import { normalizeDatasetCaps } from './scenarioDatasetCaps'
 import { useScenarioRunEstimateStyles } from './ScenarioRunEstimate.styles'
 
 interface ScenarioRunEstimateSummaryProps {
   state: ScenarioRunEstimateState
-  compact?: boolean
 }
 
 interface ScenarioRunEstimateDetailsProps {
   state: ScenarioRunEstimateState
+  idPrefix?: string
+}
+
+interface CalculationOperand {
+  id: string
+  value: string
+  label: string
+  detail?: string
+  result?: boolean
+}
+
+interface CalculationOperator {
+  id: string
+  symbol: '(' | ')' | '×' | '+' | '='
+}
+
+type CalculationPart =
+  | { kind: 'operand'; operand: CalculationOperand }
+  | { kind: 'operator'; operator: CalculationOperator }
+
+interface RunCalculation {
+  parts: CalculationPart[]
+  accessibleLabel: string
+  summary?: string
+  context?: string
 }
 
 function stateEstimate(state: ScenarioRunEstimateState): ScenarioRunEstimate | undefined {
@@ -36,18 +67,17 @@ function scopeLabel(state: ScenarioRunEstimateState): string {
   return scope === 'default' ? 'Default configuration' : 'Current configuration'
 }
 
-function statusLabel(state: ScenarioRunEstimateState): string {
+function statusLabel(state: ScenarioRunEstimateState): string | null {
   switch (state.status) {
     case 'loading':
       return 'Loading estimate'
     case 'available':
-      return 'Backend estimate'
     case 'conditional':
-      return 'Conditional estimate'
+      return null
     case 'refreshing':
-      return 'Updating estimate'
+      return state.label
     case 'stale':
-      return 'Previous estimate'
+      return 'Estimate may be out of date'
     case 'unavailable':
       return 'Estimate unavailable'
   }
@@ -56,7 +86,6 @@ function statusLabel(state: ScenarioRunEstimateState): string {
 function statusColor(state: ScenarioRunEstimateState): 'brand' | 'warning' | 'subtle' {
   switch (state.status) {
     case 'available':
-    case 'refreshing':
       return 'brand'
     case 'conditional':
     case 'stale':
@@ -66,6 +95,10 @@ function statusColor(state: ScenarioRunEstimateState): 'brand' | 'warning' | 'su
   }
 }
 
+function formatCount(value: number): string {
+  return value.toLocaleString()
+}
+
 function formatEstimateValue(value: number): string {
   return value.toLocaleString()
 }
@@ -76,63 +109,501 @@ function countLabel(value: number, singular: string, plural: string): string {
 
 function formatPlannedAttackSummary(estimate: ScenarioRunEstimate): string {
   if (estimate.total !== null) {
-    return countLabel(estimate.total, 'attack', 'attacks')
+    return countLabel(estimate.total, 'planned attack', 'planned attacks')
   }
   if (estimate.minimum != null && estimate.maximum != null) {
     return estimate.minimum === estimate.maximum
-      ? countLabel(estimate.minimum, 'attack', 'attacks')
-      : `${formatEstimateValue(estimate.minimum)}-${formatEstimateValue(estimate.maximum)} attacks`
+      ? countLabel(estimate.minimum, 'planned attack', 'planned attacks')
+      : `${formatEstimateValue(estimate.minimum)}–${formatEstimateValue(estimate.maximum)} planned attacks`
+  }
+  if (estimate.maximum != null) {
+    return `Up to ${countLabel(estimate.maximum, 'planned attack', 'planned attacks')}`
+  }
+  if (estimate.minimum != null) {
+    return `At least ${countLabel(estimate.minimum, 'planned attack', 'planned attacks')}`
+  }
+  return estimate.scope === 'default'
+    ? 'Select targets to calculate'
+    : 'Run size is confirmed at launch.'
+}
+
+function baselineCount(estimate: ScenarioRunEstimate): number {
+  return estimate.components
+    .filter((component) => component.isBaseline)
+    .reduce((sum, component) => sum + component.count, 0)
+}
+
+function formatEstimateSummary(estimate: ScenarioRunEstimate): string {
+  if (estimate.adaptiveDetails) {
+    const { objectiveCount, techniqueAttemptCountUpperBound } = estimate.adaptiveDetails
+    const attemptSummary = `up to ${countLabel(
+      techniqueAttemptCountUpperBound,
+      'technique attempt',
+      'technique attempts',
+    )}`
+    const hasPlannedAttackBound = estimate.total !== null
+      || estimate.minimum != null
+      || estimate.maximum != null
+    return hasPlannedAttackBound
+      ? `${formatPlannedAttackSummary(estimate)} · ${attemptSummary}`
+      : `${countLabel(objectiveCount, 'objective', 'objectives')} · ${attemptSummary}`
+  }
+  return formatPlannedAttackSummary(estimate)
+}
+
+function operand(id: string, value: string, label: string, result = false, detail?: string): CalculationPart {
+  return { kind: 'operand', operand: { id, value, label, detail, result } }
+}
+
+function operator(id: string, symbol: CalculationOperator['symbol']): CalculationPart {
+  return { kind: 'operator', operator: { id, symbol } }
+}
+
+function humanizeLabel(label: string): string {
+  const words = label.replace(/_/g, ' ').trim()
+  return words.length > 0 ? `${words[0].toUpperCase()}${words.slice(1)}` : label
+}
+
+function formatDatasetCap(cap: ScenarioRunEstimateDatasetCap): string {
+  const count = cap.configuredOn === 'dataset'
+    ? countLabel(cap.count, 'objective', 'objectives')
+    : formatCount(cap.count)
+  return `${humanizeLabel(cap.label)}: ${count}`
+}
+
+function semanticFactorLabel(factor: ScenarioRunEstimateFactor): string {
+  const label = factor.label.toLowerCase()
+  if (label.includes('seed group') || label === 'objectives') {
+    return factor.count === 1 ? 'objective' : 'objectives'
+  }
+  if (label.includes('technique')) {
+    return factor.count === 1 ? 'technique' : 'techniques'
+  }
+  if (factor.count === 1 && label.endsWith('s')) {
+    return label.slice(0, -1)
+  }
+  return label
+}
+
+function factorPriority(factor: ScenarioRunEstimateFactor): number {
+  const label = semanticFactorLabel(factor)
+  if (label === 'technique' || label === 'techniques') return 0
+  if (label === 'objective' || label === 'objectives') return 1
+  return 2
+}
+
+function objectiveFactor(component: ScenarioRunEstimateComponent): ScenarioRunEstimateFactor | undefined {
+  return component.factors.find((factor) => {
+    const label = semanticFactorLabel(factor)
+    return label === 'objective' || label === 'objectives'
+  })
+}
+
+function resultOperand(estimate: ScenarioRunEstimate): CalculationOperand {
+  if (estimate.total !== null) {
+    return {
+      id: 'result',
+      value: formatCount(estimate.total),
+      label: estimate.total === 1 ? 'planned attack' : 'planned attacks',
+      result: true,
+    }
+  }
+  if (estimate.minimum != null && estimate.maximum != null) {
+    return {
+      id: 'result',
+      value: estimate.minimum === estimate.maximum
+        ? formatCount(estimate.minimum)
+        : `${formatCount(estimate.minimum)}–${formatCount(estimate.maximum)}`,
+      label: estimate.minimum === 1 && estimate.maximum === 1 ? 'planned attack' : 'planned attacks',
+      result: true,
+    }
   }
   if (estimate.maximum != null) {
-    return `Up to ${countLabel(estimate.maximum, 'attack', 'attacks')}`
+    return {
+      id: 'result',
+      value: `up to ${formatCount(estimate.maximum)}`,
+      label: estimate.maximum === 1 ? 'planned attack' : 'planned attacks',
+      result: true,
+    }
   }
   if (estimate.minimum != null) {
-    return `At least ${countLabel(estimate.minimum, 'attack', 'attacks')}`
+    return {
+      id: 'result',
+      value: `at least ${formatCount(estimate.minimum)}`,
+      label: estimate.minimum === 1 ? 'planned attack' : 'planned attacks',
+      result: true,
+    }
+  }
+  return { id: 'result', value: 'Exact total', label: 'unavailable', result: true }
+}
+
+function adaptivePlannedCalculation(estimate: ScenarioRunEstimate): RunCalculation {
+  const details = estimate.adaptiveDetails
+  if (!details) {
+    throw new Error('Adaptive planned calculation requires adaptive details.')
+  }
+  const directBaselineCount = baselineCount(estimate)
+  const hasExactTotal = estimate.total !== null
+    || (
+      estimate.minimum != null
+      && estimate.maximum != null
+      && estimate.minimum === estimate.maximum
+    )
+  const hasPlannedTotal = estimate.total !== null
+    || estimate.minimum != null
+    || estimate.maximum != null
+  const adaptiveAttackCount = hasExactTotal
+    ? Math.max((estimate.total ?? estimate.maximum ?? 0) - directBaselineCount, 0)
+    : estimate.maximum != null
+      ? Math.max(estimate.maximum - directBaselineCount, 0)
+      : estimate.minimum != null
+        ? Math.max(estimate.minimum - directBaselineCount, 0)
+        : details.objectiveCount
+  const hasAdaptiveRange = directBaselineCount === 0
+    && estimate.minimum != null
+    && estimate.minimum > 0
+    && estimate.maximum != null
+    && estimate.minimum !== estimate.maximum
+  const adaptiveValue = hasExactTotal
+    ? formatCount(adaptiveAttackCount)
+    : hasAdaptiveRange
+      ? `${formatCount(estimate.minimum ?? 0)}–${formatCount(estimate.maximum ?? 0)}`
+      : estimate.maximum != null || estimate.minimum == null
+        ? `up to ${formatCount(adaptiveAttackCount)}`
+        : `at least ${formatCount(adaptiveAttackCount)}`
+  const adaptiveLabel = adaptiveAttackCount === 1 ? 'Adaptive attack' : 'Adaptive attacks'
+  const result = resultOperand(estimate)
+  const parts: CalculationPart[] = []
+  if (directBaselineCount > 0) {
+    parts.push(operand(
+      'baseline',
+      formatCount(directBaselineCount),
+      directBaselineCount === 1 ? 'direct baseline attack' : 'direct baseline attacks',
+    ))
+    parts.push(operator('baseline-plus', '+'))
+  }
+  parts.push(operand('adaptive-attacks', adaptiveValue, adaptiveLabel))
+  if (hasPlannedTotal) {
+    parts.push(operator('planned-equals', '='))
+    parts.push({ kind: 'operand', operand: result })
+  }
+
+  const adaptivePhrase = `${adaptiveValue} ${adaptiveLabel}`
+  const resultPhrase = `${result.value} ${result.label}`
+  const plannedResultPhrase = hasPlannedTotal
+    ? ` equals ${resultPhrase}.`
+    : '. Planned total is confirmed at launch.'
+  const accessibleLabel = directBaselineCount > 0
+    ? `Direct baseline comparison is included: ${countLabel(
+      directBaselineCount,
+      'direct baseline attack',
+      'direct baseline attacks',
+    )} plus ${adaptivePhrase}${plannedResultPhrase}`
+    : `Direct baseline comparison is not included: ${adaptivePhrase}${plannedResultPhrase}`
+  return { parts, accessibleLabel }
+}
+
+function adaptiveWorkCalculation(estimate: ScenarioRunEstimate): RunCalculation {
+  const details = estimate.adaptiveDetails
+  if (!details) {
+    throw new Error('Adaptive work calculation requires adaptive details.')
+  }
+  const objectiveLabel = details.objectiveCount === 1 ? 'objective' : 'objectives'
+  const techniqueLabel = details.techniquesPerObjectiveUpperBound === 1
+    ? 'technique per objective'
+    : 'techniques per objective'
+  const attemptLabel = details.techniqueAttemptCountUpperBound === 1
+    ? 'technique attempt'
+    : 'technique attempts'
+  const capProvenance = {
+    selectedCandidateCount: details.selectedCandidateTechniqueCount,
+    compatibleCandidateCount: details.candidateTechniqueCount,
+    limit: details.maxAttemptsPerObjective,
+    effectiveMaximum: details.techniquesPerObjectiveUpperBound,
+  }
+  const effectiveCapRule = formatAdaptiveCapMetadata(capProvenance)
+  const accessibleCapRule = formatAdaptiveCapAccessibleRule(capProvenance)
+  return {
+    parts: [
+      operand('adaptive-objectives', formatCount(details.objectiveCount), objectiveLabel),
+      operator('adaptive-multiply', '×'),
+      operand(
+        'adaptive-techniques',
+        `up to ${formatCount(details.techniquesPerObjectiveUpperBound)}`,
+        techniqueLabel,
+        false,
+        effectiveCapRule,
+      ),
+      operator('adaptive-equals', '='),
+      operand(
+        'adaptive-result',
+        `up to ${formatCount(details.techniqueAttemptCountUpperBound)}`,
+        attemptLabel,
+        true,
+      ),
+    ],
+    accessibleLabel: `${countLabel(details.objectiveCount, 'objective', 'objectives')} multiplied by up to ${
+      countLabel(details.techniquesPerObjectiveUpperBound, 'technique per objective', 'techniques per objective')
+    }, ${accessibleCapRule}, equals up to ${
+      countLabel(details.techniqueAttemptCountUpperBound, 'technique attempt', 'technique attempts')
+    }.`,
   }
-  return 'Attack count varies'
 }
 
-function formatComponentFormula(component: ScenarioRunEstimateComponent): string {
-  return `${component.label}: ${formatEstimateValue(component.count)}`
+function adaptiveWorkContext(estimate: ScenarioRunEstimate): string {
+  const details = estimate.adaptiveDetails
+  if (!details) {
+    throw new Error('Adaptive work context requires adaptive details.')
+  }
+  const compatibilityContext = details.compatibilityMayReduceAttempts
+    ? ' Compatibility may reduce how many candidates each objective can try.'
+    : ''
+  return `Technique-attempt totals exclude multi-turn target exchanges and retries. Adaptive stops each objective after the first successful technique.${compatibilityContext}`
+}
+
+function homogeneousTechniqueCalculation(
+  components: ScenarioRunEstimateComponent[],
+): CalculationPart[] | null {
+  if (components.length < 2 || components.some((component) => component.condition !== null)) {
+    return null
+  }
+  const objectiveCounts = components.map((component) => objectiveFactor(component)?.count)
+  if (objectiveCounts.some((count) => count === undefined)) {
+    return null
+  }
+  const firstCount = objectiveCounts[0]
+  if (!objectiveCounts.every((count) => count === firstCount)) {
+    return null
+  }
+  return [
+    operand(
+      'technique-count',
+      formatCount(components.length),
+      components.length === 1 ? 'technique' : 'techniques',
+    ),
+    operator('technique-multiply', '×'),
+    operand(
+      'objective-count',
+      formatCount(firstCount ?? 0),
+      firstCount === 1 ? 'objective' : 'objectives',
+    ),
+  ]
 }
 
-function formatBackendFormula(estimate: ScenarioRunEstimate): string {
-  const components = estimate.components.length > 0
-    ? estimate.components.map(formatComponentFormula).join(' + ')
-    : 'No additive components supplied'
-  const total = estimate.total === null
-    ? 'conditional total'
-    : formatEstimateValue(estimate.total)
-  return `${components} = ${total}`
+function componentTerms(components: ScenarioRunEstimateComponent[]): CalculationPart[] {
+  const homogeneous = homogeneousTechniqueCalculation(components)
+  if (homogeneous) {
+    return homogeneous
+  }
+  if (components.length === 1 && components[0].condition === null && components[0].factors.length > 0) {
+    return [...components[0].factors]
+      .sort((left, right) => factorPriority(left) - factorPriority(right))
+      .flatMap((factor, index) => [
+        ...(index > 0 ? [operator(`factor-${index}-multiply`, '×')] : []),
+        operand(`factor-${factor.id}`, formatCount(factor.count), semanticFactorLabel(factor)),
+      ])
+  }
+  return components.flatMap((component, index) => {
+    const objectiveCount = objectiveFactor(component)?.count
+    const value = formatCount(objectiveCount ?? component.count)
+    const unit = objectiveCount === undefined
+      ? component.count === 1 ? 'planned attack' : 'planned attacks'
+      : objectiveCount === 1 ? 'objective' : 'objectives'
+    const condition = component.condition ? ' · if supported' : ''
+    return [
+      ...(index > 0 ? [operator(`component-${index}-plus`, '+')] : []),
+      operand(
+        `component-${component.id}`,
+        value,
+        `${unit} · ${humanizeLabel(component.label)}${condition}`,
+      ),
+    ]
+  })
+}
+
+function ordinaryCalculation(estimate: ScenarioRunEstimate): RunCalculation {
+  const baselineCount = estimate.components
+    .filter((component) => component.isBaseline)
+    .reduce((sum, component) => sum + component.count, 0)
+  const attackComponents = estimate.components.filter((component) => !component.isBaseline)
+  const resultOnly = baselineCount === 0
+    && attackComponents.length === 1
+    && attackComponents[0].factors.length === 0
+    && attackComponents[0].condition === null
+  const attackParts = resultOnly ? [] : componentTerms(attackComponents)
+  const hasMultiplication = attackParts.some(
+    (part) => part.kind === 'operator' && part.operator.symbol === '×',
+  )
+  const parts: CalculationPart[] = []
+  if (baselineCount > 0 && hasMultiplication) {
+    parts.push(operator('attack-open', '('))
+  }
+  parts.push(...attackParts)
+  if (baselineCount > 0 && hasMultiplication) {
+    parts.push(operator('attack-close', ')'))
+  }
+  if (baselineCount > 0) {
+    if (attackParts.length > 0) {
+      parts.push(operator('baseline-plus', '+'))
+    }
+    parts.push(operand(
+      'baseline',
+      formatCount(baselineCount),
+      baselineCount === 1 ? 'direct baseline attack' : 'direct baseline attacks',
+    ))
+  }
+  const result = resultOperand(estimate)
+  if (parts.length > 0) {
+    parts.push(operator('total-equals', '='))
+  }
+  parts.push({ kind: 'operand', operand: result })
+
+  const visibleExpression = parts.map((part) => part.kind === 'operator'
+    ? part.operator.symbol
+    : `${part.operand.value} ${part.operand.label}`).join(' ')
+  return {
+    parts,
+    accessibleLabel: `${visibleExpression
+      .replace(/×/g, 'multiplied by')
+      .replace(/\+/g, 'plus')
+      .replace(/=/g, 'equals')}.`,
+    context: estimate.total === null && estimate.minimum == null && estimate.maximum == null
+      ? formatEstimateSummary(estimate)
+      : undefined,
+  }
 }
 
-export function ScenarioRunEstimateSummary({ state, compact = false }: ScenarioRunEstimateSummaryProps) {
+export function ScenarioRunEstimateSummary({ state }: ScenarioRunEstimateSummaryProps) {
   const styles = useScenarioRunEstimateStyles()
   const estimate = stateEstimate(state)
 
   return (
     <div className={styles.summary} aria-live="polite">
       <div className={styles.summaryHeader}>
-        {!compact && <Badge appearance="tint" color={statusColor(state)}>{statusLabel(state)}</Badge>}
+        <Badge appearance="tint" color={statusColor(state)}>{statusLabel(state)}</Badge>
         {estimate && (
           <Text className={styles.total} weight="semibold">
-            {formatPlannedAttackSummary(estimate)}
+            {formatEstimateSummary(estimate)}
           </Text>
         )}
-        {compact && !estimate && <Text className={styles.total}>{statusLabel(state)}</Text>}
       </div>
-      {!compact && <Text size={200} className={styles.muted}>{scopeLabel(state)}</Text>}
     </div>
   )
 }
 
-export function ScenarioRunEstimateDetails({ state }: ScenarioRunEstimateDetailsProps) {
+function RunCalculationView({
+  calculation,
+  heading,
+  idPrefix,
+  testId,
+}: {
+  calculation: RunCalculation
+  heading: string
+  idPrefix: string
+  testId: string
+}) {
+  const styles = useScenarioRunEstimateStyles()
+  const headingId = `${idPrefix}-calculation`
+
+  return (
+    <section className={styles.calculationSection} aria-labelledby={headingId}>
+      <Text as="h4" id={headingId} weight="semibold">{heading}</Text>
+      <div
+        className={styles.equation}
+        role="group"
+        aria-label={calculation.accessibleLabel}
+        data-testid={testId}
+      >
+        {calculation.parts.map((part) => part.kind === 'operator' ? (
+          <Text
+            aria-hidden="true"
+            className={styles.operator}
+            key={part.operator.id}
+            weight="semibold"
+          >
+            {part.operator.symbol}
+          </Text>
+        ) : (
+          <span
+            aria-hidden="true"
+            className={part.operand.result ? styles.resultOperand : styles.operand}
+            key={part.operand.id}
+          >
+            <Text className={styles.operandValue} weight="semibold">{part.operand.value}</Text>
+            <Text size={200}>{part.operand.label}</Text>
+            {part.operand.detail && (
+              <Text className={styles.operandDetail} size={100}>{part.operand.detail}</Text>
+            )}
+          </span>
+        ))}
+      </div>
+      {calculation.summary && (
+        <Text size={200} weight="semibold" className={styles.calculationContext}>
+          {calculation.summary}
+        </Text>
+      )}
+      {calculation.context && (
+        <Text size={200} className={styles.calculationContext}>{calculation.context}</Text>
+      )}
+    </section>
+  )
+}
+
+function EstimateSources({ estimate }: { estimate: ScenarioRunEstimate }) {
+  const styles = useScenarioRunEstimateStyles()
+  if (estimate.datasets.length === 0) {
+    return null
+  }
+  const { commonCaps, residualCapsByDatasetId } = normalizeDatasetCaps(estimate.datasets)
+
+  return (
+    <div className={styles.sources} role="group" aria-label="Objective sources">
+      {commonCaps.length > 0 && (
+        <Text size={200} weight="semibold" className={styles.muted}>
+          {commonCaps.map(formatDatasetCap).join(' · ')}
+        </Text>
+      )}
+      {estimate.datasets.map((dataset) => {
+        const residualCaps = residualCapsByDatasetId.get(dataset.id) ?? []
+        return (
+          <div
+            className={styles.source}
+            key={dataset.id}
+            role="group"
+            aria-label={`Objective source: ${dataset.name}`}
+          >
+            <Text size={200}>
+              {countLabel(dataset.selectedSeedGroupCount, 'objective', 'objectives')} from {dataset.name}
+              {dataset.logicalSeedGroupCount !== dataset.selectedSeedGroupCount
+                ? ` · ${formatCount(dataset.logicalSeedGroupCount)} available`
+                : ''}
+            </Text>
+            {dataset.selectionNote && (
+              <Text size={200} className={styles.muted}>{dataset.selectionNote}</Text>
+            )}
+            {residualCaps.length > 0 && (
+              <Text size={200} className={styles.muted}>
+                {residualCaps.map(formatDatasetCap).join(' · ')}
+              </Text>
+            )}
+          </div>
+        )
+      })}
+    </div>
+  )
+}
+
+export function ScenarioRunEstimateDetails({
+  state,
+  idPrefix = 'scenario-run-estimate',
+}: ScenarioRunEstimateDetailsProps) {
   const styles = useScenarioRunEstimateStyles()
 
   if (state.status === 'loading') {
     return (
       <div className={styles.details} aria-live="polite">
-        <Spinner size="tiny" label="Calculating run estimate..." />
+        <Spinner size="tiny" label="Calculating planned attacks..." />
+        <Text size={200} className={styles.muted}>{scopeLabel(state)}</Text>
       </div>
     )
   }
@@ -140,19 +611,46 @@ export function ScenarioRunEstimateDetails({ state }: ScenarioRunEstimateDetails
   if (state.status === 'unavailable') {
     return (
       <div className={styles.details} aria-live="polite">
-        <Text weight="semibold">{state.label}</Text>
+        <ScenarioRunEstimateSummary state={state} />
+        <Text>{state.label}</Text>
         {state.note && <Text size={200} className={styles.muted}>{state.note}</Text>}
       </div>
     )
   }
 
   const { estimate } = state
+  const hasAdaptiveDetails = estimate.adaptiveDetails !== null
   return (
     <div className={styles.details} aria-live="polite">
-      <Text className={styles.total} weight="semibold">
-        {formatPlannedAttackSummary(estimate)}
+      {hasAdaptiveDetails ? (
+        <>
+          <RunCalculationView
+            calculation={adaptivePlannedCalculation(estimate)}
+            heading="Planned attacks"
+            idPrefix={`${idPrefix}-planned`}
+            testId="run-calculation"
+          />
+          <RunCalculationView
+            calculation={adaptiveWorkCalculation(estimate)}
+            heading="Adaptive work"
+            idPrefix={`${idPrefix}-adaptive-work`}
+            testId="adaptive-work-calculation"
+          />
+        </>
+      ) : (
+        <RunCalculationView
+          calculation={ordinaryCalculation(estimate)}
+          heading="Run calculation"
+          idPrefix={idPrefix}
+          testId="run-calculation"
+        />
+      )}
+      <EstimateSources estimate={estimate} />
+      <Text size={200} className={styles.muted}>
+        {hasAdaptiveDetails
+          ? adaptiveWorkContext(estimate)
+          : `Retries are ${estimate.retriesIncluded ? 'included' : 'not included'}.`}
       </Text>
-      <code className={styles.formula}>{formatBackendFormula(estimate)}</code>
     </div>
   )
 }
diff --git a/frontend/src/components/Scenarios/scenarioAdaptiveCap.test.ts b/frontend/src/components/Scenarios/scenarioAdaptiveCap.test.ts
new file mode 100644
index 0000000000..1879453e53
--- /dev/null
+++ b/frontend/src/components/Scenarios/scenarioAdaptiveCap.test.ts
@@ -0,0 +1,42 @@
+import {
+  formatAdaptiveCapAccessibleRule,
+  formatAdaptiveCapFeedback,
+  formatAdaptiveCapMetadata,
+} from './scenarioAdaptiveCap'
+
+describe('scenarioAdaptiveCap', () => {
+  it.each([
+    [1, 1, '1 selected candidate · limit 3'],
+    [4, 4, '4 selected candidates · limit 3'],
+    [2, 1, '1 compatible candidate from 2 selected · limit 3'],
+    [4, 2, '2 compatible candidates from 4 selected · limit 3'],
+  ])(
+    'formats metadata for %i selected and %i compatible candidates',
+    (selectedCandidateCount, compatibleCandidateCount, expected) => {
+      expect(formatAdaptiveCapMetadata({
+        selectedCandidateCount,
+        compatibleCandidateCount,
+        limit: 3,
+        effectiveMaximum: 2,
+      })).toBe(expected)
+    },
+  )
+
+  it('formats feedback with the effective maximum', () => {
+    expect(formatAdaptiveCapFeedback({
+      selectedCandidateCount: 4,
+      compatibleCandidateCount: 2,
+      limit: 3,
+      effectiveMaximum: 2,
+    })).toBe('2 compatible candidates from 4 selected · limit 3 · effective maximum 2.')
+  })
+
+  it('formats the accessible minimum rule', () => {
+    expect(formatAdaptiveCapAccessibleRule({
+      selectedCandidateCount: 1,
+      compatibleCandidateCount: 1,
+      limit: 3,
+      effectiveMaximum: 1,
+    })).toBe('the smaller of 1 selected candidate and limit 3')
+  })
+})
diff --git a/frontend/src/components/Scenarios/scenarioAdaptiveCap.ts b/frontend/src/components/Scenarios/scenarioAdaptiveCap.ts
new file mode 100644
index 0000000000..6e7f4a3b26
--- /dev/null
+++ b/frontend/src/components/Scenarios/scenarioAdaptiveCap.ts
@@ -0,0 +1,33 @@
+interface AdaptiveCapProvenance {
+  selectedCandidateCount: number
+  compatibleCandidateCount: number
+  limit: number
+  effectiveMaximum: number
+}
+
+function candidateContext({
+  selectedCandidateCount,
+  compatibleCandidateCount,
+}: Pick<AdaptiveCapProvenance, 'selectedCandidateCount' | 'compatibleCandidateCount'>): string {
+  const compatibleLabel = compatibleCandidateCount === 1 ? 'compatible candidate' : 'compatible candidates'
+  const selectedLabel = selectedCandidateCount === 1 ? 'selected candidate' : 'selected candidates'
+  return compatibleCandidateCount < selectedCandidateCount
+    ? `${compatibleCandidateCount.toLocaleString()} ${compatibleLabel} from ${
+      selectedCandidateCount.toLocaleString()
+    } selected`
+    : `${selectedCandidateCount.toLocaleString()} ${selectedLabel}`
+}
+
+export function formatAdaptiveCapMetadata(provenance: AdaptiveCapProvenance): string {
+  return `${candidateContext(provenance)} · limit ${provenance.limit.toLocaleString()}`
+}
+
+export function formatAdaptiveCapFeedback(provenance: AdaptiveCapProvenance): string {
+  return `${formatAdaptiveCapMetadata(provenance)} · effective maximum ${
+    provenance.effectiveMaximum.toLocaleString()
+  }.`
+}
+
+export function formatAdaptiveCapAccessibleRule(provenance: AdaptiveCapProvenance): string {
+  return `the smaller of ${candidateContext(provenance)} and limit ${provenance.limit.toLocaleString()}`
+}
diff --git a/frontend/src/components/Scenarios/scenarioDatasetCaps.test.ts b/frontend/src/components/Scenarios/scenarioDatasetCaps.test.ts
new file mode 100644
index 0000000000..b3c0e2d9a9
--- /dev/null
+++ b/frontend/src/components/Scenarios/scenarioDatasetCaps.test.ts
@@ -0,0 +1,70 @@
+import type { ScenarioRunEstimateDataset, ScenarioRunEstimateDatasetCap } from '@/types'
+
+import { normalizeDatasetCaps } from './scenarioDatasetCaps'
+
+const SHARED_CAP: ScenarioRunEstimateDatasetCap = {
+  id: 'shared-cap',
+  label: 'combined cap',
+  count: 10,
+  configuredOn: 'compound',
+  datasetName: null,
+}
+
+function makeDataset(
+  name: string,
+  configuredCaps: ScenarioRunEstimateDatasetCap[],
+): ScenarioRunEstimateDataset {
+  return {
+    id: name,
+    name,
+    kind: 'dataset',
+    logicalSeedGroupCount: 20,
+    selectedSeedGroupCount: 5,
+    configuredCaps,
+    selectionNote: null,
+  }
+}
+
+describe('scenarioDatasetCaps', () => {
+  it('returns empty normalized collections without datasets', () => {
+    const normalized = normalizeDatasetCaps([])
+
+    expect(normalized.commonCaps).toEqual([])
+    expect(normalized.residualCapsByDatasetId.size).toBe(0)
+  })
+
+  it('lifts compound caps and preserves single-dataset row caps', () => {
+    const rowCap: ScenarioRunEstimateDatasetCap = {
+      ...SHARED_CAP,
+      id: 'row-cap',
+      configuredOn: 'dataset',
+      datasetName: 'alpha',
+    }
+    const dataset = makeDataset('alpha', [SHARED_CAP, rowCap])
+    const normalized = normalizeDatasetCaps([dataset])
+
+    expect(normalized.commonCaps).toEqual([SHARED_CAP])
+    expect(normalized.residualCapsByDatasetId.get('alpha')).toEqual([rowCap])
+  })
+
+  it('preserves cap multiplicity while separating universal and residual row caps', () => {
+    const rowCap: ScenarioRunEstimateDatasetCap = {
+      id: 'row-cap',
+      label: 'per-dataset cap',
+      count: 5,
+      configuredOn: 'dataset',
+      datasetName: null,
+    }
+    const datasets = [
+      makeDataset('alpha', [SHARED_CAP, rowCap, { ...rowCap, id: 'row-cap-duplicate' }]),
+      makeDataset('beta', [{ ...SHARED_CAP, id: 'shared-cap-beta' }, rowCap]),
+    ]
+    const normalized = normalizeDatasetCaps(datasets)
+
+    expect(normalized.commonCaps).toEqual([SHARED_CAP, rowCap])
+    expect(normalized.residualCapsByDatasetId.get('alpha')).toEqual([
+      { ...rowCap, id: 'row-cap-duplicate' },
+    ])
+    expect(normalized.residualCapsByDatasetId.get('beta')).toEqual([])
+  })
+})
diff --git a/frontend/src/components/Scenarios/scenarioDatasetCaps.ts b/frontend/src/components/Scenarios/scenarioDatasetCaps.ts
new file mode 100644
index 0000000000..9c1b86c6f1
--- /dev/null
+++ b/frontend/src/components/Scenarios/scenarioDatasetCaps.ts
@@ -0,0 +1,87 @@
+import type {
+  ScenarioRunEstimateDataset,
+  ScenarioRunEstimateDatasetCap,
+} from '@/types'
+
+interface NormalizedDatasetCaps {
+  readonly commonCaps: ScenarioRunEstimateDatasetCap[]
+  readonly residualCapsByDatasetId: ReadonlyMap<string, ScenarioRunEstimateDatasetCap[]>
+}
+
+function semanticCapKey(cap: ScenarioRunEstimateDatasetCap): string {
+  return JSON.stringify([cap.label, cap.count, cap.configuredOn])
+}
+
+function capOccurrences(caps: ScenarioRunEstimateDatasetCap[]): Map<string, number> {
+  const occurrences = new Map<string, number>()
+  for (const cap of caps) {
+    const key = semanticCapKey(cap)
+    occurrences.set(key, (occurrences.get(key) ?? 0) + 1)
+  }
+  return occurrences
+}
+
+export function normalizeDatasetCaps(datasets: ScenarioRunEstimateDataset[]): NormalizedDatasetCaps {
+  const commonCaps: ScenarioRunEstimateDatasetCap[] = []
+  const seenListLevelCaps = new Set<string>()
+
+  for (const dataset of datasets) {
+    for (const cap of dataset.configuredCaps) {
+      if (cap.configuredOn !== 'compound') {
+        continue
+      }
+      const key = semanticCapKey(cap)
+      if (!seenListLevelCaps.has(key)) {
+        seenListLevelCaps.add(key)
+        commonCaps.push(cap)
+      }
+    }
+  }
+
+  const universalRowCapOccurrences = datasets.length > 1
+    ? capOccurrences(datasets[0].configuredCaps.filter((cap) => cap.configuredOn !== 'compound'))
+    : new Map<string, number>()
+  for (const dataset of datasets.slice(1)) {
+    const datasetOccurrences = capOccurrences(
+      dataset.configuredCaps.filter((cap) => cap.configuredOn !== 'compound'),
+    )
+    for (const [key, count] of universalRowCapOccurrences) {
+      universalRowCapOccurrences.set(key, Math.min(count, datasetOccurrences.get(key) ?? 0))
+    }
+  }
+
+  const emittedRowCapOccurrences = new Map<string, number>()
+  if (datasets.length > 0) {
+    for (const cap of datasets[0].configuredCaps) {
+      if (cap.configuredOn === 'compound') {
+        continue
+      }
+      const key = semanticCapKey(cap)
+      const emitted = emittedRowCapOccurrences.get(key) ?? 0
+      if (emitted < (universalRowCapOccurrences.get(key) ?? 0)) {
+        commonCaps.push(cap)
+        emittedRowCapOccurrences.set(key, emitted + 1)
+      }
+    }
+  }
+
+  const residualCapsByDatasetId = new Map<string, ScenarioRunEstimateDatasetCap[]>()
+  for (const dataset of datasets) {
+    const consumedRowCapOccurrences = new Map<string, number>()
+    const residualCaps = dataset.configuredCaps.filter((cap) => {
+      if (cap.configuredOn === 'compound') {
+        return false
+      }
+      const key = semanticCapKey(cap)
+      const consumed = consumedRowCapOccurrences.get(key) ?? 0
+      if (consumed < (universalRowCapOccurrences.get(key) ?? 0)) {
+        consumedRowCapOccurrences.set(key, consumed + 1)
+        return false
+      }
+      return true
+    })
+    residualCapsByDatasetId.set(dataset.id, residualCaps)
+  }
+
+  return { commonCaps, residualCapsByDatasetId }
+}
diff --git a/frontend/src/components/Scenarios/scenarioRunEstimateAdapter.ts b/frontend/src/components/Scenarios/scenarioRunEstimateAdapter.ts
index 4fd7cbcb14..63f3bed303 100644
--- a/frontend/src/components/Scenarios/scenarioRunEstimateAdapter.ts
+++ b/frontend/src/components/Scenarios/scenarioRunEstimateAdapter.ts
@@ -1,7 +1,10 @@
 import type {
+  ScenarioDefaultRunSizeEstimate,
   ScenarioRunEstimate,
+  ScenarioRunEstimateAdaptiveDetails,
   ScenarioRunEstimateDataset,
   ScenarioRunEstimateDatasetCap,
+  ScenarioRunEstimateFactor,
   ScenarioRunEstimateResult,
   ScenarioRunSizeEstimateResponse,
 } from '@/types'
@@ -14,7 +17,7 @@ function nextStableId(prefix: string, label: string, occurrences: Map<string, nu
 
 function mapDatasetCaps(
   datasetId: string,
-  caps: ScenarioRunSizeEstimateResponse['datasets'][number]['configured_caps'],
+  caps: ScenarioDefaultRunSizeEstimate['datasets'][number]['configured_caps'],
 ): ScenarioRunEstimateDatasetCap[] {
   const occurrences = new Map<string, number>()
   return caps.map((cap) => ({
@@ -27,7 +30,7 @@ function mapDatasetCaps(
 }
 
 function mapDatasets(
-  datasets: ScenarioRunSizeEstimateResponse['datasets'],
+  datasets: ScenarioDefaultRunSizeEstimate['datasets'],
 ): ScenarioRunEstimateDataset[] {
   const occurrences = new Map<string, number>()
   return datasets.map((dataset) => {
@@ -44,16 +47,47 @@ function mapDatasets(
   })
 }
 
+function mapFactors(
+  componentId: string,
+  factors: NonNullable<ScenarioDefaultRunSizeEstimate['components'][number]['factors']>,
+): ScenarioRunEstimateFactor[] {
+  const occurrences = new Map<string, number>()
+  return factors.map((factor) => ({
+    id: nextStableId(`${componentId}:factor`, factor.label, occurrences),
+    label: factor.label,
+    count: factor.count,
+  }))
+}
+
+function mapAdaptiveDetails(
+  details: NonNullable<ScenarioDefaultRunSizeEstimate['adaptive_details']>,
+): ScenarioRunEstimateAdaptiveDetails {
+  return {
+    objectiveCount: details.objective_count,
+    selectedCandidateTechniqueCount:
+      details.selected_candidate_technique_count ?? details.candidate_technique_count,
+    candidateTechniqueCount: details.candidate_technique_count,
+    maxAttemptsPerObjective: details.max_attempts_per_objective,
+    techniquesPerObjectiveUpperBound: details.techniques_per_objective_upper_bound,
+    techniqueAttemptCountUpperBound: details.technique_attempt_count_upper_bound,
+    stopOnFirstSuccess: details.stop_on_first_success,
+    compatibilityMayReduceAttempts: details.compatibility_may_reduce_attempts,
+  }
+}
+
 export function mapScenarioRunEstimate(
-  response: ScenarioRunSizeEstimateResponse,
+  response: ScenarioDefaultRunSizeEstimate | ScenarioRunSizeEstimateResponse,
   scope: ScenarioRunEstimate['scope'],
 ): ScenarioRunEstimateResult {
-  if (
-    response.estimated_attack_count === null
-    && response.minimum_attack_count == null
-    && response.maximum_attack_count == null
-    && response.components.length === 0
-  ) {
+  const isRichEstimate = 'status' in response
+  const total = isRichEstimate ? response.total_attack_count : response.estimated_attack_count
+  const unavailable = isRichEstimate
+    ? response.status === 'unavailable'
+    : total === null
+      && response.minimum_attack_count == null
+      && response.maximum_attack_count == null
+      && response.components.length === 0
+  if (unavailable) {
     return {
       status: 'unavailable',
       scope,
@@ -66,26 +100,34 @@ export function mapScenarioRunEstimate(
 
   const componentOccurrences = new Map<string, number>()
   const estimate: ScenarioRunEstimate = {
+    version: isRichEstimate ? response.version : 1,
     scope,
-    total: response.estimated_attack_count,
+    total,
     minimum: response.minimum_attack_count ?? null,
     maximum: response.maximum_attack_count ?? null,
+    condition: isRichEstimate ? response.condition : null,
     components: response.components.map((component) => {
       const id = nextStableId('component', component.label, componentOccurrences)
       return {
         id,
         label: component.label,
         count: component.count,
+        factors: mapFactors(id, component.factors ?? []),
         isBaseline: component.is_baseline,
+        condition: component.condition,
         note: component.note,
       }
     }),
     datasets: mapDatasets(response.datasets),
+    adaptiveDetails: isRichEstimate && response.adaptive_details
+      ? mapAdaptiveDetails(response.adaptive_details)
+      : null,
     effectiveParameters: response.effective_parameters ?? {},
     note: response.note,
+    retriesIncluded: isRichEstimate ? response.retries_included : false,
   }
 
-  return response.estimated_attack_count === null
+  return (isRichEstimate ? response.status === 'conditional' : total === null)
     ? { status: 'conditional', estimate }
     : { status: 'available', estimate }
 }
diff --git a/frontend/src/components/Scenarios/scenarioTechniqueSets.test.ts b/frontend/src/components/Scenarios/scenarioTechniqueSets.test.ts
new file mode 100644
index 0000000000..dd604b3fd0
--- /dev/null
+++ b/frontend/src/components/Scenarios/scenarioTechniqueSets.test.ts
@@ -0,0 +1,73 @@
+import type { RegisteredScenario } from '@/types'
+
+import {
+  techniqueSetDisplayName,
+  techniqueSetMembers,
+  techniqueSetName,
+  techniqueSetOptionLabel,
+} from './scenarioTechniqueSets'
+
+function makeScenario(overrides: Partial<RegisteredScenario> = {}): RegisteredScenario {
+  return {
+    scenario_name: 'test.scenario',
+    scenario_type: 'TestScenario',
+    scenario_version: 1,
+    description: 'Test scenario.',
+    description_markdown: 'Test scenario.',
+    default_technique: 'default',
+    default_techniques: ['crescendo'],
+    aggregate_techniques: ['default', 'quick_set'],
+    aggregate_technique_expansions: {
+      quick_set: ['crescendo', 'crescendo', 'pair'],
+    },
+    all_techniques: ['crescendo', 'pair'],
+    default_datasets: [],
+    dataset_size_limit: {
+      default_scope: 'none',
+      default_count: null,
+      override_scope: 'unsupported',
+    },
+    baseline_policy: 'forbidden',
+    include_baseline_by_default: false,
+    supported_parameters: [],
+    default_run_size: {
+      version: 1,
+      status: 'unavailable',
+      total_attack_count: null,
+      minimum_attack_count: null,
+      maximum_attack_count: null,
+      condition: null,
+      components: [],
+      datasets: [],
+      adaptive_details: null,
+      note: null,
+      retries_included: false,
+    },
+    ...overrides,
+  }
+}
+
+describe('scenarioTechniqueSets', () => {
+  it('formats known, custom, and empty technique-set names', () => {
+    expect(techniqueSetName('default')).toBe('Recommended')
+    expect(techniqueSetName('custom_red_team')).toBe('Custom red team')
+    expect(techniqueSetName('')).toBe('')
+  })
+
+  it('expands named sets, removes duplicates, and falls back to default members', () => {
+    const scenario = makeScenario()
+
+    expect(techniqueSetMembers(scenario, 'quick_set')).toEqual(['crescendo', 'pair'])
+    expect(techniqueSetMembers(scenario, 'default')).toEqual(['crescendo'])
+    expect(techniqueSetMembers(scenario, 'unknown_set')).toEqual([])
+  })
+
+  it('labels default and custom sets with singular and plural member counts', () => {
+    const scenario = makeScenario()
+
+    expect(techniqueSetDisplayName(scenario, 'default')).toBe('Recommended (default)')
+    expect(techniqueSetDisplayName(scenario, 'quick_set')).toBe('Quick set')
+    expect(techniqueSetOptionLabel(scenario, 'default')).toBe('Recommended (default) — 1 technique')
+    expect(techniqueSetOptionLabel(scenario, 'quick_set')).toBe('Quick set (2 techniques)')
+  })
+})
diff --git a/frontend/src/services/api.test.ts b/frontend/src/services/api.test.ts
index 9de3b57847..68690f5ba5 100644
--- a/frontend/src/services/api.test.ts
+++ b/frontend/src/services/api.test.ts
@@ -21,6 +21,7 @@ import {
   configurationApi,
   targetsApi,
   attacksApi,
+  datasetsApi,
   scenariosApi,
 } from "./api";
 
@@ -564,6 +565,22 @@ describe("api service", () => {
     });
   });
 
+  describe("datasetsApi", () => {
+    it("lists registered datasets", async () => {
+      const mockResponse = {
+        data: {
+          items: [{ name: "harmbench" }, { name: "xstest" }],
+        },
+      };
+      (apiClient.get as jest.Mock).mockResolvedValueOnce(mockResponse);
+
+      const result = await datasetsApi.listDatasets();
+
+      expect(apiClient.get).toHaveBeenCalledWith("/datasets");
+      expect(result).toEqual(mockResponse.data);
+    });
+  });
+
   describe("scenariosApi", () => {
     it("lists the scenario catalog with default params", async () => {
       const mockResponse = {
@@ -647,9 +664,15 @@ describe("api service", () => {
     it("posts the exact estimate request and forwards cancellation", async () => {
       const mockResponse = {
         data: {
-          estimated_attack_count: 8,
+          version: 1,
+          status: "exact",
+          total_attack_count: 8,
+          minimum_attack_count: null,
+          maximum_attack_count: null,
+          condition: null,
           components: [],
           datasets: [],
+          adaptive_details: null,
           note: null,
         },
       };
@@ -676,7 +699,56 @@ describe("api service", () => {
         request,
         { signal: controller.signal }
       );
-      expect(result.estimated_attack_count).toBe(8);
+      expect(result.total_attack_count).toBe(8);
+    });
+
+    it("preserves Adaptive conditional work metadata in the initial estimate response", async () => {
+      const mockResponse = {
+        data: {
+          version: 1,
+          status: "conditional",
+          total_attack_count: null,
+          minimum_attack_count: null,
+          maximum_attack_count: null,
+          condition: null,
+          components: [],
+          datasets: [],
+          adaptive_details: {
+            objective_count: 21,
+            selected_candidate_technique_count: 2,
+            candidate_technique_count: 2,
+            max_attempts_per_objective: 3,
+            techniques_per_objective_upper_bound: 2,
+            technique_attempt_count_upper_bound: 42,
+            stop_on_first_success: true,
+            compatibility_may_reduce_attempts: true,
+          },
+          note: null,
+          retries_included: false,
+        },
+      };
+      (apiClient.post as jest.Mock).mockResolvedValueOnce(mockResponse);
+      const controller = new AbortController();
+      const request = {
+        target_name: "target-a",
+        techniques: ["default"],
+        include_baseline: true,
+        scenario_params: { max_attempts_per_objective: 3 },
+      };
+
+      const result = await scenariosApi.estimateRun(
+        "adaptive.text_adaptive",
+        request,
+        controller.signal
+      );
+
+      expect(apiClient.post).toHaveBeenCalledWith(
+        "/scenarios/catalog/adaptive.text_adaptive/estimate",
+        request,
+        { signal: controller.signal }
+      );
+      expect(result.adaptive_details).toEqual(mockResponse.data.adaptive_details);
+      expect(result.total_attack_count).toBeNull();
     });
 
     it("posts the exact RunScenarioRequest payload to start a run", async () => {
diff --git a/frontend/src/services/api.ts b/frontend/src/services/api.ts
index 6cf66da4c6..5a3544f44f 100644
--- a/frontend/src/services/api.ts
+++ b/frontend/src/services/api.ts
@@ -30,10 +30,11 @@ import type {
   CreateConversationRequest,
   CreateConversationResponse,
   ChangeMainConversationResponse,
+  DatasetListResponse,
   ListRegisteredScenariosResponse,
   RegisteredScenario,
   RunScenarioRequest,
-  ScenarioRunSizeEstimateResponse,
+  ScenarioDefaultRunSizeEstimate,
   ScenarioRunSizeEstimateRequest,
   ScenarioRunSummary,
   ScenarioRunListResponse,
@@ -409,6 +410,13 @@ export const labelsApi = {
   },
 }
 
+export const datasetsApi = {
+  listDatasets: async (): Promise<DatasetListResponse> => {
+    const response = await apiClient.get('/datasets')
+    return response.data
+  },
+}
+
 export const scenariosApi = {
   /**
    * Lists one page of the scenario catalog. Callers that need the full
@@ -445,7 +453,7 @@ export const scenariosApi = {
     scenarioName: string,
     request: ScenarioRunSizeEstimateRequest,
     signal?: AbortSignal,
-  ): Promise<ScenarioRunSizeEstimateResponse> => {
+  ): Promise<ScenarioDefaultRunSizeEstimate> => {
     const response = await apiClient.post(
       `/scenarios/catalog/${encodeURIComponent(scenarioName)}/estimate`,
       request,
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index da3a6e668e..cf37efb790 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -484,6 +484,16 @@ export interface ChangeMainConversationResponse {
   conversation_id: string
 }
 
+// --- Datasets ---
+
+export interface DatasetInfo {
+  name: string
+}
+
+export interface DatasetListResponse {
+  items: DatasetInfo[]
+}
+
 // --- Scenarios ---
 
 export interface RegisteredScenario {
@@ -499,10 +509,11 @@ export interface RegisteredScenario {
   all_techniques: string[]
   technique_summaries: ScenarioTechniqueSummary[]
   default_datasets: string[]
+  dataset_size_limit: ScenarioDatasetSizeLimit
   baseline_policy: 'enabled' | 'disabled' | 'forbidden'
   include_baseline_by_default: boolean
   supported_parameters: Parameter[]
-  default_run_size: ScenarioRunSizeEstimateResponse
+  default_run_size: ScenarioDefaultRunSizeEstimate | ScenarioRunSizeEstimateResponse
 }
 
 export interface ScenarioTechniqueSummary {
@@ -533,13 +544,33 @@ export interface RunScenarioRequest {
   scenario_result_id?: string | null
 }
 
+export type ScenarioRunSizeEstimateStatus = 'exact' | 'conditional' | 'unavailable'
+
+export interface ScenarioRunSizeFactor {
+  label: string
+  count: number
+}
+
 export interface ScenarioRunSizeComponent {
   label: string
   count: number
+  factors?: ScenarioRunSizeFactor[]
   is_baseline: boolean
+  condition?: 'target_capabilities' | 'launch_configuration' | null
   note: string | null
 }
 
+export interface ScenarioAdaptiveRunSizeDetails {
+  objective_count: number
+  selected_candidate_technique_count?: number
+  candidate_technique_count: number
+  max_attempts_per_objective: number
+  techniques_per_objective_upper_bound: number
+  technique_attempt_count_upper_bound: number
+  stop_on_first_success: true
+  compatibility_may_reduce_attempts: true
+}
+
 export interface ScenarioDatasetSizeCap {
   label: string
   count: number
@@ -556,6 +587,12 @@ export interface ScenarioDatasetSummary {
   selection_note: string | null
 }
 
+export interface ScenarioDatasetSizeLimit {
+  default_scope: 'none' | 'per_dataset' | 'combined' | 'heterogeneous'
+  default_count: number | null
+  override_scope: 'per_dataset' | 'combined' | 'unsupported'
+}
+
 export interface ScenarioRunSizeEstimateResponse {
   estimated_attack_count: number | null
   minimum_attack_count?: number | null
@@ -566,6 +603,21 @@ export interface ScenarioRunSizeEstimateResponse {
   note: string | null
 }
 
+export interface ScenarioDefaultRunSizeEstimate {
+  version: 1
+  status: ScenarioRunSizeEstimateStatus
+  total_attack_count: number | null
+  minimum_attack_count?: number | null
+  maximum_attack_count?: number | null
+  condition?: 'target_capabilities' | 'launch_configuration' | null
+  components: ScenarioRunSizeComponent[]
+  datasets: ScenarioDatasetSummary[]
+  adaptive_details?: ScenarioAdaptiveRunSizeDetails | null
+  effective_parameters?: Record<string, boolean | number | string | string[]>
+  note: string | null
+  retries_included: false
+}
+
 export interface ScenarioRunSizeEstimateRequest {
   target_name?: string | null
   techniques?: string[] | null
@@ -580,10 +632,29 @@ export interface ScenarioRunEstimateComponent {
   id: string
   label: string
   count: number
+  factors: ScenarioRunEstimateFactor[]
   isBaseline: boolean
+  condition?: 'target_capabilities' | 'launch_configuration' | null
   note: string | null
 }
 
+export interface ScenarioRunEstimateFactor {
+  id: string
+  label: string
+  count: number
+}
+
+export interface ScenarioRunEstimateAdaptiveDetails {
+  objectiveCount: number
+  selectedCandidateTechniqueCount: number
+  candidateTechniqueCount: number
+  maxAttemptsPerObjective: number
+  techniquesPerObjectiveUpperBound: number
+  techniqueAttemptCountUpperBound: number
+  stopOnFirstSuccess: true
+  compatibilityMayReduceAttempts: true
+}
+
 export interface ScenarioRunEstimateDatasetCap {
   id: string
   label: string
@@ -603,14 +674,18 @@ export interface ScenarioRunEstimateDataset {
 }
 
 export interface ScenarioRunEstimate {
+  version: number
   scope: 'default' | 'request'
   total: number | null
   minimum?: number | null
   maximum?: number | null
+  condition?: 'target_capabilities' | 'launch_configuration' | null
   components: ScenarioRunEstimateComponent[]
   datasets: ScenarioRunEstimateDataset[]
+  adaptiveDetails?: ScenarioRunEstimateAdaptiveDetails | null
   effectiveParameters: Record<string, boolean | number | string | string[]>
   note: string | null
+  retriesIncluded: boolean
 }
 
 export type ScenarioRunEstimateResult =
@@ -651,7 +726,7 @@ export type ScenarioRunEstimator = (
   scenarioName: string,
   request: ScenarioRunSizeEstimateRequest,
   signal?: AbortSignal,
-) => Promise<ScenarioRunSizeEstimateResponse>
+) => Promise<ScenarioDefaultRunSizeEstimate>
 
 export interface AttackErrorSummary {
   atomic_attack_name: string
diff --git a/pyrit/analytics/technique_analysis.py b/pyrit/analytics/technique_analysis.py
index b892946113..a804a510ac 100644
--- a/pyrit/analytics/technique_analysis.py
+++ b/pyrit/analytics/technique_analysis.py
@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+from collections import Counter, defaultdict
 from typing import TYPE_CHECKING
 
 from pyrit.analytics.result_analysis import AttackStats, _compute_stats
@@ -12,11 +13,33 @@
 from pyrit.models import AttackOutcome
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Iterable, Mapping, Sequence
 
     from pyrit.memory.memory_interface import MemoryInterface
 
 
+def _compute_grouped_outcome_stats(grouped_outcomes: Iterable[tuple[str, AttackOutcome]]) -> dict[str, AttackStats]:
+    """
+    Aggregate keyed outcomes into attack statistics.
+
+    Returns:
+        dict[str, AttackStats]: Statistics keyed by the caller's grouping value.
+    """
+    counts: dict[str, Counter[AttackOutcome]] = defaultdict(Counter)
+    for key, outcome in grouped_outcomes:
+        counts[key][outcome] += 1
+
+    return {
+        key: _compute_stats(
+            successes=outcomes[AttackOutcome.SUCCESS],
+            failures=outcomes[AttackOutcome.FAILURE],
+            undetermined=outcomes[AttackOutcome.UNDETERMINED],
+            errors=outcomes[AttackOutcome.ERROR],
+        )
+        for key, outcomes in counts.items()
+    }
+
+
 def compute_technique_stats(
     *,
     technique_eval_hashes: Sequence[str],
@@ -61,24 +84,88 @@ def compute_technique_stats(
     )
 
     requested = set(technique_eval_hashes)
-    counts: dict[str, tuple[int, int, int, int]] = {}
+    grouped_outcomes: list[tuple[str, AttackOutcome]] = []
     for result in results:
         identifier = result.atomic_attack_identifier
         eval_hash = identifier.eval_hash if identifier is not None else None
         if eval_hash is None or eval_hash not in requested:
             continue
+        grouped_outcomes.append((eval_hash, result.outcome))
+
+    return _compute_grouped_outcome_stats(grouped_outcomes)
+
+
+def compute_labeled_technique_stats(
+    *,
+    technique_identifiers: Sequence[str],
+    label_name: str,
+    technique_eval_hashes_by_identifier: Mapping[str, str] | None = None,
+    scenario_result_id: str | None = None,
+    targeted_harm_categories: Sequence[str] | None = None,
+    memory: MemoryInterface | None = None,
+) -> dict[str, AttackStats]:
+    """
+    Compute per-technique statistics from identity labels and eval-hash history.
+
+    Args:
+        technique_identifiers (Sequence[str]): Stable technique identifiers to
+            aggregate. Returned dict is keyed by these identifiers.
+        label_name (str): Result-label key containing the technique identifier.
+        technique_eval_hashes_by_identifier (Mapping[str, str] | None):
+            Optional mapping from requested selector identifiers to the full
+            ``AttackTechnique`` eval hashes persisted by normal scenarios.
+            Matching labeled and eval-hash rows are merged by result ID so a
+            row visible through both paths is counted once.
+        scenario_result_id (str | None): Restrict to a single scenario run.
+            Defaults to ``None`` (aggregate across all runs).
+        targeted_harm_categories (Sequence[str] | None): Restrict to results
+            whose attack targeted these harm categories. Defaults to ``None``.
+        memory (MemoryInterface | None): Memory backend to query. Defaults to
+            ``CentralMemory.get_memory_instance()``.
 
-        s, f, u, e = counts.get(eval_hash, (0, 0, 0, 0))
-        if result.outcome == AttackOutcome.SUCCESS:
-            counts[eval_hash] = (s + 1, f, u, e)
-        elif result.outcome == AttackOutcome.FAILURE:
-            counts[eval_hash] = (s, f + 1, u, e)
-        elif result.outcome == AttackOutcome.ERROR:
-            counts[eval_hash] = (s, f, u, e + 1)
+    Returns:
+        dict[str, AttackStats]: Stats per requested technique identifier.
+            Identifiers with no historical results are omitted.
+    """
+    if not technique_identifiers:
+        return {}
+
+    if memory is None:
+        memory = CentralMemory.get_memory_instance()
+    labeled_results = memory.get_attack_results(
+        labels={label_name: list(technique_identifiers)},
+        scenario_result_id=scenario_result_id,
+        targeted_harm_categories=targeted_harm_categories,
+    )
+    eval_results = (
+        memory.get_attack_results(
+            atomic_attack_eval_hashes=sorted(set(technique_eval_hashes_by_identifier.values())),
+            scenario_result_id=scenario_result_id,
+            targeted_harm_categories=targeted_harm_categories,
+        )
+        if technique_eval_hashes_by_identifier
+        else []
+    )
+
+    requested = set(technique_identifiers)
+    identifiers_by_eval_hash: dict[str, list[str]] = {}
+    for technique_identifier, eval_hash in (technique_eval_hashes_by_identifier or {}).items():
+        if technique_identifier in requested:
+            identifiers_by_eval_hash.setdefault(eval_hash, []).append(technique_identifier)
+
+    unique_results = {result.attack_result_id: result for result in [*labeled_results, *eval_results]}
+    grouped_outcomes: list[tuple[str, AttackOutcome]] = []
+    for result in unique_results.values():
+        labeled_identifier = result.labels.get(label_name)
+        if labeled_identifier in requested:
+            matching_identifiers = [labeled_identifier]
         else:
-            counts[eval_hash] = (s, f, u + 1, e)
+            result_identifier = result.atomic_attack_identifier
+            result_eval_hash = result_identifier.eval_hash if result_identifier is not None else None
+            matching_identifiers = identifiers_by_eval_hash.get(result_eval_hash or "", [])
+        if not matching_identifiers:
+            continue
 
-    return {
-        eval_hash: _compute_stats(successes=s, failures=f, undetermined=u, errors=e)
-        for eval_hash, (s, f, u, e) in counts.items()
-    }
+        grouped_outcomes.extend((technique_identifier, result.outcome) for technique_identifier in matching_identifiers)
+
+    return _compute_grouped_outcome_stats(grouped_outcomes)
diff --git a/pyrit/backend/services/scenario_configuration_resolver.py b/pyrit/backend/services/scenario_configuration_resolver.py
index a0310bf595..4b967d1fa3 100644
--- a/pyrit/backend/services/scenario_configuration_resolver.py
+++ b/pyrit/backend/services/scenario_configuration_resolver.py
@@ -8,6 +8,7 @@
 from typing import TYPE_CHECKING, Any
 
 from pyrit.registry import ConverterRegistry, ScenarioRegistry, TargetRegistry
+from pyrit.scenario.core.dataset_configuration import CompoundDatasetAttackConfiguration
 
 if TYPE_CHECKING:
     from pyrit.converter import Converter
@@ -125,7 +126,30 @@ def resolve_configuration(
 
         if dataset_names or max_dataset_size is not None or filters:
             default_config = introspection_instance._default_dataset_config
-            if dataset_names:
+
+            if isinstance(default_config, CompoundDatasetAttackConfiguration):
+                names_changed = dataset_names is not None and dataset_names != default_config.dataset_names
+                if names_changed:
+                    try:
+                        resolved["dataset_config"] = default_config.with_dataset_names(
+                            dataset_names=dataset_names,
+                            max_dataset_size=max_dataset_size,
+                            filters=filters or None,
+                        )
+                    except TypeError as exc:
+                        raise ValueError(
+                            f"Scenario '{scenario_name}' does not support overriding datasets through "
+                            f"its {type(default_config).__name__} configuration: {exc}"
+                        ) from exc
+                else:
+                    if max_dataset_size is not None:
+                        default_config.update_child_max_dataset_size(max_dataset_size=max_dataset_size)
+                    if filters:
+                        default_config.update_filters(filters=filters)
+                    resolved["dataset_config"] = default_config
+            elif dataset_names:
+                # Construct a fresh instance of the scenario's own dataset-config
+                # class so subclass-specific behavior is preserved.
                 default_config_class = type(default_config)
                 try:
                     resolved["dataset_config"] = default_config_class(
@@ -139,6 +163,10 @@ def resolve_configuration(
                         f"its {default_config_class.__name__} configuration: {exc}"
                     ) from exc
             else:
+                # Reuse the scenario's default dataset config (preserves subtype +
+                # the scenario's own default dataset names) and override only the
+                # sample cap and/or filters. Safe because the introspection instance
+                # is throwaway.
                 if max_dataset_size is not None:
                     default_config.max_dataset_size = max_dataset_size
                 if filters:
diff --git a/pyrit/backend/services/scenario_service.py b/pyrit/backend/services/scenario_service.py
index 4d52bce35a..eb0b7f9e63 100644
--- a/pyrit/backend/services/scenario_service.py
+++ b/pyrit/backend/services/scenario_service.py
@@ -14,8 +14,9 @@
 from pyrit.backend.models.common import PaginationInfo
 from pyrit.backend.models.scenarios import ListRegisteredScenariosResponse
 from pyrit.backend.services.scenario_configuration_resolver import ScenarioConfigurationResolver
-from pyrit.models.catalog.scenario import (
+from pyrit.models.catalog import (
     RegisteredScenario,
+    ScenarioDefaultRunSizeEstimate,
     ScenarioRunSizeEstimate,
     ScenarioRunSizeEstimateRequest,
 )
@@ -23,7 +24,9 @@
 
 logger = logging.getLogger(__name__)
 _ESTIMATE_CACHE_SIZE = 128
-_ESTIMATE_CONCURRENCY = 1
+_ESTIMATE_CONCURRENCY = 4
+_CONFIGURED_ESTIMATE_CONCURRENCY = 4
+_DEFAULT_ESTIMATE_TIMEOUT_SECONDS = 3.0
 _ESTIMATE_INFLIGHT_SIZE = 256
 _UNAVAILABLE_CACHE_TTL_SECONDS = 30.0
 _EstimateCacheKey = tuple[str, int]
@@ -62,6 +65,7 @@ def _metadata_to_registered_scenario(
         all_techniques=list(metadata.all_techniques),
         technique_summaries=list(metadata.technique_summaries),
         default_datasets=list(metadata.default_datasets),
+        dataset_size_limit=metadata.dataset_size_limit,
         supported_parameters=list(metadata.supported_parameters),
         baseline_policy=metadata.baseline_policy,
         include_baseline_by_default=metadata.include_baseline_by_default,
@@ -79,6 +83,7 @@ def __init__(self) -> None:
         self._estimate_tasks: OrderedDict[_EstimateCacheKey, _EstimateTask] = OrderedDict()
         self._estimate_task_lock = asyncio.Lock()
         self._estimate_semaphore = asyncio.Semaphore(_ESTIMATE_CONCURRENCY)
+        self._configured_estimate_semaphore = asyncio.Semaphore(_CONFIGURED_ESTIMATE_CONCURRENCY)
 
     async def list_scenarios_async(
         self,
@@ -162,11 +167,7 @@ async def estimate_scenario_run_size_async(
         if metadata is None:
             return None
 
-        semaphore = getattr(self, "_estimate_semaphore", None)
-        if semaphore is None:
-            semaphore = asyncio.Semaphore(_ESTIMATE_CONCURRENCY)
-            self._estimate_semaphore = semaphore
-        async with semaphore:
+        async with self._configured_estimate_semaphore:
             return await self._estimate_configured_run_size_async(
                 scenario_name=scenario_name,
                 request=request,
@@ -175,30 +176,19 @@ async def estimate_scenario_run_size_async(
     async def _get_default_run_size_estimate_async(self, *, metadata: ScenarioMetadata) -> ScenarioRunSizeEstimate:
         """Return a cached, cancellation-safe scenario-owned estimate."""
         cache_key = (metadata.registry_name, metadata.scenario_version)
-        cache = getattr(self, "_estimate_cache", None)
-        if cache is None:
-            cache = OrderedDict()
-            self._estimate_cache = cache
         while True:
             cached = self._read_estimate_cache(cache_key=cache_key)
             if cached is not None:
                 return cached
 
-            task_lock = getattr(self, "_estimate_task_lock", None)
-            if task_lock is None:
-                task_lock = asyncio.Lock()
-                self._estimate_task_lock = task_lock
             wait_for_capacity: _EstimateTask | None = None
             task: _EstimateTask | None = None
-            async with task_lock:
+            async with self._estimate_task_lock:
                 cached = self._read_estimate_cache(cache_key=cache_key)
                 if cached is not None:
                     return cached
 
-                tasks = getattr(self, "_estimate_tasks", None)
-                if tasks is None:
-                    tasks = OrderedDict()
-                    self._estimate_tasks = tasks
+                tasks = self._estimate_tasks
                 for completed_key in [key for key, candidate in tasks.items() if candidate.done()]:
                     del tasks[completed_key]
                 task = tasks.get(cache_key)
@@ -251,19 +241,26 @@ async def _compute_default_run_size_estimate_async(
         Returns:
             ScenarioRunSizeEstimate: Scenario-owned estimate.
         """
-        semaphore = getattr(self, "_estimate_semaphore", None)
-        if semaphore is None:
-            semaphore = asyncio.Semaphore(_ESTIMATE_CONCURRENCY)
-            self._estimate_semaphore = semaphore
-        async with semaphore:
-            try:
-                scenario = await asyncio.to_thread(self._registry.create_instance, scenario_name)
-                estimate = await scenario.get_default_run_size_estimate_async()
-            except Exception as exc:
-                logger.warning("Default-run estimate failed for scenario '%s': %s", scenario_name, exc)
-                estimate = ScenarioRunSizeEstimate.unavailable(
-                    note=f"The scenario could not resolve its default inputs for estimation ({type(exc).__name__})."
+        try:
+            async with self._estimate_semaphore:
+                estimate = await asyncio.wait_for(
+                    self._run_default_estimate_async(scenario_name=scenario_name),
+                    timeout=_DEFAULT_ESTIMATE_TIMEOUT_SECONDS,
                 )
+        except TimeoutError:
+            logger.warning(
+                "Default-run estimate timed out for scenario '%s' after %.1f seconds",
+                scenario_name,
+                _DEFAULT_ESTIMATE_TIMEOUT_SECONDS,
+            )
+            estimate = ScenarioDefaultRunSizeEstimate.unavailable(
+                note="The default estimate timed out; open the scenario to calculate the configured run size."
+            )
+        except Exception as exc:
+            logger.warning("Default-run estimate failed for scenario '%s': %s", scenario_name, exc)
+            estimate = ScenarioDefaultRunSizeEstimate.unavailable(
+                note=f"The scenario could not resolve its default inputs for estimation ({type(exc).__name__})."
+            )
 
         expires_at = monotonic() + _UNAVAILABLE_CACHE_TTL_SECONDS if estimate.estimated_attack_count is None else None
         cache = self._estimate_cache
@@ -273,6 +270,16 @@ async def _compute_default_run_size_estimate_async(
             cache.popitem(last=False)
         return estimate
 
+    async def _run_default_estimate_async(self, *, scenario_name: str) -> ScenarioDefaultRunSizeEstimate:
+        """
+        Run one default estimate.
+
+        Returns:
+            ScenarioDefaultRunSizeEstimate: The authoritative scenario estimate.
+        """
+        scenario = await asyncio.to_thread(self._registry.create_instance, scenario_name)
+        return await scenario.get_default_run_size_estimate_async()
+
     def _clear_estimate_task(self, *, task: _EstimateTask, cache_key: _EstimateCacheKey) -> None:
         """Remove a completed single-flight task without disturbing a replacement."""
         tasks = self._estimate_tasks
diff --git a/pyrit/models/__init__.py b/pyrit/models/__init__.py
index 5b8d2b8bdc..9d867dcdde 100644
--- a/pyrit/models/__init__.py
+++ b/pyrit/models/__init__.py
@@ -24,11 +24,14 @@
 if TYPE_CHECKING:
     from pyrit.models.additional_initializer import AdditionalInitializer
     from pyrit.models.catalog import (
+        ScenarioAdaptiveRunSizeDetails,
         ScenarioDatasetSizeCap,
+        ScenarioDatasetSizeLimit,
         ScenarioDatasetSummary,
         ScenarioRunListItem,
         ScenarioRunSizeComponent,
         ScenarioRunSizeEstimate,
+        ScenarioRunSizeEstimateCondition,
         ScenarioRunSizeEstimateRequest,
         ScenarioTechniqueSummary,
     )
@@ -252,11 +255,14 @@
     "ScorerEvaluationIdentifier": "pyrit.models.identifiers",
     "ScorerIdentifier": "pyrit.models.identifiers",
     "ScenarioIdentifier": "pyrit.models.identifiers",
+    "ScenarioAdaptiveRunSizeDetails": "pyrit.models.catalog",
     "ScenarioDatasetSizeCap": "pyrit.models.catalog",
+    "ScenarioDatasetSizeLimit": "pyrit.models.catalog",
     "ScenarioDatasetSummary": "pyrit.models.catalog",
     "ScenarioRunListItem": "pyrit.models.catalog",
     "ScenarioRunSizeComponent": "pyrit.models.catalog",
     "ScenarioRunSizeEstimate": "pyrit.models.catalog",
+    "ScenarioRunSizeEstimateCondition": "pyrit.models.catalog",
     "ScenarioRunSizeEstimateRequest": "pyrit.models.catalog",
     "ScenarioTechniqueSummary": "pyrit.models.catalog",
     "ScenarioResult": "pyrit.models.results.scenario_result",
diff --git a/pyrit/models/catalog/__init__.py b/pyrit/models/catalog/__init__.py
index 18b3f6b713..a6b4794e00 100644
--- a/pyrit/models/catalog/__init__.py
+++ b/pyrit/models/catalog/__init__.py
@@ -25,13 +25,21 @@
         AttackRetrySummary,
         RegisteredScenario,
         RunScenarioRequest,
+        ScenarioAdaptiveRunSizeDetails,
         ScenarioDatasetSizeCap,
+        ScenarioDatasetSizeLimit,
         ScenarioDatasetSummary,
+        ScenarioDefaultRunSizeEstimate,
+        ScenarioOverloadSummary,
         ScenarioRunListItem,
         ScenarioRunSizeComponent,
         ScenarioRunSizeEstimate,
+        ScenarioRunSizeEstimateCondition,
         ScenarioRunSizeEstimateRequest,
+        ScenarioRunSizeEstimateStatus,
+        ScenarioRunSizeFactor,
         ScenarioRunSummary,
+        ScenarioTargetSummary,
         ScenarioTechniqueSummary,
     )
     from pyrit.models.catalog.target import TargetInstance
@@ -42,14 +50,22 @@
     "RegisteredInitializer": "pyrit.models.catalog.initializer",
     "RegisteredScenario": "pyrit.models.catalog.scenario",
     "RunScenarioRequest": "pyrit.models.catalog.scenario",
+    "ScenarioAdaptiveRunSizeDetails": "pyrit.models.catalog.scenario",
     "ScenarioDatasetSizeCap": "pyrit.models.catalog.scenario",
+    "ScenarioDatasetSizeLimit": "pyrit.models.catalog.scenario",
     "ScenarioDatasetSummary": "pyrit.models.catalog.scenario",
+    "ScenarioDefaultRunSizeEstimate": "pyrit.models.catalog.scenario",
+    "ScenarioOverloadSummary": "pyrit.models.catalog.scenario",
     "ScenarioRunListItem": "pyrit.models.catalog.scenario",
     "ScenarioRunSizeComponent": "pyrit.models.catalog.scenario",
     "ScenarioRunSizeEstimate": "pyrit.models.catalog.scenario",
+    "ScenarioRunSizeEstimateCondition": "pyrit.models.catalog.scenario",
     "ScenarioRunSizeEstimateRequest": "pyrit.models.catalog.scenario",
+    "ScenarioRunSizeEstimateStatus": "pyrit.models.catalog.scenario",
+    "ScenarioRunSizeFactor": "pyrit.models.catalog.scenario",
     "ScenarioRunSummary": "pyrit.models.catalog.scenario",
     "ScenarioTechniqueSummary": "pyrit.models.catalog.scenario",
+    "ScenarioTargetSummary": "pyrit.models.catalog.scenario",
     "TargetInstance": "pyrit.models.catalog.target",
 }
 
diff --git a/pyrit/models/catalog/scenario.py b/pyrit/models/catalog/scenario.py
index d46af4068c..221e26f769 100644
--- a/pyrit/models/catalog/scenario.py
+++ b/pyrit/models/catalog/scenario.py
@@ -14,6 +14,8 @@
 """
 
 from datetime import datetime
+from enum import Enum
+from math import prod
 from typing import Any, Literal
 
 from pydantic import AliasChoices, BaseModel, Field, field_validator, model_validator
@@ -57,14 +59,116 @@ def _validate_dataset_filter_mapping(
     return value
 
 
+class ScenarioRunSizeEstimateStatus(str, Enum):
+    """Confidence level for a catalog default-run size estimate."""
+
+    Exact = "exact"
+    Conditional = "conditional"
+    Unavailable = "unavailable"
+
+
+class ScenarioRunSizeEstimateCondition(str, Enum):
+    """Reason an estimate remains conditional until launch."""
+
+    TargetCapabilities = "target_capabilities"
+    LaunchConfiguration = "launch_configuration"
+
+
+class ScenarioRunSizeFactor(BaseModel):
+    """One labeled multiplicative factor in a run-size component."""
+
+    label: str = Field(..., min_length=1)
+    count: int = Field(..., ge=0)
+
+
 class ScenarioRunSizeComponent(BaseModel):
     """One additive component of a default-run size estimate."""
 
     label: str = Field(..., min_length=1)
     count: int = Field(..., ge=0)
+    factors: list[ScenarioRunSizeFactor] = Field(default_factory=list)
     is_baseline: bool = False
+    condition: ScenarioRunSizeEstimateCondition | None = None
     note: str | None = None
 
+    @model_validator(mode="after")
+    def validate_factor_product(self) -> "ScenarioRunSizeComponent":
+        """
+        Require known component totals to equal their ordered factor product.
+
+        Returns:
+            ScenarioRunSizeComponent: The validated component.
+
+        Raises:
+            ValueError: If a component with factors has an inconsistent count.
+        """
+        if self.factors:
+            factor_product = prod(factor.count for factor in self.factors)
+            if self.count != factor_product:
+                raise ValueError(
+                    f"Component '{self.label}' count ({self.count}) must equal its factor product ({factor_product})"
+                )
+        return self
+
+
+class ScenarioAdaptiveRunSizeDetails(BaseModel):
+    """Structured work bounds for an adaptive scenario estimate."""
+
+    objective_count: int = Field(..., ge=0)
+    selected_candidate_technique_count: int = Field(..., ge=1)
+    candidate_technique_count: int = Field(..., ge=1)
+    max_attempts_per_objective: int = Field(..., ge=1)
+    techniques_per_objective_upper_bound: int = Field(..., ge=1)
+    technique_attempt_count_upper_bound: int = Field(..., ge=0)
+    stop_on_first_success: Literal[True] = True
+    compatibility_may_reduce_attempts: Literal[True] = True
+
+    @model_validator(mode="before")
+    @classmethod
+    def default_selected_candidate_count(cls, data: Any) -> Any:
+        """
+        Preserve version-1 payload compatibility when the selected count is absent.
+
+        Returns:
+            Any: Input data with the selected count defaulted to the compatible count.
+        """
+        if (
+            isinstance(data, dict)
+            and "selected_candidate_technique_count" not in data
+            and "candidate_technique_count" in data
+        ):
+            return {
+                **data,
+                "selected_candidate_technique_count": data["candidate_technique_count"],
+            }
+        return data
+
+    @model_validator(mode="after")
+    def validate_attempt_bounds(self) -> "ScenarioAdaptiveRunSizeDetails":
+        """
+        Ensure the serialized adaptive attempt bounds match the configured pool.
+
+        Returns:
+            ScenarioAdaptiveRunSizeDetails: The validated details.
+
+        Raises:
+            ValueError: If either derived upper bound is inconsistent.
+        """
+        if self.candidate_technique_count > self.selected_candidate_technique_count:
+            raise ValueError("candidate_technique_count cannot exceed selected_candidate_technique_count")
+        expected_per_objective = min(self.candidate_technique_count, self.max_attempts_per_objective)
+        if self.techniques_per_objective_upper_bound != expected_per_objective:
+            raise ValueError(
+                "techniques_per_objective_upper_bound must equal "
+                "min(candidate_technique_count, max_attempts_per_objective)"
+            )
+        expected_total = self.objective_count * expected_per_objective
+        if self.technique_attempt_count_upper_bound != expected_total:
+            raise ValueError(
+                "technique_attempt_count_upper_bound must equal objective_count * techniques_per_objective_upper_bound"
+            )
+        return self
+
 
 class ScenarioDatasetSizeCap(BaseModel):
     """One configured cap affecting a dataset or compound population."""
@@ -98,7 +202,31 @@ class ScenarioTechniqueSummary(BaseModel):
     tags: list[str] = Field(default_factory=list)
 
 
-class ScenarioRunSizeEstimate(BaseModel):
+class ScenarioDatasetSizeLimit(BaseModel):
+    """Structured default and override semantics for a scenario's dataset-size limit."""
+
+    default_scope: Literal["none", "per_dataset", "combined", "heterogeneous"] = "none"
+    default_count: int | None = Field(default=None, ge=1)
+    override_scope: Literal["per_dataset", "combined", "unsupported"] = "per_dataset"
+
+    @model_validator(mode="after")
+    def validate_default_count(self) -> "ScenarioDatasetSizeLimit":
+        """
+        Require a count exactly when the default has one representable scope.
+
+        Returns:
+            ScenarioDatasetSizeLimit: The validated limit metadata.
+
+        Raises:
+            ValueError: If the count does not match the declared default scope.
+        """
+        has_representable_default = self.default_scope in {"per_dataset", "combined"}
+        if has_representable_default != (self.default_count is not None):
+            raise ValueError("default_count must be set exactly for per_dataset or combined defaults")
+        return self
+
+
+class ScenarioDefaultRunSizeEstimate(BaseModel):
     """
     Structured estimate of default planned scenario execution units.
 
@@ -106,52 +234,129 @@ class ScenarioRunSizeEstimate(BaseModel):
     logical-seed-group pair. Retries and internal attack turns are excluded.
     """
 
-    estimated_attack_count: int | None = Field(default=None, ge=0)
+    version: Literal[1] = 1
+    status: ScenarioRunSizeEstimateStatus
+    total_attack_count: int | None = Field(
+        default=None,
+        ge=0,
+        validation_alias=AliasChoices("total_attack_count", "total", "estimated_attack_count"),
+    )
     minimum_attack_count: int | None = Field(default=None, ge=0)
     maximum_attack_count: int | None = Field(default=None, ge=0)
+    condition: ScenarioRunSizeEstimateCondition | None = None
     components: list[ScenarioRunSizeComponent] = Field(default_factory=list)
     datasets: list[ScenarioDatasetSummary] = Field(default_factory=list)
+    adaptive_details: ScenarioAdaptiveRunSizeDetails | None = None
     effective_parameters: dict[str, bool | int | float | str | list[str]] = Field(
         default_factory=dict,
         description="Scenario parameter values used by this estimate, including implicit runtime defaults.",
     )
-    note: str | None = None
+    note: str | None = Field(default=None, validation_alias=AliasChoices("note", "caveat"))
+    retries_included: Literal[False] = False
+
+    @property
+    def total(self) -> int | None:
+        """The legacy Python attribute for total_attack_count."""
+        return self.total_attack_count
+
+    @property
+    def estimated_attack_count(self) -> int | None:
+        """The legacy Python attribute for total_attack_count."""
+        return self.total_attack_count
+
+    @property
+    def caveat(self) -> str | None:
+        """The legacy Python attribute for note."""
+        return self.note
+
+    @model_validator(mode="before")
+    @classmethod
+    def normalize_legacy_estimate(cls, data: Any) -> Any:
+        """
+        Default an omitted status from the available total, then explain
+        component-less legacy exact totals in the canonical shape.
+
+        Callers that predate the ``status`` field (e.g. ``estimated_attack_count``-only
+        constructors) are treated as ``Exact`` when they supply a total and
+        ``Conditional`` otherwise.
+
+        Returns:
+            Any: The normalized input.
+        """
+        if not isinstance(data, dict):
+            return data
+        normalized = dict(data)
+        if "status" not in normalized:
+            has_total = any(
+                normalized.get(key) is not None for key in ("total_attack_count", "total", "estimated_attack_count")
+            )
+            normalized["status"] = (
+                ScenarioRunSizeEstimateStatus.Exact if has_total else ScenarioRunSizeEstimateStatus.Conditional
+            )
+        if "total" in normalized and "components" not in normalized:
+            status = normalized.get("status")
+            if status == ScenarioRunSizeEstimateStatus.Exact or status == "exact":
+                normalized["components"] = [
+                    {
+                        "label": "Legacy total",
+                        "count": normalized["total"],
+                        "note": "Normalized from a legacy component-less estimate.",
+                    }
+                ]
+        return normalized
 
     @model_validator(mode="after")
-    def validate_estimated_attack_count(self) -> "ScenarioRunSizeEstimate":
+    def validate_total(self) -> "ScenarioDefaultRunSizeEstimate":
         """
-        Ensure available estimates expose a complete additive total.
+        Ensure exact estimates expose and explain their complete total.
 
         Returns:
-            ScenarioRunSizeEstimate: The validated estimate.
+            ScenarioDefaultRunSizeEstimate: The validated estimate.
 
         Raises:
-            ValueError: If an available estimate misstates its total.
+            ValueError: If an exact estimate omits or misstates its total.
         """
         if (
             self.minimum_attack_count is not None
             and self.maximum_attack_count is not None
             and self.minimum_attack_count > self.maximum_attack_count
         ):
-            raise ValueError("Minimum attack count cannot exceed maximum attack count")
+            raise ValueError("minimum_attack_count must be less than or equal to maximum_attack_count")
 
-        if self.estimated_attack_count is not None:
-            component_total = sum(component.count for component in self.components)
-            if component_total != self.estimated_attack_count:
-                raise ValueError(
-                    f"Default-run estimate components total {component_total}, not {self.estimated_attack_count}"
-                )
+        if self.status is not ScenarioRunSizeEstimateStatus.Exact:
+            return self
+
+        if self.total_attack_count is None:
+            raise ValueError("Exact default-run estimates require total_attack_count")
+        for field_name, bound in (
+            ("minimum_attack_count", self.minimum_attack_count),
+            ("maximum_attack_count", self.maximum_attack_count),
+        ):
+            if bound is not None and bound != self.total_attack_count:
+                raise ValueError(f"Exact default-run estimates require {field_name} to equal total_attack_count")
+
+        component_total = sum(component.count for component in self.components)
+        if component_total != self.total_attack_count:
+            raise ValueError(
+                f"Exact default-run estimate components total {component_total}, not {self.total_attack_count}"
+            )
         return self
 
     @classmethod
-    def unavailable(cls, *, note: str = "Default-run size estimate is unavailable.") -> "ScenarioRunSizeEstimate":
+    def unavailable(
+        cls, *, note: str = "Default-run size estimate is unavailable."
+    ) -> "ScenarioDefaultRunSizeEstimate":
         """
         Build an unavailable estimate without presenting a guessed total.
 
         Returns:
-            ScenarioRunSizeEstimate: An unavailable estimate.
+            ScenarioDefaultRunSizeEstimate: An unavailable estimate.
         """
-        return cls(note=note)
+        return cls(status=ScenarioRunSizeEstimateStatus.Unavailable, note=note)
+
+
+# Backward-compatible catalog name from the initial run-size DTO.
+ScenarioRunSizeEstimate = ScenarioDefaultRunSizeEstimate
 
 
 class RegisteredScenario(BaseModel):
@@ -186,6 +391,10 @@ class RegisteredScenario(BaseModel):
         description="Descriptions and tags for the available concrete techniques",
     )
     default_datasets: list[str] = Field(..., description="Default dataset names used by the scenario")
+    dataset_size_limit: ScenarioDatasetSizeLimit = Field(
+        default_factory=ScenarioDatasetSizeLimit,
+        description="Structured scenario-default and explicit-override dataset-size limit semantics",
+    )
     baseline_policy: Literal["enabled", "disabled", "forbidden"] = Field(
         "enabled", description="Whether baseline execution is enabled, disabled, or forbidden"
     )
diff --git a/pyrit/registry/components/scenario_registry.py b/pyrit/registry/components/scenario_registry.py
index cbd84f5206..cca2a1c576 100644
--- a/pyrit/registry/components/scenario_registry.py
+++ b/pyrit/registry/components/scenario_registry.py
@@ -18,7 +18,12 @@
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Literal
 
-from pyrit.models import ScenarioRunSizeEstimate, ScenarioTechniqueSummary, class_name_to_snake_case
+from pyrit.models import (
+    ScenarioDatasetSizeLimit,
+    ScenarioRunSizeEstimate,
+    ScenarioTechniqueSummary,
+    class_name_to_snake_case,
+)
 from pyrit.models.identifiers.scenario_identifier import ScenarioIdentifier
 from pyrit.registry.registry import ParamBagRegistry
 from pyrit.registry.registry_metadata import RegistryMetadata
@@ -66,6 +71,9 @@ class ScenarioMetadata(RegistryMetadata):
     # Default dataset names used by this scenario.
     default_datasets: tuple[str, ...] = field(kw_only=True)
 
+    # Structured default and override semantics for the dataset-size control.
+    dataset_size_limit: ScenarioDatasetSizeLimit = field(kw_only=True, default_factory=ScenarioDatasetSizeLimit)
+
     # Scenario-declared custom parameters.
     supported_parameters: tuple[Parameter, ...] = field(kw_only=True, default=())
 
@@ -193,7 +201,12 @@ def _build_metadata(self, name: str, cls: type[Scenario]) -> ScenarioMetadata:
             )
             for aggregate in technique_class.get_aggregate_techniques()
         )
-        default_datasets = tuple(instance._default_dataset_config.dataset_names)
+        default_dataset_config = instance._default_dataset_config
+        default_datasets = tuple(default_dataset_config.dataset_names)
+        dataset_size_limit = self._build_dataset_size_limit(
+            default_dataset_config=default_dataset_config,
+            override_scope=instance.get_dataset_size_limit_override_scope(),
+        )
 
         return ScenarioMetadata(
             class_name=cls.__name__,
@@ -209,11 +222,46 @@ def _build_metadata(self, name: str, cls: type[Scenario]) -> ScenarioMetadata:
             aggregate_techniques=aggregate_techniques,
             aggregate_technique_expansions=aggregate_technique_expansions,
             default_datasets=default_datasets,
+            dataset_size_limit=dataset_size_limit,
             supported_parameters=supported_parameters,
             baseline_policy=instance.BASELINE_ATTACK_POLICY.value,
             include_baseline_by_default=instance.BASELINE_ATTACK_POLICY.value == "enabled",
         )
 
+    @staticmethod
+    def _build_dataset_size_limit(
+        *,
+        default_dataset_config: Any,
+        override_scope: Literal["per_dataset", "combined", "unsupported"],
+    ) -> ScenarioDatasetSizeLimit:
+        """
+        Normalize a scenario dataset configuration into form-level limit semantics.
+
+        Returns:
+            ScenarioDatasetSizeLimit: The structured default and override scopes.
+        """
+        dataset_names = tuple(default_dataset_config.dataset_names)
+        caps_by_dataset = default_dataset_config.size_caps_by_dataset()
+        configured_caps = [caps for caps in caps_by_dataset.values() if caps]
+        if not configured_caps:
+            return ScenarioDatasetSizeLimit(default_scope="none", override_scope=override_scope)
+
+        expected_source_count = max(1, len(set(dataset_names)))
+        if all(len(caps) == 1 for caps in configured_caps) and len(configured_caps) == expected_source_count:
+            cap_signatures = {(caps[0][1], caps[0][2]) for caps in configured_caps}
+            if len(cap_signatures) == 1:
+                count, configured_on = next(iter(cap_signatures))
+                default_scope: Literal["per_dataset", "combined"] = (
+                    "per_dataset" if configured_on == "dataset" else "combined"
+                )
+                return ScenarioDatasetSizeLimit(
+                    default_scope=default_scope,
+                    default_count=count,
+                    override_scope=override_scope,
+                )
+
+        return ScenarioDatasetSizeLimit(default_scope="heterogeneous", override_scope=override_scope)
+
     async def create_and_estimate_async(
         self,
         *,
diff --git a/pyrit/scenario/core/dataset_configuration.py b/pyrit/scenario/core/dataset_configuration.py
index 4f43d5fdc6..4e8261b001 100644
--- a/pyrit/scenario/core/dataset_configuration.py
+++ b/pyrit/scenario/core/dataset_configuration.py
@@ -338,9 +338,10 @@ def __init__(
         self._dataset_names = list(dataset_names) if dataset_names is not None else None
         self.max_dataset_size = max_dataset_size
         self._filters: dict[str, list[str]] = dict(filters or {})
+        self._custom_validators = list(validators) if validators else []
         self._validators: list[Callable[[ResolvedDataset], None]] = [
             *self._default_validators(),
-            *(list(validators) if validators else []),
+            *self._custom_validators,
         ]
         self._auto_fetch = auto_fetch
 
@@ -742,6 +743,28 @@ async def get_attack_groups_by_dataset_async(
             raise DatasetConstraintError(f"Resolved attack-group dataset is empty (datasets: {names}).")
         return result
 
+    async def resolve_attack_groups_for_estimate_async(
+        self,
+    ) -> tuple[dict[str, list[AttackSeedGroup]], dict[str, list[AttackSeedGroup]]]:
+        """
+        Resolve full and sampled attack groups with one dataset fetch.
+
+        Returns:
+            tuple: Full groups and effectively selected groups, both keyed by dataset.
+
+        Raises:
+            DatasetConstraintError: If the resolved or sampled attack-group population is empty.
+        """
+        groups_by_dataset, resolved = await self._build_groups_by_dataset_async()
+        self.validate(resolved)
+        selected = {
+            name: groups for name, groups in self._sample_groups_by_dataset(groups_by_dataset).items() if groups
+        }
+        if not groups_by_dataset or not selected:
+            names = ", ".join(self._dataset_names) if self._dataset_names else "<inline>"
+            raise DatasetConstraintError(f"Resolved attack-group dataset is empty (datasets: {names}).")
+        return groups_by_dataset, selected
+
     def _sample_groups_by_dataset(
         self, groups_by_dataset: dict[str, list[AttackSeedGroup]]
     ) -> dict[str, list[AttackSeedGroup]]:
@@ -849,6 +872,75 @@ def per_dataset(
             ]
         )
 
+    def with_dataset_names(
+        self,
+        *,
+        dataset_names: Sequence[str],
+        max_dataset_size: int | None = None,
+        filters: dict[str, list[str]] | None = None,
+    ) -> CompoundDatasetAttackConfiguration:
+        """
+        Rebuild a homogeneous per-dataset compound for an explicit name selection.
+
+        This preserves the scenario's per-dataset cap, auto-fetch policy, and shared
+        filters when every child is a plain single-dataset attack configuration.
+        Heterogeneous compounds must provide their own scenario-specific override
+        path rather than silently losing child shaping behavior.
+
+        Args:
+            dataset_names (Sequence[str]): Selected dataset names in request order.
+            max_dataset_size (int | None): Optional replacement per-dataset cap.
+            filters (dict[str, list[str]] | None): Filters merged over the shared defaults.
+
+        Returns:
+            CompoundDatasetAttackConfiguration: A fresh compound for the selected datasets.
+
+        Raises:
+            TypeError: If the compound has heterogeneous or shaped child configurations.
+            ValueError: If ``dataset_names`` is empty or contains duplicates.
+        """
+        if len(set(dataset_names)) != len(dataset_names):
+            raise ValueError("dataset-name overrides cannot contain duplicates")
+        if any(
+            type(child) is not DatasetAttackConfiguration or len(child.dataset_names) != 1
+            for child in self._configurations
+        ):
+            raise TypeError(
+                "dataset-name overrides require homogeneous single-dataset DatasetAttackConfiguration children"
+            )
+
+        child_caps = {child.max_dataset_size for child in self._configurations}
+        child_auto_fetch = {child._auto_fetch for child in self._configurations}
+        child_filters = {
+            tuple(sorted((key, tuple(values)) for key, values in child.filters.items()))
+            for child in self._configurations
+        }
+        template_child = self._configurations[0]
+        child_validators_match = all(
+            child._custom_validators == template_child._custom_validators for child in self._configurations[1:]
+        )
+        if len(child_caps) != 1 or len(child_auto_fetch) != 1 or len(child_filters) != 1 or not child_validators_match:
+            raise TypeError(
+                "dataset-name overrides require children with shared caps, filters, validators, and auto-fetch policy"
+            )
+
+        inherited_filters = {key: list(values) for key, values in next(iter(child_filters))}
+        inherited_filters.update(filters or {})
+        per_dataset_cap = max_dataset_size if max_dataset_size is not None else next(iter(child_caps))
+        rebuilt = type(self).per_dataset(
+            dataset_names=dataset_names,
+            max_dataset_size=per_dataset_cap,
+            auto_fetch=next(iter(child_auto_fetch)),
+            filters=inherited_filters or None,
+        )
+        for child in rebuilt._configurations:
+            child._custom_validators = list(template_child._custom_validators)
+            child._validators = list(template_child._validators)
+        rebuilt.max_dataset_size = self.max_dataset_size
+        rebuilt._custom_validators = list(self._custom_validators)
+        rebuilt._validators = list(self._validators)
+        return rebuilt
+
     @property
     def dataset_names(self) -> list[str]:
         """
@@ -911,6 +1003,21 @@ def update_filters(self, *, filters: dict[str, list[str]]) -> None:
         for child in self._configurations:
             child.update_filters(filters=filters)
 
+    def update_child_max_dataset_size(self, *, max_dataset_size: int) -> None:
+        """
+        Apply the same independent sampling cap to every child configuration.
+
+        Args:
+            max_dataset_size (int): Positive per-child logical-group cap.
+
+        Raises:
+            ValueError: If ``max_dataset_size`` is less than one.
+        """
+        if max_dataset_size < 1:
+            raise ValueError("'max_dataset_size' must be a positive integer (>= 1).")
+        for child in self._configurations:
+            child.max_dataset_size = max_dataset_size
+
     async def get_attack_seed_groups_async(self, *, apply_sampling: bool = True) -> list[AttackSeedGroup]:
         """
         Concatenate every child's flat result, then validate and apply the global cap.
@@ -961,6 +1068,27 @@ async def get_attack_groups_by_dataset_async(
         self.validate(self._resolved_from_groups([group for groups in merged.values() for group in groups]))
         return self._sample_groups_by_dataset(merged) if apply_sampling else merged
 
+    async def resolve_attack_groups_for_estimate_async(
+        self,
+    ) -> tuple[dict[str, list[AttackSeedGroup]], dict[str, list[AttackSeedGroup]]]:
+        """
+        Resolve every child's full and sampled populations with one fetch per child.
+
+        Returns:
+            tuple: Full groups and effectively selected groups, both keyed by dataset.
+        """
+        full_merged: dict[str, list[AttackSeedGroup]] = {}
+        selected_merged: dict[str, list[AttackSeedGroup]] = {}
+        for child in self._configurations:
+            full_groups, selected_groups = await child.resolve_attack_groups_for_estimate_async()
+            for name, groups in full_groups.items():
+                full_merged.setdefault(name, []).extend(groups)
+            for name, groups in selected_groups.items():
+                selected_merged.setdefault(name, []).extend(groups)
+        self.validate(self._resolved_from_groups([group for groups in full_merged.values() for group in groups]))
+        selected = {name: groups for name, groups in self._sample_groups_by_dataset(selected_merged).items() if groups}
+        return full_merged, selected
+
     def _resolved_from_groups(self, groups: list[AttackSeedGroup]) -> ResolvedDataset:
         """
         Build a ResolvedDataset over the combined groups for compound-level validation.
diff --git a/pyrit/scenario/core/scenario.py b/pyrit/scenario/core/scenario.py
index 5e36c15d46..70be3461fd 100644
--- a/pyrit/scenario/core/scenario.py
+++ b/pyrit/scenario/core/scenario.py
@@ -795,10 +795,13 @@ async def _resolve_dataset_groups_for_estimate_async(
         configured_dataset = self._dataset_config
         with read_only_dataset_resolution():
             self._dataset_config = configured_dataset
-            full_groups = await self._resolve_seed_groups_by_dataset_async(apply_sampling=False)
+            if type(self)._resolve_seed_groups_by_dataset_async is Scenario._resolve_seed_groups_by_dataset_async:
+                full_groups, selected_groups = await configured_dataset.resolve_attack_groups_for_estimate_async()
+            else:
+                full_groups = await self._resolve_seed_groups_by_dataset_async(apply_sampling=False)
+                self._dataset_config = configured_dataset
+                selected_groups = await self._resolve_seed_groups_by_dataset_async(apply_sampling=True)
             self._estimate_full_groups_by_dataset = full_groups
-            self._dataset_config = configured_dataset
-            selected_groups = await self._resolve_seed_groups_by_dataset_async(apply_sampling=True)
 
         configured_caps = self._dataset_config.size_caps_by_dataset()
         datasets: list[ScenarioDatasetSummary] = []
diff --git a/pyrit/scenario/scenarios/adaptive/__init__.py b/pyrit/scenario/scenarios/adaptive/__init__.py
index b71c7fb445..a74196af63 100644
--- a/pyrit/scenario/scenarios/adaptive/__init__.py
+++ b/pyrit/scenario/scenarios/adaptive/__init__.py
@@ -12,6 +12,8 @@
     from pyrit.scenario.scenarios.adaptive.adaptive_scenario import AdaptiveScenario
     from pyrit.scenario.scenarios.adaptive.dispatcher import (
         ADAPTIVE_ATTEMPT_LABEL,
+        ADAPTIVE_TECHNIQUE_ID_LABEL,
+        ADAPTIVE_TECHNIQUE_NAME_LABEL,
         AdaptiveTechniqueDispatcher,
         TechniqueBundle,
     )
@@ -20,11 +22,15 @@
         SelectorScope,
         TechniqueSelector,
     )
+    from pyrit.scenario.scenarios.adaptive.technique_identity import AdaptiveTechniqueIdentifier
     from pyrit.scenario.scenarios.adaptive.text_adaptive import TextAdaptive
 
 _LAZY_EXPORTS: dict[str, str | tuple[str, str | None]] = {
     "ADAPTIVE_ATTEMPT_LABEL": "pyrit.scenario.scenarios.adaptive.dispatcher",
+    "ADAPTIVE_TECHNIQUE_ID_LABEL": "pyrit.scenario.scenarios.adaptive.dispatcher",
+    "ADAPTIVE_TECHNIQUE_NAME_LABEL": "pyrit.scenario.scenarios.adaptive.dispatcher",
     "AdaptiveScenario": "pyrit.scenario.scenarios.adaptive.adaptive_scenario",
+    "AdaptiveTechniqueIdentifier": "pyrit.scenario.scenarios.adaptive.technique_identity",
     "AdaptiveTechniqueDispatcher": "pyrit.scenario.scenarios.adaptive.dispatcher",
     "EpsilonGreedyTechniqueSelector": "pyrit.scenario.scenarios.adaptive.selectors",
     "SelectorScope": "pyrit.scenario.scenarios.adaptive.selectors",
diff --git a/pyrit/scenario/scenarios/adaptive/adaptive_scenario.py b/pyrit/scenario/scenarios/adaptive/adaptive_scenario.py
index 16965aab65..c421f2974d 100644
--- a/pyrit/scenario/scenarios/adaptive/adaptive_scenario.py
+++ b/pyrit/scenario/scenarios/adaptive/adaptive_scenario.py
@@ -23,10 +23,16 @@
 from pyrit.common.utils import to_sha256
 from pyrit.executor.attack import AttackScoringConfig
 from pyrit.models import (
+    AtomicAttackEvaluationIdentifier,
+    AtomicAttackIdentifier,
+    ScenarioAdaptiveRunSizeDetails,
     ScenarioRunSizeComponent,
-    ScenarioRunSizeEstimate,
 )
-from pyrit.models.identifiers import compute_inner_attack_eval_hash
+from pyrit.models.catalog import (
+    ScenarioDefaultRunSizeEstimate,
+    ScenarioRunSizeEstimateStatus,
+    ScenarioRunSizeFactor,
+)
 from pyrit.scenario.core.atomic_attack import AtomicAttack
 from pyrit.scenario.core.attack_technique import AttackTechnique
 from pyrit.scenario.core.matrix_atomic_attack_builder import build_baseline_atomic_attack
@@ -34,6 +40,7 @@
 from pyrit.scenario.core.scenario_target_defaults import get_default_adversarial_target
 from pyrit.scenario.scenarios.adaptive.dispatcher import AdaptiveTechniqueDispatcher, TechniqueBundle
 from pyrit.scenario.scenarios.adaptive.selectors import EpsilonGreedyTechniqueSelector, TechniqueSelector
+from pyrit.scenario.scenarios.adaptive.technique_identity import AdaptiveTechniqueIdentifier
 
 if TYPE_CHECKING:
     from pyrit.models import AttackSeedGroup
@@ -201,21 +208,30 @@ async def _build_atomic_attacks_async(self, *, context: ScenarioContext) -> list
 
         return atomic_attacks
 
-    async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
+    async def _estimate_run_size_async(self) -> ScenarioDefaultRunSizeEstimate:
         """
         Estimate compatible persisted envelopes, excluding adaptive inner attempts.
 
         Returns:
-            ScenarioRunSizeEstimate: The adaptive outer-envelope estimate.
+            ScenarioDefaultRunSizeEstimate: The adaptive outer-envelope estimate.
+
+        Raises:
+            ValueError: If ``max_attempts_per_objective`` is less than one.
         """
         selected_groups, datasets = await self._resolve_dataset_groups_for_estimate_async()
         selected_count = sum(len(groups) for groups in selected_groups.values())
         max_attempts = int(self.params.get("max_attempts_per_objective", 3))
+        if max_attempts < 1:
+            raise ValueError(f"max_attempts_per_objective must be >= 1, got {max_attempts}")
+        selected_candidate_count = len(self._scenario_techniques)
+        selected_attempt_bound = min(selected_candidate_count, max_attempts)
+        baseline_count = selected_count if self._include_baseline else 0
         baseline_components = (
             [
                 ScenarioRunSizeComponent(
                     label="Baseline",
                     count=selected_count,
+                    factors=[ScenarioRunSizeFactor(label="objectives", count=selected_count)],
                     is_baseline=True,
                 )
             ]
@@ -226,24 +242,35 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
             components = [
                 *baseline_components,
                 ScenarioRunSizeComponent(
-                    label="Adaptive attack-envelope candidates",
+                    label="Adaptive objectives",
                     count=selected_count,
+                    factors=[ScenarioRunSizeFactor(label="objectives", count=selected_count)],
                 ),
             ]
-            return ScenarioRunSizeEstimate(
-                minimum_attack_count=sum(component.count for component in baseline_components),
-                maximum_attack_count=sum(component.count for component in components),
+            return ScenarioDefaultRunSizeEstimate(
+                status=ScenarioRunSizeEstimateStatus.Conditional,
+                minimum_attack_count=baseline_count,
+                maximum_attack_count=baseline_count + selected_count,
                 components=components,
                 datasets=datasets,
+                adaptive_details=ScenarioAdaptiveRunSizeDetails(
+                    objective_count=selected_count,
+                    selected_candidate_technique_count=selected_candidate_count,
+                    candidate_technique_count=selected_candidate_count,
+                    max_attempts_per_objective=max_attempts,
+                    techniques_per_objective_upper_bound=selected_attempt_bound,
+                    technique_attempt_count_upper_bound=selected_count * selected_attempt_bound,
+                ),
                 note=(
-                    "The authoritative total depends on which selected techniques are compatible with the "
-                    f"configured objective target and each seed group. Up to {max_attempts} inner attempts per "
-                    "envelope and retries are excluded."
+                    "The planned-attack total depends on which selected techniques are compatible with the "
+                    f"configured objective target. Up to {selected_attempt_bound} selected technique attempts "
+                    "may run per adaptive objective; retries are excluded."
                 ),
             )
 
         assert self._objective_target is not None
         techniques = self._build_techniques_dict(objective_target=self._objective_target)
+        candidate_count = len(techniques)
         dispatcher = AdaptiveTechniqueDispatcher(
             objective_target=self._objective_target,
             techniques=techniques,
@@ -261,34 +288,52 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
         components = [
             *baseline_components,
             ScenarioRunSizeComponent(
-                label="Adaptive attack envelopes",
+                label="Adaptive objectives",
                 count=compatible_group_count,
+                factors=[ScenarioRunSizeFactor(label="compatible objectives", count=compatible_group_count)],
             ),
         ]
-        estimated_attack_count = (
-            None if self._estimate_has_binding_size_cap else sum(component.count for component in components)
+        status = (
+            ScenarioRunSizeEstimateStatus.Conditional
+            if self._estimate_has_binding_size_cap
+            else ScenarioRunSizeEstimateStatus.Exact
+        )
+        adaptive_objective_bound = (
+            selected_count if status is ScenarioRunSizeEstimateStatus.Conditional else compatible_group_count
         )
-        minimum_attack_count = None
-        maximum_attack_count = None
+        total_attack_count = (
+            None
+            if status is ScenarioRunSizeEstimateStatus.Conditional
+            else sum(component.count for component in components)
+        )
+        minimum_attack_count = (
+            baseline_count if status is ScenarioRunSizeEstimateStatus.Conditional and baseline_count > 0 else None
+        )
+        maximum_attack_count = (
+            baseline_count + selected_count if status is ScenarioRunSizeEstimateStatus.Conditional else None
+        )
+        technique_attempt_bound = min(candidate_count, max_attempts)
         note = (
-            f"Each planned unit is one persisted adaptive envelope. Up to {max_attempts} selected technique "
-            "attempts may run inside that unit; inner attempts and retries are excluded."
+            f"Each compatible adaptive objective is one planned attack. Up to {technique_attempt_bound} selected "
+            "technique attempts may run for that objective; retries are excluded."
         )
-        if estimated_attack_count is None:
-            baseline_count = sum(component.count for component in baseline_components)
-            minimum_attack_count = baseline_count
-            maximum_attack_count = baseline_count + selected_count
-            note += (
-                " A binding randomized dataset cap may select a different compatibility mix at launch. "
-                "The range covers the baseline-only minimum through one compatible adaptive envelope per "
-                "selected seed group."
-            )
-        return ScenarioRunSizeEstimate(
-            estimated_attack_count=estimated_attack_count,
+        if status is ScenarioRunSizeEstimateStatus.Conditional:
+            note += " A binding randomized dataset cap may select a different compatibility mix at launch."
+        return ScenarioDefaultRunSizeEstimate(
+            status=status,
+            total_attack_count=total_attack_count,
             minimum_attack_count=minimum_attack_count,
             maximum_attack_count=maximum_attack_count,
             components=components,
             datasets=datasets,
+            adaptive_details=ScenarioAdaptiveRunSizeDetails(
+                objective_count=adaptive_objective_bound,
+                selected_candidate_technique_count=selected_candidate_count,
+                candidate_technique_count=candidate_count,
+                max_attempts_per_objective=max_attempts,
+                techniques_per_objective_upper_bound=technique_attempt_bound,
+                technique_attempt_count_upper_bound=adaptive_objective_bound * technique_attempt_bound,
+            ),
             note=note,
         )
 
@@ -298,19 +343,17 @@ def _build_techniques_dict(
         objective_target: PromptTarget,
     ) -> dict[str, TechniqueBundle]:
         """
-        Resolve selected techniques into a ``{eval_hash: TechniqueBundle}`` map.
+        Resolve selected techniques into a ``{adaptive_id: TechniqueBundle}`` map.
 
         Each bundle carries the inner attack technique along with the factory's
         ``seed_technique`` and ``adversarial_chat`` so the dispatcher can
         reproduce the static ``AtomicAttack`` execution path per attempt.
 
-        Technique keys are eval hashes derived from the inner attack technique's
-        identifier (run through ``AtomicAttackEvaluationIdentifier`` so seeds,
-        scorers, and operational target params are excluded). The same hash is
-        auto-stamped on every persisted ``AttackResultEntry.atomic_attack_identifier``
-        by the executor, which lets the selector aggregate historical success
-        rates by behavioral configuration via
-        ``MemoryInterface.get_attack_results(atomic_attack_eval_hashes=...)``.
+        Technique keys join the canonical factory identifier hash with the full
+        ``AttackTechnique`` eval hash. Factory identity keeps distinct registered
+        configurations as separate arms even when they share an inner attack;
+        technique eval identity links those arms to normal-scenario history.
+        The dispatcher persists this joined identity on each child result.
 
         For factories whose attack class narrows ``attack_scoring_config`` to a
         specific subtype (e.g. ``TAPAttackScoringConfig`` for TAP), this method
@@ -320,7 +363,7 @@ def _build_techniques_dict(
         are dropped with a warning so the rest of the pool continues to run.
 
         Returns:
-            dict[str, TechniqueBundle]: Mapping from technique eval hash to its
+            dict[str, TechniqueBundle]: Mapping from joined Adaptive identity to its
                 bundle, in the order selected techniques were resolved.
 
         Raises:
@@ -356,11 +399,17 @@ def _build_techniques_dict(
                 skipped_incompatible[technique_name] = str(exc)
                 logger.warning(f"Skipping technique '{technique_name}': {type(exc).__name__}: {exc}")
                 continue
-            eval_hash = compute_inner_attack_eval_hash(attack=technique.attack)
+            technique_eval_hash = AtomicAttackEvaluationIdentifier(
+                AtomicAttackIdentifier.build(technique_identifier=technique.get_identifier())
+            ).eval_hash
+            technique_identifier = AdaptiveTechniqueIdentifier(
+                factory_hash=factory.get_identifier().hash,
+                technique_eval_hash=technique_eval_hash,
+            ).serialize()
             adversarial_chat = factory.adversarial_chat
             if adversarial_chat is None and factory.uses_adversarial:
                 adversarial_chat = get_default_adversarial_target()
-            techniques[eval_hash] = TechniqueBundle(
+            techniques[technique_identifier] = TechniqueBundle(
                 attack=technique.attack,
                 name=technique_name,
                 seed_technique=technique.seed_technique,
diff --git a/pyrit/scenario/scenarios/adaptive/dispatcher.py b/pyrit/scenario/scenarios/adaptive/dispatcher.py
index ba4bc31f18..bafe0509b0 100644
--- a/pyrit/scenario/scenarios/adaptive/dispatcher.py
+++ b/pyrit/scenario/scenarios/adaptive/dispatcher.py
@@ -12,15 +12,10 @@
 hands them to the scenario base for execution.
 
 The returned attack is a plain ``SequentialAttack`` with
-``SequenceCompletionPolicy.FIRST_SUCCESS``. The per-attempt dispatch trail
-(which technique ran, with what outcome, in what order) is not stamped onto
-the envelope — every child ``AttackResult`` in
-``SequentialAttackResult.child_attack_results`` already carries its own
-``outcome`` and its own ``atomic_attack_identifier.eval_hash``. Callers that
-want a human-readable technique label per child read it directly from the
-child via ``child.get_attack_strategy_identifier().unique_name`` (the
-executor auto-stamps ``class_name`` and ``unique_name`` on every persisted
-row), so there is no separate ``{eval_hash: name}`` map to consult.
+``SequenceCompletionPolicy.FIRST_SUCCESS``. Each child result carries the
+stable registered-factory identity and friendly technique name in labels so
+different configured techniques remain attributable even when their inner
+attack implementations are execution-equivalent.
 """
 
 from __future__ import annotations
@@ -50,6 +45,12 @@
 ADAPTIVE_ATTEMPT_LABEL: str = "_adaptive_attempt"
 """1-based attempt index within the per-objective loop."""
 
+ADAPTIVE_TECHNIQUE_ID_LABEL: str = "_adaptive_technique_id"
+"""Joined registered-factory and behavioral-history identity for the selected arm."""
+
+ADAPTIVE_TECHNIQUE_NAME_LABEL: str = "_adaptive_technique_name"
+"""Registered technique name for human-readable result attribution."""
+
 
 @dataclass(frozen=True)
 class TechniqueBundle:
@@ -58,16 +59,8 @@ class TechniqueBundle:
 
     Carries the inner attack strategy alongside the factory-supplied
     ``seed_technique`` (if any) and ``adversarial_chat`` (required when the
-    seed_technique contains a simulated-conversation config). ``name`` is the
-    factory-registration key; the dispatcher does not consume it, but it is
-    convenient for diagnostics and is preserved here so callers/tests can
-    cross-check which factory each bundle came from.
-
-    Notebook/report code that wants a human-readable label for a persisted
-    child ``AttackResult`` should read it from the child itself via
-    ``child.get_attack_strategy_identifier()`` — the executor already stamps
-    ``class_name`` and ``unique_name`` on every row, so there is no need to
-    publish a separate ``{eval_hash: name}`` map.
+    seed technique contains a simulated-conversation config). ``name`` is the
+    factory-registration key and is persisted on every selected child result.
     """
 
     attack: AttackStrategy[Any, AttackResult]
@@ -110,7 +103,7 @@ def __init__(
         Args:
             objective_target (PromptTarget): The target inner attacks run against.
             techniques (dict[str, TechniqueBundle]): Mapping from
-                technique eval hash to its bundle. Must be non-empty.
+                joined Adaptive technique identity to its bundle. Must be non-empty.
             selector (TechniqueSelector): Stateless technique selector.
             objective_scorer (TrueFalseScorer | None): Scorer forwarded
                 to inner attacks that generate simulated conversations.
@@ -137,14 +130,14 @@ def __init__(
 
     def compatible_techniques(self, *, seed_group: AttackSeedGroup) -> list[str]:
         """
-        Return technique hashes whose ``seed_technique`` is compatible with ``seed_group``.
+        Return technique identifiers whose ``seed_technique`` is compatible with ``seed_group``.
 
         Techniques with no ``seed_technique`` are universally compatible.
         Used by ``AdaptiveScenario`` to drop seed groups with no usable
         techniques before building atomic attacks.
 
         Returns:
-            list[str]: Technique eval hashes in declaration order.
+            list[str]: Joined Adaptive technique identities in declaration order.
         """
         return [
             name
@@ -179,12 +172,8 @@ async def build_attack_async(
                 technique map.
 
         Returns:
-            SequentialAttack: The ready-to-run attack. Each child's
-                identity is captured by its own
-                ``atomic_attack_identifier.eval_hash`` after execution;
-                callers wanting the friendly technique name read it
-                directly from the child via
-                ``child.get_attack_strategy_identifier().unique_name``.
+            SequentialAttack: The ready-to-run attack. Each child carries its
+                canonical factory identity and registered name in result labels.
 
         Raises:
             ValueError: If ``seed_group.objective`` is not initialized,
@@ -202,7 +191,7 @@ async def build_attack_async(
                 f"(objective={seed_group.objective.value!r})."
             )
 
-        chosen_hashes = await self._selector.select_async(
+        chosen_identifiers = await self._selector.select_async(
             technique_identifiers=compatible,
             objective=seed_group.objective.value,
             num_top_techniques=self._max_attempts,
@@ -210,7 +199,7 @@ async def build_attack_async(
         )
 
         child_attacks: list[SequentialChildAttack] = []
-        for attempt_idx, chosen in enumerate(chosen_hashes):
+        for attempt_idx, chosen in enumerate(chosen_identifiers):
             bundle = self._techniques[chosen]
             execution_group = (
                 seed_group.with_technique(technique=bundle.seed_technique)
@@ -223,7 +212,11 @@ async def build_attack_async(
                     seed_group=execution_group,
                     adversarial_chat=bundle.adversarial_chat,
                     objective_scorer=self._objective_scorer,
-                    memory_labels={ADAPTIVE_ATTEMPT_LABEL: str(attempt_idx + 1)},
+                    memory_labels={
+                        ADAPTIVE_ATTEMPT_LABEL: str(attempt_idx + 1),
+                        ADAPTIVE_TECHNIQUE_ID_LABEL: chosen,
+                        ADAPTIVE_TECHNIQUE_NAME_LABEL: bundle.name,
+                    },
                 )
             )
 
diff --git a/pyrit/scenario/scenarios/adaptive/selectors/epsilon_greedy.py b/pyrit/scenario/scenarios/adaptive/selectors/epsilon_greedy.py
index a415182733..3fd2b000e9 100644
--- a/pyrit/scenario/scenarios/adaptive/selectors/epsilon_greedy.py
+++ b/pyrit/scenario/scenarios/adaptive/selectors/epsilon_greedy.py
@@ -11,8 +11,10 @@
 import struct
 from typing import TYPE_CHECKING
 
-from pyrit.analytics.technique_analysis import compute_technique_stats
+from pyrit.analytics.technique_analysis import compute_labeled_technique_stats
+from pyrit.scenario.scenarios.adaptive.dispatcher import ADAPTIVE_TECHNIQUE_ID_LABEL
 from pyrit.scenario.scenarios.adaptive.selectors.technique_selector import SelectorScope
+from pyrit.scenario.scenarios.adaptive.technique_identity import get_history_eval_hash
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -129,8 +131,13 @@ async def select_async(
         rng = _derive_rng(self._seed, decision_key)
 
         effective_run_id = scenario_result_id if self._scope.current_run_only else None
-        stats = compute_technique_stats(
-            technique_eval_hashes=technique_list,
+        stats = compute_labeled_technique_stats(
+            technique_identifiers=technique_list,
+            label_name=ADAPTIVE_TECHNIQUE_ID_LABEL,
+            technique_eval_hashes_by_identifier={
+                technique_identifier: get_history_eval_hash(technique_identifier=technique_identifier)
+                for technique_identifier in technique_list
+            },
             scenario_result_id=effective_run_id,
             targeted_harm_categories=self._scope.targeted_harm_categories,
         )
diff --git a/pyrit/scenario/scenarios/adaptive/selectors/technique_selector.py b/pyrit/scenario/scenarios/adaptive/selectors/technique_selector.py
index 0161e4923b..4ae383df55 100644
--- a/pyrit/scenario/scenarios/adaptive/selectors/technique_selector.py
+++ b/pyrit/scenario/scenarios/adaptive/selectors/technique_selector.py
@@ -20,7 +20,7 @@ class SelectorScope:
 
     All fields default to "no restriction"; combine fields to narrow the
     scope (e.g. current run only, same harm category). Filter values flow
-    through ``compute_technique_stats`` to
+    through labeled technique statistics to
     ``MemoryInterface.get_attack_results``.
 
     The scope is held by the selector at construction time. The per-call
@@ -28,10 +28,9 @@ class SelectorScope:
     to memory only when ``current_run_only`` is set; otherwise the selector
     queries across all runs.
 
-    Per-technique disambiguation uses ``atomic_attack_identifier.eval_hash``
-    (auto-stamped on every persisted attack result), which already encodes
-    the attack class plus its behavior-relevant params. Class-based
-    narrowing is therefore unnecessary at this layer.
+    Per-technique disambiguation uses the canonical registered factory
+    identifier persisted on every Adaptive child result. This keeps distinct
+    registered configurations separate even when they share an attack class.
     """
 
     current_run_only: bool = False
@@ -86,8 +85,8 @@ async def select_async(
         Return techniques in priority order (try first, try second, …).
 
         Args:
-            technique_identifiers (Sequence[str]): Available technique eval
-                hashes.
+            technique_identifiers (Sequence[str]): Available stable Adaptive
+                technique identities.
             objective (str): The objective text for this selection.
             num_top_techniques (int): Max techniques to return. Defaults to 1.
             scenario_result_id (str | None): The current scenario run ID,
@@ -96,7 +95,7 @@ async def select_async(
                 ``current_run_only=True``.
 
         Returns:
-            Sequence[str]: Up to ``num_top_techniques`` technique eval hashes
+            Sequence[str]: Up to ``num_top_techniques`` technique identities
                 in priority order. Fewer if not enough techniques are
                 available.
         """
diff --git a/pyrit/scenario/scenarios/adaptive/technique_identity.py b/pyrit/scenario/scenarios/adaptive/technique_identity.py
new file mode 100644
index 0000000000..950d7358b7
--- /dev/null
+++ b/pyrit/scenario/scenarios/adaptive/technique_identity.py
@@ -0,0 +1,72 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Stable identity carried by Adaptive selector arms."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import ClassVar
+
+
+@dataclass(frozen=True)
+class AdaptiveTechniqueIdentifier:
+    """
+    Join registered factory identity with cross-scenario behavioral identity.
+
+    The factory hash keeps separately registered configured techniques as
+    distinct selector arms. The technique eval hash links each arm to normal
+    scenario results persisted from the same ``AttackTechnique`` behavior.
+    """
+
+    factory_hash: str
+    technique_eval_hash: str
+
+    _PREFIX: ClassVar[str] = "adaptive-v1"
+    _SEPARATOR: ClassVar[str] = ":"
+
+    def serialize(self) -> str:
+        """
+        Serialize the identifier for selector keys and persisted labels.
+
+        Returns:
+            str: Versioned identifier containing both canonical hashes.
+
+        Raises:
+            ValueError: If either hash is empty or contains the field separator.
+        """
+        if self._SEPARATOR in self.factory_hash or self._SEPARATOR in self.technique_eval_hash:
+            raise ValueError("Adaptive technique identity hashes cannot contain ':'")
+        if not self.factory_hash or not self.technique_eval_hash:
+            raise ValueError("Adaptive technique identity hashes cannot be empty")
+        return self._SEPARATOR.join((self._PREFIX, self.factory_hash, self.technique_eval_hash))
+
+    @classmethod
+    def parse(cls, value: str) -> AdaptiveTechniqueIdentifier | None:
+        """
+        Parse a serialized Adaptive identifier.
+
+        Unknown selector identifiers remain valid for custom selectors and
+        legacy tests, so malformed or unversioned values return ``None``.
+
+        Returns:
+            AdaptiveTechniqueIdentifier | None: Parsed identity when recognized.
+        """
+        parts = value.split(cls._SEPARATOR)
+        if len(parts) != 3 or parts[0] != cls._PREFIX or not parts[1] or not parts[2]:
+            return None
+        return cls(factory_hash=parts[1], technique_eval_hash=parts[2])
+
+
+def get_history_eval_hash(*, technique_identifier: str) -> str:
+    """
+    Return the normal-scenario eval hash associated with a selector arm.
+
+    Unversioned identifiers fall back to themselves for backward compatibility
+    with custom selectors and callers that already pass eval hashes.
+
+    Returns:
+        str: Behavioral eval hash used for historical result lookup.
+    """
+    parsed = AdaptiveTechniqueIdentifier.parse(technique_identifier)
+    return parsed.technique_eval_hash if parsed is not None else technique_identifier
diff --git a/pyrit/scenario/scenarios/adaptive/text_adaptive.py b/pyrit/scenario/scenarios/adaptive/text_adaptive.py
index ad1c468312..256e94ec22 100644
--- a/pyrit/scenario/scenarios/adaptive/text_adaptive.py
+++ b/pyrit/scenario/scenarios/adaptive/text_adaptive.py
@@ -126,7 +126,10 @@ def additional_parameters(cls) -> list[Parameter]:
         return [
             Parameter(
                 name="max_attempts_per_objective",
-                description="Max techniques tried per objective. Defaults to 3.",
+                description=(
+                    "Maximum different compatible techniques Adaptive may try for one objective, stopping after "
+                    "the first success. This is separate from retries."
+                ),
                 param_type=int,
                 default=3,
             ),
diff --git a/pyrit/scenario/scenarios/airt/jailbreak.py b/pyrit/scenario/scenarios/airt/jailbreak.py
index ac94993d52..e9b956b110 100644
--- a/pyrit/scenario/scenarios/airt/jailbreak.py
+++ b/pyrit/scenario/scenarios/airt/jailbreak.py
@@ -16,7 +16,12 @@
     AttackTechniqueSeedGroup,
     Parameter,
     ScenarioRunSizeComponent,
-    ScenarioRunSizeEstimate,
+    ScenarioRunSizeEstimateCondition,
+)
+from pyrit.models.catalog import (
+    ScenarioDefaultRunSizeEstimate,
+    ScenarioRunSizeEstimateStatus,
+    ScenarioRunSizeFactor,
 )
 from pyrit.prompt_target import CapabilityName
 from pyrit.registry.components.attack_technique_registry import AttackTechniqueRegistry
@@ -316,12 +321,12 @@ def _build_initial_scenario_metadata(self) -> dict[str, Any]:
         metadata[_JAILBREAK_TEMPLATES_METADATA_KEY] = list(self._resolved_jailbreaks)
         return metadata
 
-    async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
+    async def _estimate_run_size_async(self) -> ScenarioDefaultRunSizeEstimate:
         """
         Estimate the template and attempt axes, preserving the target capability caveat.
 
         Returns:
-            ScenarioRunSizeEstimate: Conditional target-aware estimate.
+            ScenarioDefaultRunSizeEstimate: Conditional target-aware estimate.
 
         Raises:
             ValueError: If native system-prompt delivery is the only selected
@@ -353,6 +358,7 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                 ScenarioRunSizeComponent(
                     label="Baseline",
                     count=seed_group_count,
+                    factors=[ScenarioRunSizeFactor(label="selected logical seed groups", count=seed_group_count)],
                     is_baseline=True,
                 )
             )
@@ -360,6 +366,12 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
             ScenarioRunSizeComponent(
                 label="Inline jailbreak delivery",
                 count=seed_group_count * template_count * attempt_count * converter_count,
+                factors=[
+                    ScenarioRunSizeFactor(label="selected logical seed groups", count=seed_group_count),
+                    ScenarioRunSizeFactor(label="jailbreak templates", count=template_count),
+                    ScenarioRunSizeFactor(label="attempts", count=attempt_count),
+                    ScenarioRunSizeFactor(label="inline delivery techniques", count=converter_count),
+                ],
                 note=(
                     "Each planned unit is one template, one selected delivery technique, and one logical seed group. "
                     "num_jailbreaks selects templates; it is not a persisted result or attempt count."
@@ -371,6 +383,12 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                 ScenarioRunSizeComponent(
                     label="Native system-prompt jailbreak delivery",
                     count=seed_group_count * template_count * attempt_count,
+                    factors=[
+                        ScenarioRunSizeFactor(label="selected logical seed groups", count=seed_group_count),
+                        ScenarioRunSizeFactor(label="jailbreak templates", count=template_count),
+                        ScenarioRunSizeFactor(label="attempts", count=attempt_count),
+                    ],
+                    condition=ScenarioRunSizeEstimateCondition.TargetCapabilities,
                     note=(
                         "The selected objective target supports native system-prompt delivery."
                         if system_delivery_supported is True
@@ -396,10 +414,12 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
             f"{converter_count} selected target-agnostic technique(s) x {attempt_count} configured attempt(s) "
             f"= {seed_group_count * template_count * attempt_count * converter_count} planned unit(s)."
         )
-        estimated_attack_count = (
-            None if system_delivery_selected and system_delivery_supported is None else planned_count
+        status = (
+            ScenarioRunSizeEstimateStatus.Conditional
+            if system_delivery_selected and system_delivery_supported is None
+            else ScenarioRunSizeEstimateStatus.Exact
         )
-        if estimated_attack_count is None:
+        if status is ScenarioRunSizeEstimateStatus.Conditional:
             capability_note = (
                 " The selected technique requires native system-prompt delivery; incompatible targets cannot run it."
                 if converter_count == 0
@@ -422,10 +442,18 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
             effective_parameters["jailbreak_names"] = list(jailbreak_names)
         else:
             effective_parameters["num_jailbreaks"] = template_count
-        return ScenarioRunSizeEstimate(
-            estimated_attack_count=estimated_attack_count,
-            minimum_attack_count=minimum_planned_count if estimated_attack_count is None else None,
-            maximum_attack_count=planned_count if estimated_attack_count is None else None,
+        return ScenarioDefaultRunSizeEstimate(
+            status=status,
+            total_attack_count=planned_count if status is ScenarioRunSizeEstimateStatus.Exact else None,
+            minimum_attack_count=(
+                minimum_planned_count if status is ScenarioRunSizeEstimateStatus.Conditional else None
+            ),
+            maximum_attack_count=planned_count if status is ScenarioRunSizeEstimateStatus.Conditional else None,
+            condition=(
+                ScenarioRunSizeEstimateCondition.TargetCapabilities
+                if status is ScenarioRunSizeEstimateStatus.Conditional
+                else None
+            ),
             components=components,
             datasets=datasets,
             effective_parameters=effective_parameters,
diff --git a/pyrit/scenario/scenarios/airt/psychosocial.py b/pyrit/scenario/scenarios/airt/psychosocial.py
index af6b28e193..338931f643 100644
--- a/pyrit/scenario/scenarios/airt/psychosocial.py
+++ b/pyrit/scenario/scenarios/airt/psychosocial.py
@@ -6,7 +6,7 @@
 import logging
 import pathlib
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, ClassVar, Literal, cast
 
 from pyrit.common import apply_defaults
 from pyrit.common.path import DATASETS_PATH
@@ -342,6 +342,9 @@ class Psychosocial(Scenario):
     """
 
     VERSION: int = 3
+    DATASET_SIZE_LIMIT_OVERRIDE_SCOPE: ClassVar[Literal["per_dataset", "combined", "unsupported"] | None] = (
+        "per_dataset"
+    )
 
     @classmethod
     def additional_parameters(cls) -> list[Parameter]:
diff --git a/pyrit/scenario/scenarios/garak/web_injection.py b/pyrit/scenario/scenarios/garak/web_injection.py
index ddf7216d4b..5b6bf4e997 100644
--- a/pyrit/scenario/scenarios/garak/web_injection.py
+++ b/pyrit/scenario/scenarios/garak/web_injection.py
@@ -6,7 +6,7 @@
 import asyncio
 import logging
 import random
-from typing import TYPE_CHECKING, ClassVar, cast
+from typing import TYPE_CHECKING, ClassVar, Literal, cast
 
 from pyrit.common import apply_defaults
 from pyrit.executor.attack.core.attack_config import AttackScoringConfig
@@ -97,6 +97,9 @@ class WebInjection(Scenario):
 
     VERSION: int = 1
     BASELINE_ATTACK_POLICY: ClassVar[BaselineAttackPolicy] = BaselineAttackPolicy.Enabled
+    DATASET_SIZE_LIMIT_OVERRIDE_SCOPE: ClassVar[Literal["per_dataset", "combined", "unsupported"] | None] = (
+        "unsupported"
+    )
 
     # Local ``.prompt`` datasets under datasets/seed_datasets/local/garak.
     DATASET_EXAMPLE_DOMAINS: ClassVar[str] = "garak_example_domains_xss"
diff --git a/tests/unit/analytics/test_technique_analysis.py b/tests/unit/analytics/test_technique_analysis.py
index 04b1d94890..c31a1cd0ea 100644
--- a/tests/unit/analytics/test_technique_analysis.py
+++ b/tests/unit/analytics/test_technique_analysis.py
@@ -2,15 +2,17 @@
 # Licensed under the MIT license.
 
 from unittest.mock import MagicMock, patch
+from uuid import uuid4
 
 import pytest
 
-from pyrit.analytics.technique_analysis import compute_technique_stats
+from pyrit.analytics.technique_analysis import compute_labeled_technique_stats, compute_technique_stats
 from pyrit.models import AttackOutcome
 
 
 def _make_result(*, eval_hash: str | None, outcome: AttackOutcome) -> MagicMock:
     r = MagicMock()
+    r.attack_result_id = str(uuid4())
     if eval_hash is None:
         r.atomic_attack_identifier = None
     else:
@@ -18,9 +20,16 @@ def _make_result(*, eval_hash: str | None, outcome: AttackOutcome) -> MagicMock:
         identifier.eval_hash = eval_hash
         r.atomic_attack_identifier = identifier
     r.outcome = outcome
+    r.labels = {}
     return r
 
 
+def _make_labeled_result(*, label_name: str, technique_identifier: str, outcome: AttackOutcome) -> MagicMock:
+    result = _make_result(eval_hash=None, outcome=outcome)
+    result.labels = {label_name: technique_identifier}
+    return result
+
+
 @pytest.fixture(autouse=True)
 def _patch_memory():
     mock_memory = MagicMock()
@@ -144,3 +153,77 @@ def test_injected_memory_bypasses_central_memory(self, _patch_memory):
         injected.get_attack_results.assert_called_once()
         _patch_memory.get_attack_results.assert_not_called()
         assert stats["a"].successes == 1
+
+
+class TestComputeLabeledTechniqueStats:
+    def test_counts_distinct_labeled_techniques(self, _patch_memory):
+        label_name = "_adaptive_technique_id"
+        _patch_memory.get_attack_results.return_value = [
+            _make_labeled_result(
+                label_name=label_name,
+                technique_identifier="role-play-movie",
+                outcome=AttackOutcome.SUCCESS,
+            ),
+            _make_labeled_result(
+                label_name=label_name,
+                technique_identifier="role-play-video",
+                outcome=AttackOutcome.FAILURE,
+            ),
+        ]
+
+        stats = compute_labeled_technique_stats(
+            technique_identifiers=["role-play-movie", "role-play-video"],
+            label_name=label_name,
+        )
+
+        assert stats["role-play-movie"].successes == 1
+        assert stats["role-play-video"].failures == 1
+        assert _patch_memory.get_attack_results.call_args.kwargs["labels"] == {
+            label_name: ["role-play-movie", "role-play-video"]
+        }
+
+    def test_unlabeled_and_unrequested_results_are_ignored(self, _patch_memory):
+        label_name = "_adaptive_technique_id"
+        unlabeled = _make_result(eval_hash="shared", outcome=AttackOutcome.SUCCESS)
+        _patch_memory.get_attack_results.return_value = [
+            unlabeled,
+            _make_labeled_result(
+                label_name=label_name,
+                technique_identifier="other",
+                outcome=AttackOutcome.SUCCESS,
+            ),
+        ]
+
+        stats = compute_labeled_technique_stats(
+            technique_identifiers=["requested"],
+            label_name=label_name,
+        )
+
+        assert stats == {}
+
+    def test_merges_labeled_and_normal_scenario_history_without_double_counting(self, _patch_memory):
+        label_name = "_adaptive_technique_id"
+        labeled = _make_labeled_result(
+            label_name=label_name,
+            technique_identifier="factory-arm",
+            outcome=AttackOutcome.SUCCESS,
+        )
+        labeled.atomic_attack_identifier = MagicMock(eval_hash="inner-attack-hash")
+        normal = _make_result(eval_hash="full-technique-hash", outcome=AttackOutcome.FAILURE)
+        _patch_memory.get_attack_results.side_effect = [
+            [labeled],
+            [labeled, normal],
+        ]
+
+        stats = compute_labeled_technique_stats(
+            technique_identifiers=["factory-arm"],
+            label_name=label_name,
+            technique_eval_hashes_by_identifier={"factory-arm": "full-technique-hash"},
+        )
+
+        assert stats["factory-arm"].successes == 1
+        assert stats["factory-arm"].failures == 1
+        assert stats["factory-arm"].total_decided == 2
+        assert _patch_memory.get_attack_results.call_args_list[1].kwargs["atomic_attack_eval_hashes"] == [
+            "full-technique-hash"
+        ]
diff --git a/tests/unit/backend/test_scenario_run_service.py b/tests/unit/backend/test_scenario_run_service.py
index c2a5b75fbb..8e13888613 100644
--- a/tests/unit/backend/test_scenario_run_service.py
+++ b/tests/unit/backend/test_scenario_run_service.py
@@ -45,7 +45,11 @@
     config_hash,
 )
 from pyrit.models.catalog.scenario import RunScenarioRequest
-from pyrit.scenario.core import DatasetAttackConfiguration, DatasetConfiguration
+from pyrit.scenario.core import (
+    CompoundDatasetAttackConfiguration,
+    DatasetAttackConfiguration,
+    DatasetConfiguration,
+)
 from pyrit.scenario.core.scenario_technique import ScenarioTechnique
 from unit.mocks import make_scenario_result
 
@@ -585,6 +589,81 @@ class _MarkerDatasetConfiguration(DatasetConfiguration):
         assert built_config.dataset_names == ["only_this"]
         assert built_config.max_dataset_size is None
 
+    async def test_start_run_dataset_names_rebuilds_homogeneous_compound(self, mock_all_registries) -> None:
+        """Compound per-dataset defaults support exact selected-name overrides."""
+        default_config = CompoundDatasetAttackConfiguration.per_dataset(
+            dataset_names=["airt_hate", "airt_fairness"],
+            max_dataset_size=4,
+        )
+        scenario_instance = mock_all_registries["scenario_instance"]
+        scenario_instance._default_dataset_config = default_config
+
+        service = ScenarioRunService()
+        await service.start_run_async(request=_make_request(dataset_names=["airt_fairness"]))
+
+        init_call = mock_all_registries["scenario_registry"].create_and_initialize_async.await_args
+        built_config = init_call.kwargs["dataset_config"]
+        assert isinstance(built_config, CompoundDatasetAttackConfiguration)
+        assert built_config.dataset_names == ["airt_fairness"]
+        assert [child.max_dataset_size for child in built_config._configurations] == [4]
+        assert default_config.dataset_names == ["airt_hate", "airt_fairness"]
+
+    async def test_start_run_max_dataset_size_updates_each_default_compound_child(self, mock_all_registries) -> None:
+        """An unchanged default selection keeps compound caps per dataset."""
+        default_config = CompoundDatasetAttackConfiguration.per_dataset(
+            dataset_names=["airt_hate", "airt_fairness"],
+            max_dataset_size=4,
+        )
+        scenario_instance = mock_all_registries["scenario_instance"]
+        scenario_instance._default_dataset_config = default_config
+
+        service = ScenarioRunService()
+        await service.start_run_async(request=_make_request(max_dataset_size=2))
+
+        init_call = mock_all_registries["scenario_registry"].create_and_initialize_async.await_args
+        built_config = init_call.kwargs["dataset_config"]
+        assert isinstance(built_config, CompoundDatasetAttackConfiguration)
+        assert built_config is default_config
+        assert built_config.dataset_names == ["airt_hate", "airt_fairness"]
+        assert [child.max_dataset_size for child in built_config._configurations] == [2, 2]
+
+    async def test_start_run_non_name_overrides_preserve_shaped_compound_children(self, mock_all_registries) -> None:
+        """Size and filter overrides do not rebuild scenario-specific child configurations."""
+
+        class _ShapedDatasetConfiguration(DatasetAttackConfiguration):
+            pass
+
+        default_config = CompoundDatasetAttackConfiguration(
+            configurations=[
+                _ShapedDatasetConfiguration(dataset_names=["d1"], max_dataset_size=4),
+                _ShapedDatasetConfiguration(dataset_names=["d2"], max_dataset_size=4),
+            ],
+        )
+        scenario_instance = mock_all_registries["scenario_instance"]
+        scenario_instance._default_dataset_config = default_config
+
+        service = ScenarioRunService()
+        await service.start_run_async(
+            request=_make_request(
+                dataset_names=["d1", "d2"],
+                max_dataset_size=2,
+                dataset_filters={"harm_categories": ["cyber"]},
+            )
+        )
+
+        init_call = mock_all_registries["scenario_registry"].create_and_initialize_async.await_args
+        built_config = init_call.kwargs["dataset_config"]
+        assert built_config is default_config
+        assert [type(child) for child in built_config._configurations] == [
+            _ShapedDatasetConfiguration,
+            _ShapedDatasetConfiguration,
+        ]
+        assert [child.max_dataset_size for child in built_config._configurations] == [2, 2]
+        assert [child.filters for child in built_config._configurations] == [
+            {"harm_categories": ["cyber"]},
+            {"harm_categories": ["cyber"]},
+        ]
+
     async def test_start_run_dataset_names_rejects_incompatible_subclass_constructor(self, mock_all_registries) -> None:
         """Reject overrides that cannot preserve scenario-specific dataset configuration."""
 
diff --git a/tests/unit/backend/test_scenario_service.py b/tests/unit/backend/test_scenario_service.py
index ff657eb456..ceed2f32a8 100644
--- a/tests/unit/backend/test_scenario_service.py
+++ b/tests/unit/backend/test_scenario_service.py
@@ -7,6 +7,7 @@
 
 import asyncio
 from collections import OrderedDict
+from collections.abc import Awaitable
 from typing import Literal
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -26,13 +27,18 @@
 from pyrit.models import (
     Parameter,
     ScenarioDatasetSizeCap,
+    ScenarioDatasetSizeLimit,
     ScenarioDatasetSummary,
     ScenarioRunSizeComponent,
     ScenarioRunSizeEstimate,
     ScenarioRunSizeEstimateRequest,
     ScenarioTechniqueSummary,
 )
-from pyrit.models.catalog.scenario import RegisteredScenario
+from pyrit.models.catalog import (
+    RegisteredScenario,
+    ScenarioDefaultRunSizeEstimate,
+    ScenarioRunSizeEstimateStatus,
+)
 from pyrit.registry import ScenarioMetadata
 from pyrit.scenario.core import DatasetAttackConfiguration, ScenarioTechnique
 
@@ -66,6 +72,15 @@ def clear_service_cache():
     get_scenario_service.cache_clear()
 
 
+def _initialize_test_service(service: ScenarioService) -> None:
+    """Initialize service state without binding the process-wide registry."""
+    service._estimate_cache = OrderedDict()
+    service._estimate_tasks = OrderedDict()
+    service._estimate_task_lock = asyncio.Lock()
+    service._estimate_semaphore = asyncio.Semaphore(4)
+    service._configured_estimate_semaphore = asyncio.Semaphore(4)
+
+
 def _make_scenario_metadata(
     *,
     registry_name: str = "test.scenario",
@@ -96,6 +111,7 @@ def _make_scenario_metadata(
     default_datasets: tuple[str, ...] = ("test_dataset",),
     baseline_policy: str = "enabled",
     include_baseline_by_default: bool = True,
+    dataset_size_limit: ScenarioDatasetSizeLimit | None = None,
 ) -> ScenarioMetadata:
     """Create a ScenarioMetadata instance for testing."""
     return ScenarioMetadata(
@@ -112,6 +128,7 @@ def _make_scenario_metadata(
         aggregate_technique_expansions=aggregate_technique_expansions,
         technique_summaries=technique_summaries,
         default_datasets=default_datasets,
+        dataset_size_limit=dataset_size_limit or ScenarioDatasetSizeLimit(),
         baseline_policy=baseline_policy,
         include_baseline_by_default=include_baseline_by_default,
     )
@@ -127,7 +144,7 @@ class TestScenarioServiceListScenarios:
 
     async def test_list_scenarios_returns_empty_when_no_scenarios(self) -> None:
         """Test that list returns empty list when no scenarios are registered."""
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_all_registered_class_metadata.return_value = []
@@ -141,7 +158,7 @@ async def test_list_scenarios_returns_scenarios_from_registry(self) -> None:
         """Test that list returns scenarios from registry."""
         metadata = _make_scenario_metadata()
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_all_registered_class_metadata.return_value = [metadata]
@@ -161,6 +178,7 @@ async def test_list_scenarios_returns_scenarios_from_registry(self) -> None:
             assert result.items[0].technique_summaries[0].description == "Frames the objective as role play."
             assert result.items[0].technique_summaries[0].tags == ["default", "single_turn"]
             assert result.items[0].default_datasets == ["test_dataset"]
+            assert result.items[0].dataset_size_limit == ScenarioDatasetSizeLimit()
             assert result.items[0].baseline_policy == "enabled"
             assert result.items[0].include_baseline_by_default is True
 
@@ -179,6 +197,24 @@ async def test_list_scenarios_can_return_metadata_without_waiting_for_estimates(
         assert result.items[0].default_run_size == ScenarioRunSizeEstimate.unavailable()
         service._registry.create_instance.assert_not_called()
 
+    async def test_list_scenarios_projects_dataset_size_limit_metadata(self) -> None:
+        """Catalog responses preserve structured scenario-owned limit semantics."""
+        limit = ScenarioDatasetSizeLimit(
+            default_scope="per_dataset",
+            default_count=4,
+            override_scope="per_dataset",
+        )
+        metadata = _make_scenario_metadata(dataset_size_limit=limit)
+
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
+            service = ScenarioService()
+            service._registry = MagicMock()
+            service._registry.get_all_registered_class_metadata.return_value = [metadata]
+
+            result = await service.list_scenarios_async()
+
+        assert result.items[0].dataset_size_limit == limit
+
     async def test_estimate_is_offloaded_and_cached(self) -> None:
         """Scenario-owned estimates run in a worker once and are reused by subsequent reads."""
         metadata = _make_scenario_metadata()
@@ -204,7 +240,7 @@ async def test_estimate_is_offloaded_and_cached(self) -> None:
         scenario = MagicMock()
         scenario.get_default_run_size_estimate_async = AsyncMock(return_value=estimate)
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_registered_class_metadata.return_value = metadata
@@ -239,7 +275,7 @@ async def estimate_async() -> ScenarioRunSizeEstimate:
         scenario = MagicMock()
         scenario.get_default_run_size_estimate_async = AsyncMock(side_effect=estimate_async)
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.create_instance.return_value = scenario
@@ -289,7 +325,7 @@ async def estimate_async() -> ScenarioRunSizeEstimate:
         scenario = MagicMock()
         scenario.get_default_run_size_estimate_async = AsyncMock(side_effect=estimate_async)
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.create_instance.return_value = scenario
@@ -319,7 +355,7 @@ async def test_completed_stale_task_cannot_block_inflight_capacity(self) -> None
         scenario.get_default_run_size_estimate_async = AsyncMock(return_value=estimate)
 
         with (
-            patch.object(ScenarioService, "__init__", lambda self: None),
+            patch.object(ScenarioService, "__init__", _initialize_test_service),
             patch("pyrit.backend.services.scenario_service._ESTIMATE_INFLIGHT_SIZE", 1),
         ):
             service = ScenarioService()
@@ -351,7 +387,7 @@ async def test_one_failed_estimate_does_not_break_catalog(self) -> None:
         bad_scenario = MagicMock()
         bad_scenario.get_default_run_size_estimate_async = AsyncMock(side_effect=RuntimeError("dataset unavailable"))
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_all_registered_class_metadata.return_value = metadata
@@ -363,6 +399,170 @@ async def test_one_failed_estimate_does_not_break_catalog(self) -> None:
             result = await service.list_scenarios_async()
         assert "RuntimeError" in result.items[1].default_run_size.note
 
+    async def test_catalog_estimates_use_bounded_parallelism(self) -> None:
+        """Catalog cards estimate concurrently without exceeding the configured bound."""
+        metadata = [_make_scenario_metadata(registry_name=f"test.scenario_{index}") for index in range(6)]
+        estimate = ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=1,
+            components=[ScenarioRunSizeComponent(label="Default sweep", count=1)],
+        )
+        active = 0
+        maximum_active = 0
+
+        async def estimate_async() -> ScenarioDefaultRunSizeEstimate:
+            nonlocal active, maximum_active
+            active += 1
+            maximum_active = max(maximum_active, active)
+            await asyncio.sleep(0.01)
+            active -= 1
+            return estimate
+
+        scenario = MagicMock()
+        scenario.get_default_run_size_estimate_async = AsyncMock(side_effect=estimate_async)
+        service = ScenarioService()
+        service._registry = MagicMock()
+        service._registry.get_all_registered_class_metadata.return_value = metadata
+        service._registry.create_instance.return_value = scenario
+        service._estimate_semaphore = asyncio.Semaphore(2)
+
+        result = await service.list_scenarios_async()
+
+        assert maximum_active == 2
+        assert all(item.default_run_size == estimate for item in result.items)
+
+    async def test_catalog_queue_wait_does_not_start_execution_timeout(self) -> None:
+        """A queued catalog estimate starts its execution timeout only after acquiring capacity."""
+        metadata = [_make_scenario_metadata(registry_name=f"test.scenario_{index}") for index in range(2)]
+        estimate = ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=1,
+            components=[ScenarioRunSizeComponent(label="Default sweep", count=1)],
+        )
+        first_estimate_started = asyncio.Event()
+        release_first_estimate = asyncio.Event()
+        second_timeout_started = asyncio.Event()
+        estimate_count = 0
+        timeout_count = 0
+
+        async def estimate_async() -> ScenarioDefaultRunSizeEstimate:
+            nonlocal estimate_count
+            estimate_count += 1
+            if estimate_count == 1:
+                first_estimate_started.set()
+                await release_first_estimate.wait()
+            return estimate
+
+        async def wait_for_async(
+            awaitable: Awaitable[ScenarioDefaultRunSizeEstimate], *, timeout: float
+        ) -> ScenarioDefaultRunSizeEstimate:
+            nonlocal timeout_count
+            timeout_count += 1
+            if timeout_count == 2:
+                second_timeout_started.set()
+            return await awaitable
+
+        scenario = MagicMock()
+        scenario.get_default_run_size_estimate_async = AsyncMock(side_effect=estimate_async)
+        service = ScenarioService()
+        service._registry = MagicMock()
+        service._registry.get_all_registered_class_metadata.return_value = metadata
+        service._registry.create_instance.return_value = scenario
+        service._estimate_semaphore = asyncio.Semaphore(1)
+
+        with patch("pyrit.backend.services.scenario_service.asyncio.wait_for", side_effect=wait_for_async):
+            catalog_task = asyncio.create_task(service.list_scenarios_async())
+            await first_estimate_started.wait()
+            await asyncio.sleep(0)
+            assert not second_timeout_started.is_set()
+
+            release_first_estimate.set()
+            result = await catalog_task
+
+        assert second_timeout_started.is_set()
+        assert timeout_count == 2
+        assert all(item.default_run_size == estimate for item in result.items)
+
+    async def test_catalog_execution_timeout_is_unavailable_and_cached(self) -> None:
+        """A genuine estimate execution timeout is unavailable and reused from cache."""
+        metadata = _make_scenario_metadata()
+        estimate_started = asyncio.Event()
+        estimate_cancelled = asyncio.Event()
+        block_estimate = asyncio.Event()
+
+        async def slow_estimate_async() -> ScenarioDefaultRunSizeEstimate:
+            estimate_started.set()
+            try:
+                await block_estimate.wait()
+            except asyncio.CancelledError:
+                estimate_cancelled.set()
+                raise
+            raise AssertionError("The blocked estimate should be cancelled by its execution timeout.")
+
+        scenario = MagicMock()
+        scenario.get_default_run_size_estimate_async = AsyncMock(side_effect=slow_estimate_async)
+        service = ScenarioService()
+        service._registry = MagicMock()
+        service._registry.create_instance.return_value = scenario
+
+        with patch("pyrit.backend.services.scenario_service._DEFAULT_ESTIMATE_TIMEOUT_SECONDS", 0.01):
+            estimate_task = asyncio.create_task(service._get_default_run_size_estimate_async(metadata=metadata))
+            await estimate_started.wait()
+            result = await estimate_task
+            cached = await service._get_default_run_size_estimate_async(metadata=metadata)
+            await asyncio.sleep(0)
+
+        assert result.status is ScenarioRunSizeEstimateStatus.Unavailable
+        assert cached is result
+        assert estimate_cancelled.is_set()
+        service._registry.create_instance.assert_called_once_with(metadata.registry_name)
+        scenario.get_default_run_size_estimate_async.assert_awaited_once()
+        assert service._estimate_tasks == {}
+
+    async def test_configured_estimate_does_not_wait_for_catalog_estimate(self) -> None:
+        """Interactive detail estimates use separate capacity from default catalog cards."""
+        metadata = _make_scenario_metadata()
+        default_estimate = ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=1,
+            components=[ScenarioRunSizeComponent(label="Default sweep", count=1)],
+        )
+        configured_estimate = ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=2,
+            components=[ScenarioRunSizeComponent(label="Configured sweep", count=2)],
+        )
+        started = asyncio.Event()
+        release = asyncio.Event()
+
+        async def default_estimate_async() -> ScenarioDefaultRunSizeEstimate:
+            started.set()
+            await release.wait()
+            return default_estimate
+
+        scenario = MagicMock()
+        scenario.get_default_run_size_estimate_async = AsyncMock(side_effect=default_estimate_async)
+        service = ScenarioService()
+        service._registry = MagicMock()
+        service._registry.get_registered_class_metadata.return_value = metadata
+        service._registry.create_instance.return_value = scenario
+        service._estimate_semaphore = asyncio.Semaphore(1)
+        service._estimate_configured_run_size_async = AsyncMock(return_value=configured_estimate)
+
+        catalog_task = asyncio.create_task(service._get_default_run_size_estimate_async(metadata=metadata))
+        await started.wait()
+        interactive = await asyncio.wait_for(
+            service.estimate_scenario_run_size_async(
+                scenario_name=metadata.registry_name,
+                request=ScenarioRunSizeEstimateRequest(),
+            ),
+            timeout=0.2,
+        )
+        release.set()
+
+        assert interactive == configured_estimate
+        assert await catalog_task == default_estimate
+
     async def test_unavailable_estimate_cache_expires(self) -> None:
         """A transient estimate failure is retried after the unavailable-result TTL."""
         metadata = _make_scenario_metadata()
@@ -376,7 +576,7 @@ async def test_unavailable_estimate_cache_expires(self) -> None:
         )
 
         with (
-            patch.object(ScenarioService, "__init__", lambda self: None),
+            patch.object(ScenarioService, "__init__", _initialize_test_service),
             patch("pyrit.backend.services.scenario_service._UNAVAILABLE_CACHE_TTL_SECONDS", 0),
         ):
             service = ScenarioService()
@@ -402,7 +602,7 @@ async def test_estimate_cache_is_version_aware_and_bounded(self) -> None:
         scenario.get_default_run_size_estimate_async = AsyncMock(return_value=estimate)
 
         with (
-            patch.object(ScenarioService, "__init__", lambda self: None),
+            patch.object(ScenarioService, "__init__", _initialize_test_service),
             patch("pyrit.backend.services.scenario_service._ESTIMATE_CACHE_SIZE", 1),
         ):
             service = ScenarioService()
@@ -421,7 +621,7 @@ async def test_list_scenarios_preserves_disabled_baseline_policy(self) -> None:
             include_baseline_by_default=False,
         )
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_all_registered_class_metadata.return_value = [metadata]
@@ -437,7 +637,7 @@ async def test_list_scenarios_paginates_with_limit(self) -> None:
             _make_scenario_metadata(registry_name=f"test.scenario_{i}", class_name=f"Scenario{i}") for i in range(5)
         ]
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_all_registered_class_metadata.return_value = metadata_list
@@ -459,7 +659,7 @@ async def test_list_scenarios_paginates_with_cursor(self) -> None:
             _make_scenario_metadata(registry_name=f"test.scenario_{i}", class_name=f"Scenario{i}") for i in range(5)
         ]
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_all_registered_class_metadata.return_value = metadata_list
@@ -477,7 +677,7 @@ async def test_list_scenarios_last_page_has_more_false(self) -> None:
             _make_scenario_metadata(registry_name=f"test.scenario_{i}", class_name=f"Scenario{i}") for i in range(3)
         ]
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_all_registered_class_metadata.return_value = metadata_list
@@ -506,7 +706,7 @@ async def test_configured_estimate_uses_shared_launch_resolution(self) -> None:
         objective_target = MagicMock()
 
         with (
-            patch.object(ScenarioService, "__init__", lambda self: None),
+            patch.object(ScenarioService, "__init__", _initialize_test_service),
             patch.object(
                 ScenarioConfigurationResolver, "resolve_target", return_value=objective_target
             ) as resolve_target,
@@ -559,7 +759,7 @@ async def test_configured_estimate_rejects_incompatible_v4_jailbreak_technique(s
         introspection_instance._default_dataset_config = DatasetAttackConfiguration(dataset_names=["harmbench"])
         scenario_class = MagicMock(return_value=introspection_instance)
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_registered_class_metadata.return_value = metadata
@@ -586,7 +786,7 @@ async def test_configured_estimate_without_target_does_not_resolve_or_send_to_ta
         scenario_class = MagicMock(return_value=introspection_instance)
 
         with (
-            patch.object(ScenarioService, "__init__", lambda self: None),
+            patch.object(ScenarioService, "__init__", _initialize_test_service),
             patch.object(ScenarioConfigurationResolver, "resolve_target") as resolve_target,
         ):
             service = ScenarioService()
@@ -610,7 +810,7 @@ async def test_get_scenario_returns_matching_scenario(self) -> None:
         """Test that get returns the matching scenario."""
         metadata = _make_scenario_metadata(registry_name="foundry.red_team_agent")
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_registered_class_metadata.return_value = metadata
@@ -622,7 +822,7 @@ async def test_get_scenario_returns_matching_scenario(self) -> None:
 
     async def test_get_scenario_returns_none_for_missing(self) -> None:
         """Test that get returns None when scenario not found."""
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_registered_class_metadata.return_value = None
@@ -774,8 +974,11 @@ def test_get_scenario_returns_200(self, client: TestClient) -> None:
             aggregate_techniques=["all"],
             all_techniques=["role_play"],
             default_datasets=["airt_hate"],
-            default_run_size=ScenarioRunSizeEstimate(
-                estimated_attack_count=8,
+            default_run_size=ScenarioDefaultRunSizeEstimate(
+                status=ScenarioRunSizeEstimateStatus.Exact,
+                total_attack_count=8,
+                minimum_attack_count=8,
+                maximum_attack_count=8,
                 components=[
                     ScenarioRunSizeComponent(
                         label="Default technique sweep",
@@ -796,7 +999,11 @@ def test_get_scenario_returns_200(self, client: TestClient) -> None:
             data = response.json()
             assert data["scenario_name"] == "foundry.red_team_agent"
             assert data["default_techniques"] == ["role_play"]
-            assert data["default_run_size"]["estimated_attack_count"] == 8
+            assert data["default_run_size"]["version"] == 1
+            assert data["default_run_size"]["status"] == "exact"
+            assert data["default_run_size"]["total_attack_count"] == 8
+            assert data["default_run_size"]["minimum_attack_count"] == 8
+            assert data["default_run_size"]["maximum_attack_count"] == 8
 
     def test_get_scenario_returns_404_when_not_found(self, client: TestClient) -> None:
         """Test that GET /api/scenarios/catalog/{name} returns 404 when not found."""
@@ -836,7 +1043,9 @@ def test_estimate_scenario_returns_configured_projection(self, client: TestClien
             )
 
         assert response.status_code == status.HTTP_200_OK
-        assert response.json()["estimated_attack_count"] == 12
+        assert response.json()["total_attack_count"] == 12
+        assert response.json()["minimum_attack_count"] is None
+        assert response.json()["maximum_attack_count"] is None
         request = mock_service.estimate_scenario_run_size_async.await_args.kwargs["request"]
         assert request.techniques == ["prompt_sending"]
         assert request.include_baseline is False
@@ -957,7 +1166,7 @@ async def test_list_scenarios_includes_supported_parameters(self) -> None:
             ),
         )
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_all_registered_class_metadata.return_value = [metadata]
@@ -986,7 +1195,7 @@ async def test_scenario_with_no_parameters_has_empty_list(self) -> None:
         """Test that scenarios without parameters have empty supported_parameters."""
         metadata = _make_scenario_metadata()
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_all_registered_class_metadata.return_value = [metadata]
@@ -1016,7 +1225,7 @@ async def test_supported_parameters_with_none_default(self) -> None:
             ),
         )
 
-        with patch.object(ScenarioService, "__init__", lambda self: None):
+        with patch.object(ScenarioService, "__init__", _initialize_test_service):
             service = ScenarioService()
             service._registry = MagicMock()
             service._registry.get_all_registered_class_metadata.return_value = [metadata]
diff --git a/tests/unit/models/test_scenario_catalog.py b/tests/unit/models/test_scenario_catalog.py
index 7e89b91ccf..9943beb7ff 100644
--- a/tests/unit/models/test_scenario_catalog.py
+++ b/tests/unit/models/test_scenario_catalog.py
@@ -7,62 +7,187 @@
 from pydantic import ValidationError
 
 from pyrit.models import (
+    ScenarioAdaptiveRunSizeDetails,
     ScenarioDatasetSizeCap,
     ScenarioDatasetSummary,
     ScenarioRunSizeComponent,
     ScenarioRunSizeEstimate,
+    ScenarioRunSizeEstimateCondition,
     ScenarioRunSizeEstimateRequest,
 )
+from pyrit.models.catalog import (
+    ScenarioDefaultRunSizeEstimate,
+    ScenarioRunSizeEstimateStatus,
+    ScenarioRunSizeFactor,
+)
+
+
+def test_run_size_estimate_compatibility_alias_is_canonical_model() -> None:
+    """The initial DTO name remains an unambiguous alias of the versioned model."""
+    assert ScenarioRunSizeEstimate is ScenarioDefaultRunSizeEstimate
+
+
+def test_run_size_estimate_accepts_legacy_fields_and_serializes_canonically() -> None:
+    """Legacy constructors parse while the wire shape remains singular and versioned."""
+    estimate = ScenarioRunSizeEstimate.model_validate(
+        {
+            "status": "exact",
+            "total": 2,
+            "components": [{"label": "Sweep", "count": 2}],
+            "datasets": [
+                {
+                    "name": "harmbench",
+                    "seed_group_count": 100,
+                    "selected_seed_group_count": 2,
+                }
+            ],
+            "caveat": "Legacy explanation.",
+        }
+    )
+
+    assert estimate.total == 2
+    assert estimate.caveat == "Legacy explanation."
+    payload = estimate.model_dump(mode="json")
+    assert payload["version"] == 1
+    assert payload["total_attack_count"] == 2
+    assert payload["minimum_attack_count"] is None
+    assert payload["maximum_attack_count"] is None
+    assert payload["note"] == "Legacy explanation."
+    assert payload["datasets"][0]["logical_seed_group_count"] == 100
+    assert "total" not in payload
+    assert "caveat" not in payload
+    assert "seed_group_count" not in payload["datasets"][0]
+
 
+def test_run_size_estimate_normalizes_legacy_componentless_exact_total() -> None:
+    estimate = ScenarioRunSizeEstimate.model_validate({"status": "exact", "total": 2})
 
-def test_run_size_estimate_requires_available_total_to_match_components() -> None:
-    """Available estimates require an additive component total."""
+    assert estimate.total_attack_count == 2
+    assert estimate.components == [
+        ScenarioRunSizeComponent(
+            label="Legacy total",
+            count=2,
+            note="Normalized from a legacy component-less estimate.",
+        )
+    ]
+
+
+def test_exact_default_run_size_requires_component_total() -> None:
+    """Exact estimates reject totals that do not match their additive components."""
     with pytest.raises(ValidationError, match="components total 6, not 7"):
-        ScenarioRunSizeEstimate(
-            estimated_attack_count=7,
+        ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=7,
+            components=[
+                ScenarioRunSizeComponent(
+                    label="Techniques",
+                    count=6,
+                    factors=[
+                        ScenarioRunSizeFactor(label="seed groups", count=3),
+                        ScenarioRunSizeFactor(label="techniques", count=2),
+                    ],
+                )
+            ],
+        )
+
+
+@pytest.mark.parametrize("field_name", ["minimum_attack_count", "maximum_attack_count"])
+def test_exact_default_run_size_requires_bounds_to_match_total(field_name: str) -> None:
+    """Exact estimates reject bounds that disagree with their authoritative total."""
+    with pytest.raises(ValidationError, match=f"{field_name} to equal total_attack_count"):
+        ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=6,
             components=[ScenarioRunSizeComponent(label="Techniques", count=6)],
+            **{field_name: 5},
         )
 
 
-def test_run_size_estimate_allows_unavailable_count_with_components() -> None:
-    """Unavailable estimates retain useful candidate components and an explanatory note."""
-    estimate = ScenarioRunSizeEstimate(
-        components=[ScenarioRunSizeComponent(label="Candidate techniques", count=6)],
-        note="The final count depends on target capabilities.",
-    )
+def test_default_run_size_requires_ordered_nonnegative_bounds() -> None:
+    """Conditional estimate bounds remain nonnegative and ordered."""
+    with pytest.raises(ValidationError, match="greater than or equal to 0"):
+        ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Conditional,
+            minimum_attack_count=-1,
+        )
+
+    with pytest.raises(ValidationError, match="minimum_attack_count must be less than or equal"):
+        ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Conditional,
+            minimum_attack_count=20,
+            maximum_attack_count=12,
+        )
+
 
-    assert estimate.estimated_attack_count is None
-    assert estimate.components[0].count == 6
+def test_conditional_default_run_size_allows_unknown_bounds() -> None:
+    """Conditional estimates may remain unbounded when no truthful range is available."""
+    estimate = ScenarioDefaultRunSizeEstimate(status=ScenarioRunSizeEstimateStatus.Conditional)
 
+    assert estimate.minimum_attack_count is None
+    assert estimate.maximum_attack_count is None
 
-def test_run_size_estimate_serializes_canonical_api_shape() -> None:
-    """The estimate exposes only the available count and additive components."""
-    estimate = ScenarioRunSizeEstimate(
-        estimated_attack_count=6,
-        components=[ScenarioRunSizeComponent(label="Techniques", count=6)],
+
+def test_run_size_component_requires_factor_product() -> None:
+    """Components reject counts that disagree with their ordered formula factors."""
+    with pytest.raises(ValidationError, match="factor product \\(6\\)"):
+        ScenarioRunSizeComponent(
+            label="Techniques",
+            count=7,
+            factors=[
+                ScenarioRunSizeFactor(label="seed groups", count=3),
+                ScenarioRunSizeFactor(label="techniques", count=2),
+            ],
+        )
+
+
+def test_default_run_size_serializes_versioned_api_shape() -> None:
+    """The estimate exposes stable status, total, component, and factor fields."""
+    estimate = ScenarioDefaultRunSizeEstimate(
+        status=ScenarioRunSizeEstimateStatus.Exact,
+        total_attack_count=6,
+        components=[
+            ScenarioRunSizeComponent(
+                label="Techniques",
+                count=6,
+                factors=[
+                    ScenarioRunSizeFactor(label="seed groups", count=3),
+                    ScenarioRunSizeFactor(label="techniques", count=2),
+                ],
+            )
+        ],
     )
 
     assert estimate.model_dump(mode="json") == {
-        "estimated_attack_count": 6,
+        "version": 1,
+        "status": "exact",
+        "total_attack_count": 6,
         "minimum_attack_count": None,
         "maximum_attack_count": None,
+        "condition": None,
         "components": [
             {
                 "label": "Techniques",
                 "count": 6,
+                "factors": [
+                    {"label": "seed groups", "count": 3},
+                    {"label": "techniques", "count": 2},
+                ],
                 "note": None,
                 "is_baseline": False,
+                "condition": None,
             }
         ],
         "datasets": [],
         "effective_parameters": {},
+        "adaptive_details": None,
         "note": None,
+        "retries_included": False,
     }
 
 
 def test_run_size_estimate_rejects_inverted_bounds() -> None:
     """The minimum estimate cannot exceed the maximum estimate."""
-    with pytest.raises(ValidationError, match="Minimum attack count cannot exceed maximum attack count"):
+    with pytest.raises(ValidationError, match="minimum_attack_count must be less than or equal"):
         ScenarioRunSizeEstimate(minimum_attack_count=8, maximum_attack_count=4)
 
 
@@ -70,13 +195,81 @@ def test_unavailable_run_size_estimate_has_no_count() -> None:
     """The unavailable factory communicates that a count cannot be calculated."""
     estimate = ScenarioRunSizeEstimate.unavailable()
 
-    assert estimate.estimated_attack_count is None
-    assert estimate.note == "Default-run size estimate is unavailable."
+    assert estimate.status is ScenarioRunSizeEstimateStatus.Unavailable
+    assert estimate.total_attack_count is None
+
+
+def test_adaptive_run_size_details_serialize_derived_attempt_bounds() -> None:
+    """Adaptive estimates expose progress objectives and underlying attempt bounds separately."""
+    details = ScenarioAdaptiveRunSizeDetails(
+        objective_count=21,
+        selected_candidate_technique_count=2,
+        candidate_technique_count=2,
+        max_attempts_per_objective=3,
+        techniques_per_objective_upper_bound=2,
+        technique_attempt_count_upper_bound=42,
+    )
+
+    assert details.model_dump(mode="json") == {
+        "objective_count": 21,
+        "selected_candidate_technique_count": 2,
+        "candidate_technique_count": 2,
+        "max_attempts_per_objective": 3,
+        "techniques_per_objective_upper_bound": 2,
+        "technique_attempt_count_upper_bound": 42,
+        "stop_on_first_success": True,
+        "compatibility_may_reduce_attempts": True,
+    }
+
+
+def test_adaptive_run_size_details_reject_inconsistent_attempt_bounds() -> None:
+    """Adaptive work bounds cannot drift from the selected pool and configured cap."""
+    with pytest.raises(ValidationError, match="min\\(candidate_technique_count, max_attempts_per_objective\\)"):
+        ScenarioAdaptiveRunSizeDetails(
+            objective_count=21,
+            selected_candidate_technique_count=2,
+            candidate_technique_count=2,
+            max_attempts_per_objective=3,
+            techniques_per_objective_upper_bound=3,
+            technique_attempt_count_upper_bound=63,
+        )
+
+
+def test_adaptive_run_size_details_accept_legacy_version_one_payload() -> None:
+    """Version-one payloads without the additive selected count remain readable."""
+    details = ScenarioAdaptiveRunSizeDetails.model_validate(
+        {
+            "objective_count": 21,
+            "candidate_technique_count": 2,
+            "max_attempts_per_objective": 3,
+            "techniques_per_objective_upper_bound": 2,
+            "technique_attempt_count_upper_bound": 42,
+        }
+    )
+
+    assert details.selected_candidate_technique_count == 2
+
+
+def test_adaptive_run_size_details_reject_more_compatible_than_selected_candidates() -> None:
+    """Resolved compatible candidates cannot exceed the concrete selected pool."""
+    with pytest.raises(ValidationError, match="cannot exceed selected_candidate_technique_count"):
+        ScenarioAdaptiveRunSizeDetails(
+            objective_count=21,
+            selected_candidate_technique_count=2,
+            candidate_technique_count=3,
+            max_attempts_per_objective=3,
+            techniques_per_objective_upper_bound=3,
+            technique_attempt_count_upper_bound=63,
+        )
 
 
-def test_estimate_exposes_dataset_counts_structurally() -> None:
-    """Effective dataset selection remains machine-readable."""
-    estimate = ScenarioRunSizeEstimate(
+def test_conditional_estimate_exposes_dataset_counts_structurally() -> None:
+    """Conditionality and effective dataset selection are machine-readable."""
+    estimate = ScenarioDefaultRunSizeEstimate(
+        status=ScenarioRunSizeEstimateStatus.Conditional,
+        minimum_attack_count=12,
+        maximum_attack_count=20,
+        condition=ScenarioRunSizeEstimateCondition.TargetCapabilities,
         datasets=[
             ScenarioDatasetSummary(
                 name="harmbench",
@@ -93,11 +286,16 @@ def test_estimate_exposes_dataset_counts_structurally() -> None:
                 ],
             )
         ],
-        note="The final count depends on target capabilities.",
+        note="The final total depends on target capabilities.",
     )
 
-    assert estimate.estimated_attack_count is None
-    assert estimate.model_dump(mode="json")["datasets"] == [
+    payload = estimate.model_dump(mode="json")
+    assert payload["status"] == "conditional"
+    assert payload["total_attack_count"] is None
+    assert payload["minimum_attack_count"] == 12
+    assert payload["maximum_attack_count"] == 20
+    assert payload["condition"] == "target_capabilities"
+    assert payload["datasets"] == [
         {
             "name": "harmbench",
             "kind": "dataset",
@@ -114,6 +312,7 @@ def test_estimate_exposes_dataset_counts_structurally() -> None:
             ],
         }
     ]
+    assert payload["retries_included"] is False
 
 
 def test_estimate_request_reuses_dataset_filter_validation() -> None:
diff --git a/tests/unit/registry/test_scenario_registry.py b/tests/unit/registry/test_scenario_registry.py
index 649ef9beb7..da812520fe 100644
--- a/tests/unit/registry/test_scenario_registry.py
+++ b/tests/unit/registry/test_scenario_registry.py
@@ -3,12 +3,21 @@
 
 """Tests for ScenarioRegistry._build_metadata and create_and_initialize_async."""
 
-from unittest.mock import AsyncMock, MagicMock
+from typing import Literal
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
-from pyrit.registry.components.scenario_registry import ScenarioRegistry
-from pyrit.scenario.core import BaselineAttackPolicy, ScenarioTechnique
+from pyrit.registry import ScenarioRegistry
+from pyrit.scenario import (
+    BaselineAttackPolicy,
+    CompoundDatasetAttackConfiguration,
+    DatasetAttackConfiguration,
+    ScenarioTechnique,
+)
+from pyrit.scenario.scenarios.adaptive import TextAdaptive
+from pyrit.scenario.scenarios.airt import Psychosocial
+from pyrit.scenario.scenarios.garak import WebInjection
 
 
 class _NotNoArgScenario:
@@ -61,6 +70,10 @@ def _resolve_scenario_techniques(self, *, scenario_techniques):
         """Resolve the concrete defaults."""
         return _MetadataTechnique.resolve(scenario_techniques, default=self._default_technique)
 
+    def get_dataset_size_limit_override_scope(self) -> Literal["per_dataset"]:
+        """Return the test scenario's conventional single-dataset override scope."""
+        return "per_dataset"
+
 
 class _MarkdownMetadataScenario(_MetadataScenario):
     """
@@ -104,6 +117,92 @@ def test_build_metadata_expands_ordered_default_techniques() -> None:
     }
 
 
+@pytest.mark.parametrize(
+    ("configuration", "declared_override_scope", "default_scope", "default_count", "override_scope"),
+    [
+        (DatasetAttackConfiguration(dataset_names=["sample"]), "per_dataset", "none", None, "per_dataset"),
+        (
+            DatasetAttackConfiguration(dataset_names=["one", "two"]),
+            "per_dataset",
+            "none",
+            None,
+            "per_dataset",
+        ),
+        (
+            DatasetAttackConfiguration(dataset_names=["one", "two"]),
+            "unsupported",
+            "none",
+            None,
+            "unsupported",
+        ),
+        (
+            DatasetAttackConfiguration(dataset_names=["one", "two"], max_dataset_size=6),
+            "combined",
+            "combined",
+            6,
+            "combined",
+        ),
+        (
+            CompoundDatasetAttackConfiguration.per_dataset(
+                dataset_names=["one", "two"],
+                max_dataset_size=4,
+            ),
+            "per_dataset",
+            "per_dataset",
+            4,
+            "per_dataset",
+        ),
+        (
+            CompoundDatasetAttackConfiguration(
+                configurations=[
+                    DatasetAttackConfiguration(dataset_names=["one"], max_dataset_size=3),
+                    DatasetAttackConfiguration(dataset_names=["two"], max_dataset_size=4),
+                ]
+            ),
+            "per_dataset",
+            "heterogeneous",
+            None,
+            "per_dataset",
+        ),
+    ],
+)
+def test_build_dataset_size_limit_normalizes_configuration_semantics(
+    configuration: DatasetAttackConfiguration,
+    declared_override_scope: Literal["per_dataset", "combined", "unsupported"],
+    default_scope: str,
+    default_count: int | None,
+    override_scope: str,
+) -> None:
+    """Catalog limit metadata preserves no-cap, combined, per-dataset, and heterogeneous defaults."""
+    limit = ScenarioRegistry._build_dataset_size_limit(
+        default_dataset_config=configuration,
+        override_scope=declared_override_scope,
+    )
+
+    assert limit.default_scope == default_scope
+    assert limit.default_count == default_count
+    assert limit.override_scope == override_scope
+
+
+def test_specialized_scenarios_declare_nonstandard_dataset_override_semantics() -> None:
+    """Catalog metadata can remain truthful when a scenario reshapes or ignores generic dataset caps."""
+    assert Psychosocial.DATASET_SIZE_LIMIT_OVERRIDE_SCOPE == "per_dataset"
+    assert WebInjection.DATASET_SIZE_LIMIT_OVERRIDE_SCOPE == "unsupported"
+
+
+def test_text_adaptive_metadata_exposes_per_dataset_default_limit() -> None:
+    """TextAdaptive publishes its canonical four-objective child cap without scenario-name special cases."""
+    with (
+        patch.object(TextAdaptive, "_get_default_objective_scorer", return_value=MagicMock()),
+        patch("pyrit.scenario.core.scenario.CentralMemory.get_memory_instance", return_value=MagicMock()),
+    ):
+        metadata = ScenarioRegistry()._build_metadata("adaptive.text_adaptive", TextAdaptive)
+
+    assert metadata.dataset_size_limit.default_scope == "per_dataset"
+    assert metadata.dataset_size_limit.default_count == 4
+    assert metadata.dataset_size_limit.override_scope == "per_dataset"
+
+
 def test_build_metadata_preserves_structured_markdown_separately() -> None:
     """Scenario metadata keeps plain compatibility text and Markdown source."""
     metadata = ScenarioRegistry()._build_metadata("markdown", _MarkdownMetadataScenario)
diff --git a/tests/unit/scenario/airt/test_jailbreak.py b/tests/unit/scenario/airt/test_jailbreak.py
index 284736b104..580a7c226b 100644
--- a/tests/unit/scenario/airt/test_jailbreak.py
+++ b/tests/unit/scenario/airt/test_jailbreak.py
@@ -3,6 +3,7 @@
 
 """Tests for the Jailbreak class."""
 
+import logging
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -18,10 +19,10 @@
     SeedObjective,
     SeedPrompt,
 )
+from pyrit.models.catalog import ScenarioRunSizeEstimateStatus
 from pyrit.prompt_target import PromptTarget
-from pyrit.registry import TargetRegistry
+from pyrit.registry import ScenarioRegistry, TargetRegistry
 from pyrit.registry.components.attack_technique_registry import AttackTechniqueRegistry
-from pyrit.registry.components.scenario_registry import ScenarioRegistry
 from pyrit.scenario.core import BaselineAttackPolicy
 from pyrit.scenario.core.attack_technique_factory import AttackTechniqueFactory
 from pyrit.scenario.scenarios.airt.jailbreak import (
@@ -251,9 +252,11 @@ async def test_run_size_is_conditional_when_system_delivery_target_is_not_select
             )
 
             estimate = await scenario.get_run_size_estimate_async(target_is_configured=False)
-        assert estimate.estimated_attack_count is None
+        assert estimate.status is ScenarioRunSizeEstimateStatus.Conditional
+        assert estimate.total_attack_count is None
         assert estimate.minimum_attack_count == 2
         assert estimate.maximum_attack_count == 4
+        assert estimate.condition.value == "target_capabilities"
         assert [component.label for component in estimate.components] == [
             "Inline jailbreak delivery",
             "Native system-prompt jailbreak delivery",
diff --git a/tests/unit/scenario/core/test_dataset_configuration.py b/tests/unit/scenario/core/test_dataset_configuration.py
index 3c3ad9c25c..5e1aabd103 100644
--- a/tests/unit/scenario/core/test_dataset_configuration.py
+++ b/tests/unit/scenario/core/test_dataset_configuration.py
@@ -262,6 +262,16 @@ async def test_max_sample_is_a_single_global_budget(self, mock_memory: MagicMock
         result = await config.get_attack_groups_by_dataset_async()
         assert sum(len(groups) for groups in result.values()) == 2
 
+    async def test_estimate_resolution_fetches_full_and_sampled_groups_once(self, mock_memory: MagicMock) -> None:
+        mock_memory.get_seeds.return_value = make_objectives("a", "b", "c")
+        config = DatasetAttackConfiguration(dataset_names=["d1"], max_dataset_size=1)
+
+        full, selected = await config.resolve_attack_groups_for_estimate_async()
+
+        assert len(full["d1"]) == 3
+        assert len(selected["d1"]) == 1
+        mock_memory.get_seeds.assert_called_once()
+
     async def test_loud_raise_when_a_dataset_is_empty(self, mock_memory: MagicMock) -> None:
         mock_memory.get_seeds.side_effect = [make_objectives("a"), []]
         config = DatasetAttackConfiguration(dataset_names=["d1", "d2"], auto_fetch=False)
@@ -507,6 +517,95 @@ def test_per_dataset_builds_one_child_per_name(self) -> None:
         assert [child.dataset_names for child in config._configurations] == [["d1"], ["d2"]]
         assert all(child.max_dataset_size == 4 for child in config._configurations)
 
+    def test_with_dataset_names_preserves_per_dataset_defaults(self) -> None:
+        config = CompoundDatasetAttackConfiguration.per_dataset(
+            dataset_names=["d1", "d2"],
+            max_dataset_size=4,
+            filters={"harm_categories": ["original"]},
+        )
+
+        overridden = config.with_dataset_names(
+            dataset_names=["selected"],
+            filters={"data_types": ["text"]},
+        )
+
+        assert overridden.dataset_names == ["selected"]
+        assert len(overridden._configurations) == 1
+        assert overridden._configurations[0].max_dataset_size == 4
+        assert overridden._configurations[0].filters == {
+            "harm_categories": ["original"],
+            "data_types": ["text"],
+        }
+        assert overridden._configurations[0]._validators == config._configurations[0]._validators
+        assert overridden._validators == config._validators
+        assert config.dataset_names == ["d1", "d2"]
+
+    def test_with_dataset_names_rejects_shaped_children(self) -> None:
+        class _ShapedDatasetConfiguration(DatasetAttackConfiguration):
+            pass
+
+        config = CompoundDatasetAttackConfiguration(
+            configurations=[_ShapedDatasetConfiguration(dataset_names=["d1"])],
+        )
+
+        with pytest.raises(TypeError, match="homogeneous single-dataset"):
+            config.with_dataset_names(dataset_names=["selected"])
+
+    def test_with_dataset_names_rejects_duplicates(self) -> None:
+        config = CompoundDatasetAttackConfiguration.per_dataset(dataset_names=["d1", "d2"])
+
+        with pytest.raises(ValueError, match="cannot contain duplicates"):
+            config.with_dataset_names(dataset_names=["selected", "selected"])
+
+    def test_with_dataset_names_rejects_different_child_validators(self) -> None:
+        first_validator = require_min_size(1)
+        second_validator = require_min_size(2)
+        config = CompoundDatasetAttackConfiguration(
+            configurations=[
+                DatasetAttackConfiguration(dataset_names=["d1"], validators=[first_validator]),
+                DatasetAttackConfiguration(dataset_names=["d2"], validators=[second_validator]),
+            ],
+        )
+
+        with pytest.raises(TypeError, match="shared caps, filters, validators"):
+            config.with_dataset_names(dataset_names=["selected"])
+
+    def test_with_dataset_names_supports_shared_unhashable_validator(self) -> None:
+        class _UnhashableValidator:
+            __hash__ = None
+
+            def __call__(self, resolved: ResolvedDataset) -> None:
+                del resolved
+
+        validator = _UnhashableValidator()
+        config = CompoundDatasetAttackConfiguration.per_dataset(
+            dataset_names=["d1", "d2"],
+            validators=[validator],
+        )
+
+        overridden = config.with_dataset_names(dataset_names=["selected"])
+
+        assert overridden._configurations[0]._custom_validators == [validator]
+
+    def test_update_child_max_dataset_size_preserves_shaped_children(self) -> None:
+        class _ShapedDatasetConfiguration(DatasetAttackConfiguration):
+            pass
+
+        config = CompoundDatasetAttackConfiguration(
+            configurations=[
+                _ShapedDatasetConfiguration(dataset_names=["d1"], max_dataset_size=4),
+                _ShapedDatasetConfiguration(dataset_names=["d2"], max_dataset_size=4),
+            ],
+        )
+
+        config.update_child_max_dataset_size(max_dataset_size=2)
+
+        assert [type(child) for child in config._configurations] == [
+            _ShapedDatasetConfiguration,
+            _ShapedDatasetConfiguration,
+        ]
+        assert [child.max_dataset_size for child in config._configurations] == [2, 2]
+
     def test_size_caps_report_child_and_combined_limits(self) -> None:
         """Planning metadata explains independent child caps and the final compound cap."""
         config = CompoundDatasetAttackConfiguration.per_dataset(dataset_names=["d1", "d2"], max_dataset_size=4)
diff --git a/tests/unit/scenario/scenarios/adaptive/test_dispatcher.py b/tests/unit/scenario/scenarios/adaptive/test_dispatcher.py
index eceb2b5cf9..b33a769829 100644
--- a/tests/unit/scenario/scenarios/adaptive/test_dispatcher.py
+++ b/tests/unit/scenario/scenarios/adaptive/test_dispatcher.py
@@ -18,6 +18,8 @@
 )
 from pyrit.scenario.scenarios.adaptive.dispatcher import (
     ADAPTIVE_ATTEMPT_LABEL,
+    ADAPTIVE_TECHNIQUE_ID_LABEL,
+    ADAPTIVE_TECHNIQUE_NAME_LABEL,
     AdaptiveTechniqueDispatcher,
     TechniqueBundle,
 )
@@ -127,6 +129,10 @@ async def test_builds_sequential_attack(self, target, seed_group):
         # 1-based per-attempt label stamped on each child
         assert attack._child_attacks[0].memory_labels[ADAPTIVE_ATTEMPT_LABEL] == "1"
         assert attack._child_attacks[1].memory_labels[ADAPTIVE_ATTEMPT_LABEL] == "2"
+        assert attack._child_attacks[0].memory_labels[ADAPTIVE_TECHNIQUE_ID_LABEL] == "a"
+        assert attack._child_attacks[1].memory_labels[ADAPTIVE_TECHNIQUE_ID_LABEL] == "b"
+        assert attack._child_attacks[0].memory_labels[ADAPTIVE_TECHNIQUE_NAME_LABEL] == "a"
+        assert attack._child_attacks[1].memory_labels[ADAPTIVE_TECHNIQUE_NAME_LABEL] == "b"
         # default policy is FIRST_SUCCESS
         assert attack._completion_policy is SequenceCompletionPolicy.FIRST_SUCCESS
 
@@ -239,37 +245,25 @@ async def test_merges_real_system_prompt_technique_onto_user_turn_at_sequence_ze
 
 
 @pytest.mark.usefixtures("patch_central_database")
-class TestEvalHashRoundTrip:
+class TestRegisteredTechniqueIdentityRoundTrip:
     """
-    Pin the load-bearing invariant that ``compute_inner_attack_eval_hash``
-    (used by ``AdaptiveScenario._build_techniques_dict`` to key the
-    ``techniques`` dict and by the selector to look up historical stats)
-    equals the ``eval_hash`` the executor stamps on persisted child rows.
-
-    If the prediction helper and the write path ever drift (e.g. a new
-    field is added to the eval-hash rule on one side only), the selector
-    silently reads zero history for every technique and epsilon-greedy
-    degrades to random with no error. This test runs a real
-    ``PromptSendingAttack`` through the dispatcher's ``SequentialAttack``
-    end-to-end and asserts the round-trip holds.
+    Pin the selector identity labels through real child-result persistence.
     """
 
-    async def test_predicted_hash_matches_persisted_row(self, sqlite_instance):
+    async def test_registered_identity_and_name_are_persisted(self, sqlite_instance):
         from pyrit.executor.attack.single_turn.prompt_sending import PromptSendingAttack
         from pyrit.memory.memory_models import AttackResultEntry
         from pyrit.models import AttackSeedGroup, SeedObjective
-        from pyrit.models.identifiers import compute_inner_attack_eval_hash
         from tests.unit.mocks import MockPromptTarget
 
         live_target = MockPromptTarget()
         attack = PromptSendingAttack(objective_target=live_target)
-        predicted_hash = compute_inner_attack_eval_hash(attack=attack)
-
-        bundles = {predicted_hash: TechniqueBundle(attack=attack, name="prompt_sending")}
+        technique_identifier = "factory-identity-hash"
+        bundles = {technique_identifier: TechniqueBundle(attack=attack, name="prompt_sending")}
         dispatcher = AdaptiveTechniqueDispatcher(
             objective_target=live_target,
             techniques=bundles,
-            selector=_StubSelector(technique_order=[predicted_hash]),
+            selector=_StubSelector(technique_order=[technique_identifier]),
             max_attempts_per_objective=1,
         )
 
@@ -280,8 +274,6 @@ async def test_predicted_hash_matches_persisted_row(self, sqlite_instance):
         with sqlite_instance.get_session() as session:
             rows = session.query(AttackResultEntry).all()
 
-        # Drill into the persisted envelope to find rows whose inner attack is PromptSendingAttack,
-        # then assert the eval_hash on those rows matches what the selector predicted.
         matching_rows = [
             r
             for r in rows
@@ -297,10 +289,5 @@ async def test_predicted_hash_matches_persisted_row(self, sqlite_instance):
             f"Expected at least one persisted row whose inner attack is PromptSendingAttack; "
             f"found rows: {[(r.id, r.atomic_attack_identifier) for r in rows]}"
         )
-        for row in matching_rows:
-            stamped_hash = row.atomic_attack_identifier["eval_hash"]
-            assert stamped_hash == predicted_hash, (
-                f"Selector-side eval_hash ({predicted_hash}) drifted from executor-stamped "
-                f"eval_hash ({stamped_hash}) on persisted row {row.id}. "
-                f"compute_inner_attack_eval_hash and AtomicAttackIdentifier.build must agree."
-            )
+        assert all(row.labels[ADAPTIVE_TECHNIQUE_ID_LABEL] == technique_identifier for row in matching_rows)
+        assert all(row.labels[ADAPTIVE_TECHNIQUE_NAME_LABEL] == "prompt_sending" for row in matching_rows)
diff --git a/tests/unit/scenario/scenarios/adaptive/test_epsilon_greedy.py b/tests/unit/scenario/scenarios/adaptive/test_epsilon_greedy.py
index 21144721f5..23d4ee12f9 100644
--- a/tests/unit/scenario/scenarios/adaptive/test_epsilon_greedy.py
+++ b/tests/unit/scenario/scenarios/adaptive/test_epsilon_greedy.py
@@ -6,14 +6,15 @@
 import pytest
 
 from pyrit.analytics.result_analysis import AttackStats
-from pyrit.scenario.scenarios.adaptive.selectors import (
+from pyrit.scenario.scenarios.adaptive import (
+    AdaptiveTechniqueIdentifier,
     EpsilonGreedyTechniqueSelector,
     SelectorScope,
 )
 
 TECHNIQUES = ["a", "b", "c", "d"]
 
-_COMPUTE_PATH = "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_technique_stats"
+_COMPUTE_PATH = "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_labeled_technique_stats"
 
 
 def _seeded_selector(*, epsilon: float = 0.0, random_seed: int = 0) -> EpsilonGreedyTechniqueSelector:
@@ -66,7 +67,7 @@ def test_init_rejects_out_of_range_epsilon(self, bad_epsilon):
 
 class TestEpsilonGreedyTechniqueSelectorSelect:
     @patch(
-        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_technique_stats",
+        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_labeled_technique_stats",
         side_effect=_empty_rates,
     )
     async def test_select_empty_techniques_raises(self, _mock):
@@ -75,7 +76,7 @@ async def test_select_empty_techniques_raises(self, _mock):
             await selector.select_async(technique_identifiers=[], objective="obj")
 
     @patch(
-        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_technique_stats",
+        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_labeled_technique_stats",
         side_effect=_empty_rates,
     )
     async def test_select_all_unseen_ties_resolved_randomly(self, _mock):
@@ -88,7 +89,7 @@ async def test_select_all_unseen_ties_resolved_randomly(self, _mock):
         assert winners.issubset(set(TECHNIQUES))
 
     @patch(
-        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_technique_stats",
+        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_labeled_technique_stats",
         side_effect=_rates_with_winner("b"),
     )
     async def test_select_exploits_clear_winner(self, _mock):
@@ -98,7 +99,7 @@ async def test_select_exploits_clear_winner(self, _mock):
             assert result[0] == "b"
 
     @patch(
-        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_technique_stats",
+        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_labeled_technique_stats",
         side_effect=_empty_rates,
     )
     async def test_select_epsilon_one_is_pure_random(self, _mock):
@@ -110,7 +111,7 @@ async def test_select_epsilon_one_is_pure_random(self, _mock):
         assert picks == set(TECHNIQUES)
 
     @patch(
-        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_technique_stats",
+        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_labeled_technique_stats",
         side_effect=_empty_rates,
     )
     async def test_select_returns_multiple_techniques(self, _mock):
@@ -120,7 +121,7 @@ async def test_select_returns_multiple_techniques(self, _mock):
         assert len(set(result)) == 3  # no duplicates
 
     @patch(
-        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_technique_stats",
+        "pyrit.scenario.scenarios.adaptive.selectors.epsilon_greedy.compute_labeled_technique_stats",
         side_effect=_empty_rates,
     )
     async def test_select_caps_at_available_techniques(self, _mock):
@@ -130,6 +131,18 @@ async def test_select_caps_at_available_techniques(self, _mock):
 
 
 class TestEpsilonGreedySelectorScope:
+    @patch(_COMPUTE_PATH, side_effect=_empty_rates)
+    async def test_forwards_full_technique_eval_hash_for_cross_scenario_history(self, mock_compute):
+        arm = AdaptiveTechniqueIdentifier(
+            factory_hash="factory-hash",
+            technique_eval_hash="full-technique-eval-hash",
+        ).serialize()
+        selector = _seeded_selector()
+
+        await selector.select_async(technique_identifiers=[arm], objective="obj")
+
+        assert mock_compute.call_args.kwargs["technique_eval_hashes_by_identifier"] == {arm: "full-technique-eval-hash"}
+
     @patch(_COMPUTE_PATH, side_effect=_empty_rates)
     async def test_default_scope_passes_none_scenario_result_id(self, mock_compute):
         selector = _seeded_selector()
diff --git a/tests/unit/scenario/scenarios/adaptive/test_technique_identity.py b/tests/unit/scenario/scenarios/adaptive/test_technique_identity.py
new file mode 100644
index 0000000000..c491d6a1f7
--- /dev/null
+++ b/tests/unit/scenario/scenarios/adaptive/test_technique_identity.py
@@ -0,0 +1,23 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+from pyrit.scenario.scenarios.adaptive.technique_identity import (
+    AdaptiveTechniqueIdentifier,
+    get_history_eval_hash,
+)
+
+
+def test_adaptive_technique_identifier_round_trip() -> None:
+    identifier = AdaptiveTechniqueIdentifier(
+        factory_hash="factory-hash",
+        technique_eval_hash="technique-eval-hash",
+    )
+
+    serialized = identifier.serialize()
+
+    assert AdaptiveTechniqueIdentifier.parse(serialized) == identifier
+    assert get_history_eval_hash(technique_identifier=serialized) == "technique-eval-hash"
+
+
+def test_history_eval_hash_falls_back_for_custom_selector_identifier() -> None:
+    assert get_history_eval_hash(technique_identifier="custom-arm") == "custom-arm"
diff --git a/tests/unit/scenario/scenarios/adaptive/test_text_adaptive.py b/tests/unit/scenario/scenarios/adaptive/test_text_adaptive.py
index 93a9929b20..0483b6a30a 100644
--- a/tests/unit/scenario/scenarios/adaptive/test_text_adaptive.py
+++ b/tests/unit/scenario/scenarios/adaptive/test_text_adaptive.py
@@ -11,17 +11,29 @@
 
 import pytest
 
-from pyrit.models import AttackSeedGroup, SeedObjective
+from pyrit.models import AttackSeedGroup, ScenarioDatasetSummary, SeedObjective
 from pyrit.models.identifiers import ComponentIdentifier
 from pyrit.prompt_target import PromptTarget
 from pyrit.registry.components.attack_technique_registry import AttackTechniqueRegistry
 from pyrit.scenario.core.dataset_configuration import CompoundDatasetAttackConfiguration
 from pyrit.scenario.core.scenario import BaselineAttackPolicy
 from pyrit.scenario.scenarios.adaptive.dispatcher import AdaptiveTechniqueDispatcher
+from pyrit.scenario.scenarios.adaptive.technique_identity import AdaptiveTechniqueIdentifier
 from pyrit.scenario.scenarios.adaptive.text_adaptive import TextAdaptive
 from pyrit.score import TrueFalseScorer
 
 _MOCK_MANY_SHOT_EXAMPLES = [{"question": f"q{i}", "answer": f"a{i}"} for i in range(100)]
+_LIGHT_TECHNIQUES = {
+    "role_play_movie_script",
+    "role_play_video_game",
+    "role_play_trivia_game",
+    "role_play_persuasion",
+    "role_play_persuasion_written",
+    "many_shot",
+    "red_teaming",
+    "context_compliance",
+    "flip",
+}
 
 
 def _mock_id(name: str) -> ComponentIdentifier:
@@ -82,30 +94,43 @@ def _make_seed_group(*, value: str, harm_categories: list[str] | None = None) ->
     return AttackSeedGroup(seeds=[SeedObjective(value=value, harm_categories=harm_categories)])
 
 
-def _make_fake_factory(*, seed_technique=None, adversarial_chat=None, scoring_config_type=None) -> MagicMock:
+def _make_fake_factory(
+    *,
+    seed_technique=None,
+    adversarial_chat=None,
+    scoring_config_type=None,
+    attack_identifier: ComponentIdentifier | None = None,
+    factory_identifier: ComponentIdentifier | None = None,
+    technique_identifier: ComponentIdentifier | None = None,
+) -> MagicMock:
     """Return a stub attack-technique factory that produces a fake ``AttackTechnique``.
 
     Mocks the surface ``AdaptiveScenario._build_techniques_dict`` consumes
-    (``factory.create(...)``, ``factory.adversarial_chat``, and
-    ``factory.scoring_config_type``). Each call assigns a unique fake
-    attack identifier (via a fresh UUID) so the bundle dict keys (eval
-    hashes) don't collide across calls — no shared mutable test state, so
-    test execution order doesn't shift hash values.
+    (``factory.create(...)``, ``factory.get_identifier()``,
+    ``factory.adversarial_chat``, and ``factory.scoring_config_type``).
+    Each call assigns unique attack and factory identities unless a test
+    deliberately supplies shared identities.
     """
     fake_id = uuid.uuid4().hex[:8]
 
     fake_technique = MagicMock()
     fake_attack = MagicMock(name=f"fake-attack-technique-{fake_id}")
-    fake_attack.get_identifier.return_value = ComponentIdentifier(
-        class_name=f"FakeAttack{fake_id}",
-        class_module="test_text_adaptive",
+    fake_attack.get_identifier.return_value = attack_identifier or ComponentIdentifier(
+        class_name=f"FakeAttack{fake_id}", class_module="test_text_adaptive"
     )
     fake_technique.attack = fake_attack
     fake_technique.seed_technique = seed_technique
+    fake_technique.get_identifier.return_value = technique_identifier or ComponentIdentifier(
+        class_name=f"FakeTechnique{fake_id}", class_module="test_text_adaptive"
+    )
     factory = MagicMock()
     factory.create.return_value = fake_technique
     factory.adversarial_chat = adversarial_chat
+    factory.uses_adversarial = adversarial_chat is not None
     factory.scoring_config_type = scoring_config_type
+    factory.get_identifier.return_value = factory_identifier or ComponentIdentifier(
+        class_name=f"FakeFactory{fake_id}", class_module="test_text_adaptive"
+    )
     return factory
 
 
@@ -190,6 +215,17 @@ async def test_binding_dataset_cap_exposes_attack_range(
         assert estimate.minimum_attack_count == 2
         assert estimate.maximum_attack_count == 4
 
+    def test_max_attempts_parameter_distinguishes_techniques_from_retries(self):
+        parameter = next(
+            parameter
+            for parameter in TextAdaptive.additional_parameters()
+            if parameter.name == "max_attempts_per_objective"
+        )
+        assert parameter.default == 3
+        assert "different compatible techniques" in parameter.description
+        assert "stopping after the first success" in parameter.description
+        assert "separate from retries" in parameter.description
+
     def test_get_technique_class_is_cached(self):
         cls_a = TextAdaptive.get_technique_class()
         cls_b = TextAdaptive.get_technique_class()
@@ -394,6 +430,139 @@ async def test_techniques_with_seed_technique_are_kept(self, mock_objective_targ
         assert "role_play_movie_script" in technique_names
         assert "many_shot" in technique_names
 
+    @pytest.mark.parametrize(("max_attempts", "expected_attempts"), [(4, 84), (5, 105)])
+    async def test_light_keeps_nine_distinct_factory_arms_and_attempt_bound(
+        self,
+        mock_objective_target,
+        mock_objective_scorer,
+        max_attempts,
+        expected_attempts,
+    ):
+        shared_attack_identifier = _mock_id("SharedPromptSendingAttack")
+        factories = {
+            name: _make_fake_factory(
+                attack_identifier=shared_attack_identifier,
+                factory_identifier=_mock_id(f"Factory_{name}"),
+            )
+            for name in _LIGHT_TECHNIQUES
+        }
+        groups = {"adaptive": [_make_seed_group(value=f"obj-{index}") for index in range(21)]}
+        summaries = [
+            ScenarioDatasetSummary(
+                name="adaptive",
+                logical_seed_group_count=21,
+                selected_seed_group_count=21,
+            )
+        ]
+        scenario = TextAdaptive(objective_scorer=mock_objective_scorer)
+        technique_class = scenario.get_technique_class()
+        scenario.set_params_from_args(
+            args={
+                "objective_target": mock_objective_target,
+                "scenario_techniques": [technique_class("light")],
+                "include_baseline": False,
+                "max_attempts_per_objective": max_attempts,
+            }
+        )
+        scenario._resolve_dataset_groups_for_estimate_async = AsyncMock(return_value=(groups, summaries))
+
+        with patch.object(scenario, "_get_attack_technique_factories", return_value=factories):
+            estimate = await scenario.get_run_size_estimate_async()
+            techniques = scenario._build_techniques_dict(objective_target=mock_objective_target)
+
+        assert len(techniques) == 9
+        assert {bundle.name for bundle in techniques.values()} == _LIGHT_TECHNIQUES
+        parsed_identifiers = [AdaptiveTechniqueIdentifier.parse(identifier) for identifier in techniques]
+        assert all(identifier is not None for identifier in parsed_identifiers)
+        assert len({identifier.factory_hash for identifier in parsed_identifiers if identifier is not None}) == 9
+        assert len({identifier.technique_eval_hash for identifier in parsed_identifiers if identifier is not None}) == 9
+        assert estimate.adaptive_details is not None
+        assert estimate.adaptive_details.selected_candidate_technique_count == 9
+        assert estimate.adaptive_details.candidate_technique_count == 9
+        assert estimate.adaptive_details.techniques_per_objective_upper_bound == max_attempts
+        assert estimate.adaptive_details.technique_attempt_count_upper_bound == expected_attempts
+
+    @pytest.mark.parametrize(("aggregate_name", "expected_candidate_count"), [("light", 9), ("core", 14)])
+    async def test_aggregate_attempt_bound_increases_until_distinct_candidate_count(
+        self,
+        mock_objective_target,
+        mock_objective_scorer,
+        aggregate_name,
+        expected_candidate_count,
+    ):
+        technique_class = TextAdaptive.get_technique_class()
+        aggregate = technique_class(aggregate_name)
+        selected_names = {technique.value for technique in technique_class.expand({aggregate})}
+        assert len(selected_names) == expected_candidate_count
+
+        shared_attack_identifier = _mock_id("SharedAttackImplementation")
+        factories = {
+            name: _make_fake_factory(
+                attack_identifier=shared_attack_identifier,
+                factory_identifier=_mock_id(f"Factory_{name}"),
+            )
+            for name in selected_names
+        }
+        groups = {"adaptive": [_make_seed_group(value=f"obj-{index}") for index in range(21)]}
+        summaries = [
+            ScenarioDatasetSummary(
+                name="adaptive",
+                logical_seed_group_count=21,
+                selected_seed_group_count=21,
+            )
+        ]
+        scenario = TextAdaptive(objective_scorer=mock_objective_scorer)
+        scenario._resolve_dataset_groups_for_estimate_async = AsyncMock(return_value=(groups, summaries))
+        effective_caps: list[int] = []
+
+        with patch.object(scenario, "_get_attack_technique_factories", return_value=factories):
+            for limit in range(1, expected_candidate_count + 3):
+                scenario.set_params_from_args(
+                    args={
+                        "objective_target": mock_objective_target,
+                        "scenario_techniques": [aggregate],
+                        "include_baseline": False,
+                        "max_attempts_per_objective": limit,
+                    }
+                )
+                estimate = await scenario.get_run_size_estimate_async()
+
+                assert estimate.adaptive_details is not None
+                expected_effective_cap = min(limit, expected_candidate_count)
+                effective_caps.append(estimate.adaptive_details.techniques_per_objective_upper_bound)
+                assert estimate.adaptive_details.candidate_technique_count == expected_candidate_count
+                assert estimate.adaptive_details.techniques_per_objective_upper_bound == expected_effective_cap
+                assert estimate.adaptive_details.technique_attempt_count_upper_bound == 21 * expected_effective_cap
+
+        assert effective_caps == [
+            *range(1, expected_candidate_count + 1),
+            expected_candidate_count,
+            expected_candidate_count,
+        ]
+
+    def test_exact_duplicate_registered_technique_dedupes_only_itself(
+        self,
+        mock_objective_target,
+        mock_objective_scorer,
+    ):
+        scenario = TextAdaptive(objective_scorer=mock_objective_scorer)
+        technique_class = scenario.get_technique_class()
+        scenario._scenario_techniques = [
+            technique_class("role_play_movie_script"),
+            technique_class("role_play_movie_script"),
+        ]
+        factory = _make_fake_factory()
+
+        with patch.object(
+            scenario,
+            "_get_attack_technique_factories",
+            return_value={"role_play_movie_script": factory},
+        ):
+            techniques = scenario._build_techniques_dict(objective_target=mock_objective_target)
+
+        assert len(techniques) == 1
+        factory.create.assert_called_once()
+
     async def test_incompatible_seed_technique_is_filtered_per_objective(
         self, mock_objective_target, mock_objective_scorer
     ):
@@ -692,11 +861,19 @@ async def test_baseline_emitted_at_index_zero_by_default(self, mock_objective_ta
         scenario must prepend a baseline atomic attack at index 0.
         """
         groups = {"violence": [_make_seed_group(value="obj", harm_categories=["violence"])]}
-        with patch.object(
-            CompoundDatasetAttackConfiguration,
-            "get_attack_groups_by_dataset_async",
-            new_callable=AsyncMock,
-            return_value=groups,
+        with (
+            patch.object(
+                CompoundDatasetAttackConfiguration,
+                "get_attack_groups_by_dataset_async",
+                new_callable=AsyncMock,
+                return_value=groups,
+            ),
+            patch.object(
+                CompoundDatasetAttackConfiguration,
+                "resolve_attack_groups_for_estimate_async",
+                new_callable=AsyncMock,
+                return_value=(groups, groups),
+            ),
         ):
             scenario = TextAdaptive(objective_scorer=mock_objective_scorer)
             with warnings.catch_warnings():
@@ -708,3 +885,9 @@ async def test_baseline_emitted_at_index_zero_by_default(self, mock_objective_ta
             assert scenario._atomic_attacks[0].atomic_attack_name == "baseline", (
                 f"baseline must be prepended at index 0; got {[a.atomic_attack_name for a in scenario._atomic_attacks]}"
             )
+            estimate = await scenario.get_run_size_estimate_async()
+            plan = scenario._build_run_plan()
+            planned_units = sum(len(group.seed_group_ids) for group in plan.atomic_groups)
+            assert planned_units == 2
+            assert estimate.total_attack_count == planned_units
+            assert [component.count for component in estimate.components] == [1, 1]
diff --git a/tests/unit/scenario/test_default_run_size_estimates.py b/tests/unit/scenario/test_default_run_size_estimates.py
index 88152579e9..f636185315 100644
--- a/tests/unit/scenario/test_default_run_size_estimates.py
+++ b/tests/unit/scenario/test_default_run_size_estimates.py
@@ -8,26 +8,26 @@
 
 import pytest
 
-from pyrit.executor.attack.core.attack_config import AttackScoringConfig
+from pyrit.executor.attack import AttackScoringConfig
 from pyrit.models import (
     AttackSeedGroup,
     AttackTechniqueSeedGroup,
     ComponentIdentifier,
     ScenarioDatasetSizeCap,
     ScenarioDatasetSummary,
+    ScenarioRunSizeEstimateCondition,
     SeedObjective,
     SeedPrompt,
     SeedSimulatedConversation,
 )
+from pyrit.models.catalog import ScenarioRunSizeEstimateStatus
 from pyrit.prompt_target import PromptTarget
-from pyrit.scenario.core import BaselineAttackPolicy, DatasetAttackConfiguration, Scenario, ScenarioTechnique
-from pyrit.scenario.scenarios.adaptive.text_adaptive import TextAdaptive
-from pyrit.scenario.scenarios.airt.jailbreak import Jailbreak
-from pyrit.scenario.scenarios.airt.psychosocial import Psychosocial
-from pyrit.scenario.scenarios.benchmark.adversarial import AdversarialBenchmark
-from pyrit.scenario.scenarios.foundry.red_team_agent import FoundryComposite, FoundryTechnique, RedTeamAgent
-from pyrit.scenario.scenarios.garak.encoding import Encoding
-from pyrit.scenario.scenarios.garak.web_injection import WebInjection
+from pyrit.scenario import BaselineAttackPolicy, DatasetAttackConfiguration, Scenario, ScenarioTechnique
+from pyrit.scenario.scenarios.adaptive import TextAdaptive
+from pyrit.scenario.scenarios.airt import Jailbreak, Psychosocial
+from pyrit.scenario.scenarios.benchmark import AdversarialBenchmark
+from pyrit.scenario.scenarios.foundry import FoundryComposite, FoundryTechnique, RedTeamAgent
+from pyrit.scenario.scenarios.garak import Encoding, WebInjection
 from pyrit.score import TrueFalseScorer
 
 
@@ -455,8 +455,19 @@ async def test_adaptive_estimate_is_target_conditional_and_does_not_multiply_tec
     scenario._resolve_dataset_groups_for_estimate_async = AsyncMock(return_value=_resolved_groups({"adaptive": 3}))
 
     estimate = await scenario.get_default_run_size_estimate_async()
-    assert estimate.estimated_attack_count is None
+
+    assert estimate.status is ScenarioRunSizeEstimateStatus.Conditional
+    assert estimate.total_attack_count is None
+    assert estimate.minimum_attack_count == 3
+    assert estimate.maximum_attack_count == 6
     assert [component.count for component in estimate.components] == [3, 3]
+    assert estimate.adaptive_details is not None
+    assert estimate.adaptive_details.objective_count == 3
+    assert estimate.adaptive_details.selected_candidate_technique_count == 2
+    assert estimate.adaptive_details.candidate_technique_count == 2
+    assert estimate.adaptive_details.max_attempts_per_objective == 3
+    assert estimate.adaptive_details.techniques_per_objective_upper_bound == 2
+    assert estimate.adaptive_details.technique_attempt_count_upper_bound == 6
 
 
 @pytest.mark.usefixtures("patch_central_database")
@@ -486,13 +497,115 @@ async def test_adaptive_estimate_counts_exact_compatible_outer_envelopes_with_ta
         estimate = await scenario.get_run_size_estimate_async()
     assert estimate.estimated_attack_count == 2
     assert [component.count for component in estimate.components] == [2]
-    assert "7 selected technique attempts" in estimate.note
+    assert "Up to 1 selected technique attempts" in estimate.note
+    assert estimate.adaptive_details is not None
+    assert estimate.adaptive_details.objective_count == 2
+    assert estimate.adaptive_details.selected_candidate_technique_count == 2
+    assert estimate.adaptive_details.candidate_technique_count == 1
+    assert estimate.adaptive_details.techniques_per_objective_upper_bound == 1
+    assert estimate.adaptive_details.technique_attempt_count_upper_bound == 2
 
     scenario.set_params_from_args(args={"include_baseline": False})
     estimate_without_target = await scenario.get_run_size_estimate_async()
     assert estimate_without_target.estimated_attack_count is None
 
 
+@pytest.mark.usefixtures("patch_central_database")
+async def test_adaptive_estimate_caps_attempts_below_candidate_pool() -> None:
+    """A lower configured max-attempt cap bounds each objective before pool size."""
+    with patch.object(TextAdaptive, "get_technique_class", return_value=_TwoTechniqueDefault):
+        scenario = TextAdaptive(objective_scorer=_scorer())
+    target = MagicMock(spec=PromptTarget)
+    scenario.set_params_from_args(
+        args={
+            "objective_target": target,
+            "include_baseline": False,
+            "max_attempts_per_objective": 1,
+        }
+    )
+    scenario._resolve_dataset_groups_for_estimate_async = AsyncMock(return_value=_resolved_groups({"adaptive": 3}))
+    dispatcher = MagicMock()
+    dispatcher.compatible_techniques.side_effect = [["one", "two"], ["one"], ["two"]]
+
+    with (
+        patch.object(
+            scenario,
+            "_build_techniques_dict",
+            return_value={"one": MagicMock(), "two": MagicMock()},
+        ),
+        patch(
+            "pyrit.scenario.scenarios.adaptive.adaptive_scenario.AdaptiveTechniqueDispatcher",
+            return_value=dispatcher,
+        ),
+    ):
+        estimate = await scenario.get_run_size_estimate_async()
+
+    assert estimate.adaptive_details is not None
+    assert estimate.adaptive_details.objective_count == 3
+    assert estimate.adaptive_details.selected_candidate_technique_count == 2
+    assert estimate.adaptive_details.candidate_technique_count == 2
+    assert estimate.adaptive_details.max_attempts_per_objective == 1
+    assert estimate.adaptive_details.techniques_per_objective_upper_bound == 1
+    assert estimate.adaptive_details.technique_attempt_count_upper_bound == 3
+
+
+@pytest.mark.usefixtures("patch_central_database")
+async def test_adaptive_conditional_attempt_bound_uses_launch_wide_objective_maximum() -> None:
+    """A sampled compatibility preview cannot understate a capped launch's attempt bound."""
+    with patch.object(TextAdaptive, "get_technique_class", return_value=_TwoTechniqueDefault):
+        scenario = TextAdaptive(objective_scorer=_scorer())
+    target = MagicMock(spec=PromptTarget)
+    scenario.set_params_from_args(
+        args={
+            "objective_target": target,
+            "include_baseline": False,
+            "max_attempts_per_objective": 3,
+        }
+    )
+
+    async def resolve_groups() -> tuple[dict[str, list[AttackSeedGroup]], list[ScenarioDatasetSummary]]:
+        scenario._estimate_has_binding_size_cap = True
+        return _resolved_groups({"adaptive": 3})
+
+    scenario._resolve_dataset_groups_for_estimate_async = AsyncMock(side_effect=resolve_groups)
+    dispatcher = MagicMock()
+    dispatcher.compatible_techniques.side_effect = [["one"], [], []]
+
+    with (
+        patch.object(
+            scenario,
+            "_build_techniques_dict",
+            return_value={"one": MagicMock(), "two": MagicMock()},
+        ),
+        patch(
+            "pyrit.scenario.scenarios.adaptive.adaptive_scenario.AdaptiveTechniqueDispatcher",
+            return_value=dispatcher,
+        ),
+    ):
+        estimate = await scenario.get_run_size_estimate_async()
+
+    assert estimate.status is ScenarioRunSizeEstimateStatus.Conditional
+    assert estimate.minimum_attack_count is None
+    assert estimate.maximum_attack_count == 3
+    assert estimate.components[0].count == 1
+    assert estimate.adaptive_details is not None
+    assert estimate.adaptive_details.objective_count == 3
+    assert estimate.adaptive_details.techniques_per_objective_upper_bound == 2
+    assert estimate.adaptive_details.technique_attempt_count_upper_bound == 6
+
+
+@pytest.mark.usefixtures("patch_central_database")
+async def test_adaptive_estimate_rejects_non_positive_attempt_limit_without_target() -> None:
+    """Invalid attempt limits fail explicitly before constructing estimate metadata."""
+    with patch.object(TextAdaptive, "get_technique_class", return_value=_TwoTechniqueDefault):
+        scenario = TextAdaptive(objective_scorer=_scorer())
+    scenario.set_params_from_args(args={"include_baseline": False, "max_attempts_per_objective": 0})
+    scenario._resolve_dataset_groups_for_estimate_async = AsyncMock(return_value=_resolved_groups({"adaptive": 3}))
+
+    with pytest.raises(ValueError, match="max_attempts_per_objective must be >= 1, got 0"):
+        await scenario.get_run_size_estimate_async()
+
+
 @pytest.mark.usefixtures("patch_central_database")
 async def test_jailbreak_estimate_exposes_template_attempt_and_target_capability_axes() -> None:
     """Jailbreak reports guaranteed inline work separately from conditional system delivery."""
@@ -501,7 +614,14 @@ async def test_jailbreak_estimate_exposes_template_attempt_and_target_capability
     scenario._resolve_dataset_groups_for_estimate_async = AsyncMock(return_value=_resolved_groups({"harmbench": 4}))
 
     estimate = await scenario.get_default_run_size_estimate_async()
-    assert estimate.estimated_attack_count is None
+
+    assert estimate.status is ScenarioRunSizeEstimateStatus.Conditional
+    assert estimate.total_attack_count is None
+    assert estimate.minimum_attack_count == 12
+    assert estimate.maximum_attack_count == 20
+    assert estimate.components[2].condition is ScenarioRunSizeEstimateCondition.TargetCapabilities
+    assert estimate.model_dump(mode="json")["minimum_attack_count"] == 12
+    assert estimate.model_dump(mode="json")["maximum_attack_count"] == 20
     assert [component.count for component in estimate.components] == [4, 8, 8]
     assert "2 template(s) x 4 selected logical seed group(s) x 1 selected" in estimate.note
     assert "Baseline adds one unit per selected seed group (4 units)" in estimate.note

From e5be6c7764b86e5ecda75eebcc8ae788f92673d0 Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Thu, 20 Aug 2026 23:27:03 -0700
Subject: [PATCH 07/12] FIX: Cache conditional scenario estimates

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 pyrit/backend/services/scenario_service.py  |  7 +++++-
 tests/unit/backend/test_scenario_service.py | 25 +++++++++++++++++++++
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/pyrit/backend/services/scenario_service.py b/pyrit/backend/services/scenario_service.py
index eb0b7f9e63..cb3c4b70c3 100644
--- a/pyrit/backend/services/scenario_service.py
+++ b/pyrit/backend/services/scenario_service.py
@@ -19,6 +19,7 @@
     ScenarioDefaultRunSizeEstimate,
     ScenarioRunSizeEstimate,
     ScenarioRunSizeEstimateRequest,
+    ScenarioRunSizeEstimateStatus,
 )
 from pyrit.registry import ScenarioMetadata, ScenarioRegistry
 
@@ -262,7 +263,11 @@ async def _compute_default_run_size_estimate_async(
                 note=f"The scenario could not resolve its default inputs for estimation ({type(exc).__name__})."
             )
 
-        expires_at = monotonic() + _UNAVAILABLE_CACHE_TTL_SECONDS if estimate.estimated_attack_count is None else None
+        expires_at = (
+            monotonic() + _UNAVAILABLE_CACHE_TTL_SECONDS
+            if estimate.status is ScenarioRunSizeEstimateStatus.Unavailable
+            else None
+        )
         cache = self._estimate_cache
         cache[cache_key] = (estimate, expires_at)
         cache.move_to_end(cache_key)
diff --git a/tests/unit/backend/test_scenario_service.py b/tests/unit/backend/test_scenario_service.py
index ceed2f32a8..84d6f12ddc 100644
--- a/tests/unit/backend/test_scenario_service.py
+++ b/tests/unit/backend/test_scenario_service.py
@@ -592,6 +592,31 @@ async def test_unavailable_estimate_cache_expires(self) -> None:
         assert second.default_run_size == estimate
         assert service._registry.create_instance.call_count == 2
 
+    async def test_conditional_estimate_cache_does_not_expire(self) -> None:
+        """A successful conditional estimate remains cached despite having no exact total."""
+        metadata = _make_scenario_metadata()
+        estimate = ScenarioDefaultRunSizeEstimate(status=ScenarioRunSizeEstimateStatus.Conditional)
+        scenario = MagicMock()
+        scenario.get_default_run_size_estimate_async = AsyncMock(return_value=estimate)
+
+        with (
+            patch.object(ScenarioService, "__init__", _initialize_test_service),
+            patch("pyrit.backend.services.scenario_service._UNAVAILABLE_CACHE_TTL_SECONDS", 0),
+        ):
+            service = ScenarioService()
+            service._registry = MagicMock()
+            service._registry.get_registered_class_metadata.return_value = metadata
+            service._registry.create_instance.return_value = scenario
+
+            first = await service.get_scenario_async(scenario_name="test.scenario")
+            second = await service.get_scenario_async(scenario_name="test.scenario")
+
+        assert first is not None
+        assert second is not None
+        assert first.default_run_size == estimate
+        assert second.default_run_size == estimate
+        assert service._registry.create_instance.call_count == 1
+
     async def test_estimate_cache_is_version_aware_and_bounded(self) -> None:
         """Scenario version changes invalidate estimates and the LRU stays bounded."""
         estimate = ScenarioRunSizeEstimate(

From f6518e97d9a7a11bb165e8b755c059295aa999e0 Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Thu, 20 Aug 2026 23:45:00 -0700
Subject: [PATCH 08/12] FIX: Preserve rich scenario sizing after restack

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 pyrit/scenario/core/scenario.py               | 33 ++++++++++++---
 pyrit/scenario/scenarios/airt/psychosocial.py | 18 ++++++--
 .../scenarios/benchmark/adversarial.py        | 41 +++++++++++++++----
 .../scenarios/foundry/red_team_agent.py       | 18 ++++++--
 pyrit/scenario/scenarios/garak/encoding.py    | 22 ++++++++--
 .../scenario/scenarios/garak/web_injection.py | 20 +++++++--
 tests/unit/scenario/airt/test_jailbreak.py    |  6 +--
 7 files changed, 124 insertions(+), 34 deletions(-)

diff --git a/pyrit/scenario/core/scenario.py b/pyrit/scenario/core/scenario.py
index 70be3461fd..877142a019 100644
--- a/pyrit/scenario/core/scenario.py
+++ b/pyrit/scenario/core/scenario.py
@@ -46,10 +46,14 @@
     ScenarioRunPlanAtomicGroup,
     ScenarioRunPlanSeedGroup,
     ScenarioRunSizeComponent,
-    ScenarioRunSizeEstimate,
     ScenarioRunState,
     config_hash,
 )
+from pyrit.models.catalog import (
+    ScenarioDefaultRunSizeEstimate,
+    ScenarioRunSizeEstimateStatus,
+    ScenarioRunSizeFactor,
+)
 from pyrit.models.parameter import ComponentType, Parameter, RegistryReference
 from pyrit.prompt_target import PromptTarget
 from pyrit.prompt_target.common.target_requirements import TargetRequirements
@@ -563,7 +567,7 @@ def _resolve_scenario_techniques(self, *, scenario_techniques: Any) -> list[Scen
         return self._technique_class.resolve(scenario_techniques, default=self._default_technique)
 
     @final
-    async def get_default_run_size_estimate_async(self) -> ScenarioRunSizeEstimate:
+    async def get_default_run_size_estimate_async(self) -> ScenarioDefaultRunSizeEstimate:
         """
         Estimate the scenario's default planned execution units without starting a run.
 
@@ -577,7 +581,9 @@ async def get_default_run_size_estimate_async(self) -> ScenarioRunSizeEstimate:
         return await self.get_run_size_estimate_async(target_is_configured=False)
 
     @final
-    async def get_run_size_estimate_async(self, *, target_is_configured: bool = False) -> ScenarioRunSizeEstimate:
+    async def get_run_size_estimate_async(
+        self, *, target_is_configured: bool = False
+    ) -> ScenarioDefaultRunSizeEstimate:
         """
         Estimate the currently configured run without creating or persisting it.
 
@@ -597,7 +603,7 @@ async def get_run_size_estimate_async(self, *, target_is_configured: bool = Fals
         self._estimate_target_is_configured = self._objective_target is not None
         return await self._estimate_run_size_async()
 
-    async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
+    async def _estimate_run_size_async(self) -> ScenarioDefaultRunSizeEstimate:
         """
         Estimate a standard technique-by-seed-group scenario.
 
@@ -618,6 +624,7 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                 ScenarioRunSizeComponent(
                     label="Baseline",
                     count=seed_group_count,
+                    factors=[ScenarioRunSizeFactor(label="selected logical seed groups", count=seed_group_count)],
                     is_baseline=True,
                     note="One unmodified prompt-sending unit per selected seed group.",
                 )
@@ -643,8 +650,14 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                 else:
                     estimated_attack_count = None
                     note += " The range covers every compatibility mix that the randomized per-dataset caps can select."
-        return ScenarioRunSizeEstimate(
-            estimated_attack_count=estimated_attack_count,
+        status = (
+            ScenarioRunSizeEstimateStatus.Exact
+            if estimated_attack_count is not None
+            else ScenarioRunSizeEstimateStatus.Conditional
+        )
+        return ScenarioDefaultRunSizeEstimate(
+            status=status,
+            total_attack_count=estimated_attack_count,
             minimum_attack_count=minimum_attack_count,
             maximum_attack_count=maximum_attack_count,
             components=components,
@@ -670,6 +683,10 @@ def _build_technique_size_components(
                 ScenarioRunSizeComponent(
                     label="Default technique sweep",
                     count=seed_group_count * technique_count,
+                    factors=[
+                        ScenarioRunSizeFactor(label="selected logical seed groups", count=seed_group_count),
+                        ScenarioRunSizeFactor(label="default concrete techniques", count=technique_count),
+                    ],
                 )
             ]
 
@@ -695,6 +712,10 @@ def _build_technique_size_components(
                 ScenarioRunSizeComponent(
                     label=technique.value,
                     count=compatible_count,
+                    factors=[
+                        ScenarioRunSizeFactor(label="selected concrete techniques", count=1),
+                        ScenarioRunSizeFactor(label="compatible logical seed groups", count=compatible_count),
+                    ],
                 )
             )
         return components
diff --git a/pyrit/scenario/scenarios/airt/psychosocial.py b/pyrit/scenario/scenarios/airt/psychosocial.py
index 338931f643..834d02d26e 100644
--- a/pyrit/scenario/scenarios/airt/psychosocial.py
+++ b/pyrit/scenario/scenarios/airt/psychosocial.py
@@ -32,9 +32,13 @@
 )
 from pyrit.models import (
     ScenarioRunSizeComponent,
-    ScenarioRunSizeEstimate,
     SeedPrompt,
 )
+from pyrit.models.catalog import (
+    ScenarioDefaultRunSizeEstimate,
+    ScenarioRunSizeEstimateStatus,
+    ScenarioRunSizeFactor,
+)
 from pyrit.models.parameter import Parameter
 from pyrit.prompt_normalizer.converter_configuration import ConverterConfiguration
 from pyrit.scenario.core.atomic_attack import AtomicAttack
@@ -489,7 +493,7 @@ async def _resolve_seed_groups_by_dataset_async(
             self._dataset_config = rebuilt
         return await super()._resolve_seed_groups_by_dataset_async(apply_sampling=apply_sampling)
 
-    async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
+    async def _estimate_run_size_async(self) -> ScenarioDefaultRunSizeEstimate:
         """
         Estimate the independent sub-harm technique sweeps and per-harm baselines.
 
@@ -505,6 +509,10 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                 ScenarioRunSizeComponent(
                     label=f"{dataset_name} technique sweep",
                     count=seed_group_count * technique_count,
+                    factors=[
+                        ScenarioRunSizeFactor(label="selected logical seed groups", count=seed_group_count),
+                        ScenarioRunSizeFactor(label="default concrete techniques", count=technique_count),
+                    ],
                 )
             )
             if self._include_baseline:
@@ -512,12 +520,14 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                     ScenarioRunSizeComponent(
                         label=f"{dataset_name} baseline",
                         count=seed_group_count,
+                        factors=[ScenarioRunSizeFactor(label="selected logical seed groups", count=seed_group_count)],
                         is_baseline=True,
                         note="Psychosocial uses a distinct baseline and scorer for each sub-harm.",
                     )
                 )
-        return ScenarioRunSizeEstimate(
-            estimated_attack_count=sum(component.count for component in components),
+        return ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=sum(component.count for component in components),
             components=components,
             datasets=datasets,
             note="Each default sub-harm is planned independently; retries and internal turns are excluded.",
diff --git a/pyrit/scenario/scenarios/benchmark/adversarial.py b/pyrit/scenario/scenarios/benchmark/adversarial.py
index 6d824ccee8..b2d9b4d622 100644
--- a/pyrit/scenario/scenarios/benchmark/adversarial.py
+++ b/pyrit/scenario/scenarios/benchmark/adversarial.py
@@ -17,7 +17,11 @@
     ObjectiveTargetEvaluationIdentifier,
     ScenarioResult,
     ScenarioRunSizeComponent,
-    ScenarioRunSizeEstimate,
+)
+from pyrit.models.catalog import (
+    ScenarioDefaultRunSizeEstimate,
+    ScenarioRunSizeEstimateStatus,
+    ScenarioRunSizeFactor,
 )
 from pyrit.models.parameter import Parameter
 from pyrit.registry import AttackTechniqueRegistry, TargetRegistry
@@ -203,7 +207,7 @@ def __init__(
             scenario_result_id=scenario_result_id,
         )
 
-    async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
+    async def _estimate_run_size_async(self) -> ScenarioDefaultRunSizeEstimate:
         """
         Estimate the target-by-technique matrix using execution compatibility.
 
@@ -227,6 +231,10 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                 ScenarioRunSizeComponent(
                     label=technique.value,
                     count=compatible_count,
+                    factors=[
+                        ScenarioRunSizeFactor(label="selected concrete techniques", count=1),
+                        ScenarioRunSizeFactor(label="compatible logical seed groups", count=compatible_count),
+                    ],
                     note="Count per adversarial target.",
                 )
             )
@@ -246,7 +254,8 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
             per_target_maximum = sampled_per_target_count
         target_names = self.params.get("adversarial_targets") or []
         if not target_names:
-            return ScenarioRunSizeEstimate(
+            return ScenarioDefaultRunSizeEstimate(
+                status=ScenarioRunSizeEstimateStatus.Conditional,
                 minimum_attack_count=per_target_minimum,
                 components=per_target_components,
                 datasets=datasets,
@@ -259,11 +268,22 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
         resolved_targets = self._resolve_adversarial_targets(target_names=target_names)
         target_count = len(resolved_targets)
         components = [
-            component.model_copy(update={"count": component.count * target_count, "note": None})
+            component.model_copy(
+                update={
+                    "count": component.count * target_count,
+                    "factors": [
+                        *component.factors[:1],
+                        ScenarioRunSizeFactor(label="adversarial targets", count=target_count),
+                        *component.factors[1:],
+                    ],
+                    "note": None,
+                }
+            )
             for component in per_target_components
         ]
         if self._use_cached:
-            return ScenarioRunSizeEstimate(
+            return ScenarioDefaultRunSizeEstimate(
+                status=ScenarioRunSizeEstimateStatus.Conditional,
                 minimum_attack_count=0,
                 maximum_attack_count=per_target_maximum * target_count if per_target_maximum is not None else None,
                 components=components,
@@ -274,7 +294,8 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                 ),
             )
         if self._estimate_has_binding_size_cap and compatibility_bounds is None:
-            return ScenarioRunSizeEstimate(
+            return ScenarioDefaultRunSizeEstimate(
+                status=ScenarioRunSizeEstimateStatus.Conditional,
                 components=components,
                 datasets=datasets,
                 note=(
@@ -288,7 +309,8 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
             and per_target_maximum is not None
             and per_target_minimum != per_target_maximum
         ):
-            return ScenarioRunSizeEstimate(
+            return ScenarioDefaultRunSizeEstimate(
+                status=ScenarioRunSizeEstimateStatus.Conditional,
                 minimum_attack_count=per_target_minimum * target_count,
                 maximum_attack_count=per_target_maximum * target_count,
                 components=components,
@@ -298,8 +320,9 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                     "Baseline is forbidden."
                 ),
             )
-        return ScenarioRunSizeEstimate(
-            estimated_attack_count=sum(component.count for component in components),
+        return ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=sum(component.count for component in components),
             components=components,
             datasets=datasets,
             note="Baseline is forbidden; retries and internal attack turns are excluded.",
diff --git a/pyrit/scenario/scenarios/foundry/red_team_agent.py b/pyrit/scenario/scenarios/foundry/red_team_agent.py
index 958683adc1..d65c2cec5c 100644
--- a/pyrit/scenario/scenarios/foundry/red_team_agent.py
+++ b/pyrit/scenario/scenarios/foundry/red_team_agent.py
@@ -53,7 +53,11 @@
 from pyrit.models import (
     AttackSeedGroup,
     ScenarioRunSizeComponent,
-    ScenarioRunSizeEstimate,
+)
+from pyrit.models.catalog import (
+    ScenarioDefaultRunSizeEstimate,
+    ScenarioRunSizeEstimateStatus,
+    ScenarioRunSizeFactor,
 )
 from pyrit.prompt_normalizer.converter_configuration import ConverterConfiguration
 from pyrit.prompt_target import PromptTarget
@@ -418,7 +422,7 @@ def _resolve_foundry_techniques(
         self._scenario_composites = composites
         return flat
 
-    async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
+    async def _estimate_run_size_async(self) -> ScenarioDefaultRunSizeEstimate:
         """
         Estimate one selected seed population per resolved Foundry composition.
 
@@ -431,6 +435,10 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
             ScenarioRunSizeComponent(
                 label=composition.name,
                 count=selected_count,
+                factors=[
+                    ScenarioRunSizeFactor(label="resolved Foundry composites", count=1),
+                    ScenarioRunSizeFactor(label="selected logical seed groups", count=selected_count),
+                ],
             )
             for composition in self._scenario_composites
         ]
@@ -439,11 +447,13 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                 ScenarioRunSizeComponent(
                     label="Baseline",
                     count=selected_count,
+                    factors=[ScenarioRunSizeFactor(label="selected logical seed groups", count=selected_count)],
                     is_baseline=True,
                 )
             )
-        return ScenarioRunSizeEstimate(
-            estimated_attack_count=sum(component.count for component in components),
+        return ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=sum(component.count for component in components),
             components=components,
             datasets=datasets,
             note="Counts one population per resolved Foundry composite, not per flattened constituent technique.",
diff --git a/pyrit/scenario/scenarios/garak/encoding.py b/pyrit/scenario/scenarios/garak/encoding.py
index 43bc565ea2..37b34f1573 100644
--- a/pyrit/scenario/scenarios/garak/encoding.py
+++ b/pyrit/scenario/scenarios/garak/encoding.py
@@ -27,11 +27,15 @@
 from pyrit.models import (
     AttackSeedGroup,
     ScenarioRunSizeComponent,
-    ScenarioRunSizeEstimate,
     Seed,
     SeedObjective,
     SeedPrompt,
 )
+from pyrit.models.catalog import (
+    ScenarioDefaultRunSizeEstimate,
+    ScenarioRunSizeEstimateStatus,
+    ScenarioRunSizeFactor,
+)
 from pyrit.prompt_normalizer.converter_configuration import ConverterConfiguration
 from pyrit.scenario.core.atomic_attack import AtomicAttack
 from pyrit.scenario.core.attack_technique import AttackTechnique
@@ -230,7 +234,7 @@ async def _build_atomic_attacks_async(self, *, context: ScenarioContext) -> list
         atomic_attacks.extend(self._get_converter_attacks(context=context))
         return atomic_attacks
 
-    async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
+    async def _estimate_run_size_async(self) -> ScenarioDefaultRunSizeEstimate:
         """
         Estimate converter variants crossed with raw and decode-template prompt configurations.
 
@@ -246,6 +250,14 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
             ScenarioRunSizeComponent(
                 label="Encoding converter variants",
                 count=seed_group_count * variant_count * prompt_configuration_count,
+                factors=[
+                    ScenarioRunSizeFactor(label="selected logical seed groups", count=seed_group_count),
+                    ScenarioRunSizeFactor(label="concrete converter variants", count=variant_count),
+                    ScenarioRunSizeFactor(
+                        label="raw plus decode prompt configurations",
+                        count=prompt_configuration_count,
+                    ),
+                ],
                 note=(
                     f"{seed_group_count} selected seed groups x {variant_count} concrete converter variants x "
                     f"{prompt_configuration_count} prompt configurations. Base64 and ASCII85 each map to two "
@@ -258,11 +270,13 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                 ScenarioRunSizeComponent(
                     label="Baseline",
                     count=seed_group_count,
+                    factors=[ScenarioRunSizeFactor(label="selected logical seed groups", count=seed_group_count)],
                     is_baseline=True,
                 )
             )
-        return ScenarioRunSizeEstimate(
-            estimated_attack_count=sum(component.count for component in components),
+        return ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=sum(component.count for component in components),
             components=components,
             datasets=datasets,
             note=(
diff --git a/pyrit/scenario/scenarios/garak/web_injection.py b/pyrit/scenario/scenarios/garak/web_injection.py
index 5b6bf4e997..d03f85d154 100644
--- a/pyrit/scenario/scenarios/garak/web_injection.py
+++ b/pyrit/scenario/scenarios/garak/web_injection.py
@@ -16,10 +16,14 @@
     AttackSeedGroup,
     ScenarioDatasetSummary,
     ScenarioRunSizeComponent,
-    ScenarioRunSizeEstimate,
     SeedObjective,
     SeedPrompt,
 )
+from pyrit.models.catalog import (
+    ScenarioDefaultRunSizeEstimate,
+    ScenarioRunSizeEstimateStatus,
+    ScenarioRunSizeFactor,
+)
 from pyrit.scenario.core.atomic_attack import AtomicAttack
 from pyrit.scenario.core.attack_technique import AttackTechnique
 from pyrit.scenario.core.dataset_configuration import DatasetAttackConfiguration
@@ -528,7 +532,7 @@ def _build_synthesized_seed_groups(
             )
         return seed_groups_by_technique
 
-    async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
+    async def _estimate_run_size_async(self) -> ScenarioDefaultRunSizeEstimate:
         """
         Estimate the technique-specific synthesized populations and their shared baseline.
 
@@ -561,6 +565,7 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
             ScenarioRunSizeComponent(
                 label=f"{technique_name} synthesized prompts",
                 count=len(seed_groups),
+                factors=[ScenarioRunSizeFactor(label="synthesized logical seed groups", count=len(seed_groups))],
             )
             for technique_name, seed_groups in seed_groups_by_technique.items()
         ]
@@ -570,12 +575,19 @@ async def _estimate_run_size_async(self) -> ScenarioRunSizeEstimate:
                 ScenarioRunSizeComponent(
                     label="Baseline",
                     count=synthesized_count,
+                    factors=[
+                        ScenarioRunSizeFactor(
+                            label="all synthesized logical seed groups",
+                            count=synthesized_count,
+                        )
+                    ],
                     is_baseline=True,
                     note="The baseline runs over the union of all default technique populations.",
                 )
             )
-        return ScenarioRunSizeEstimate(
-            estimated_attack_count=sum(component.count for component in components),
+        return ScenarioDefaultRunSizeEstimate(
+            status=ScenarioRunSizeEstimateStatus.Exact,
+            total_attack_count=sum(component.count for component in components),
             components=components,
             datasets=datasets,
             note=(
diff --git a/tests/unit/scenario/airt/test_jailbreak.py b/tests/unit/scenario/airt/test_jailbreak.py
index 580a7c226b..e8db0b18c3 100644
--- a/tests/unit/scenario/airt/test_jailbreak.py
+++ b/tests/unit/scenario/airt/test_jailbreak.py
@@ -89,7 +89,7 @@ def mock_memory_seed_groups() -> list[AttackSeedGroup]:
 
 
 @pytest.fixture
-def mock_objective_target() -> PromptTarget:
+def mock_objective_target() -> MagicMock:
     """Create a mock objective target that cannot carry native system-prompt delivery.
 
     ``configuration.includes(...)`` returns ``False`` so the default technique set degrades to the
@@ -102,7 +102,7 @@ def mock_objective_target() -> PromptTarget:
 
 
 @pytest.fixture
-def mock_capable_target() -> PromptTarget:
+def mock_capable_target() -> MagicMock:
     """Create a mock objective target that natively supports editable history + system prompts."""
     mock = MagicMock(spec=PromptTarget)
     mock.get_identifier.return_value = ComponentIdentifier(class_name="MockCapableTarget", class_module="test")
@@ -111,7 +111,7 @@ def mock_capable_target() -> PromptTarget:
 
 
 @pytest.fixture
-def mock_objective_scorer() -> TrueFalseInverterScorer:
+def mock_objective_scorer() -> MagicMock:
     """Create a mock scorer for testing."""
     mock = MagicMock(spec=TrueFalseInverterScorer)
     mock.get_identifier.return_value = ComponentIdentifier(class_name="MockObjectiveScorer", class_module="test")

From f8bac7729d0c3ea79c96fcaadf62033c34b5f614 Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Thu, 20 Aug 2026 23:57:29 -0700
Subject: [PATCH 09/12] FIX: Clarify conditional scenario estimates

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../src/components/Scenarios/ScenarioRunEstimate.test.tsx    | 5 +++--
 frontend/src/components/Scenarios/ScenarioRunEstimate.tsx    | 4 +++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/frontend/src/components/Scenarios/ScenarioRunEstimate.test.tsx b/frontend/src/components/Scenarios/ScenarioRunEstimate.test.tsx
index 4ecf198111..32d229e1df 100644
--- a/frontend/src/components/Scenarios/ScenarioRunEstimate.test.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunEstimate.test.tsx
@@ -706,8 +706,9 @@ describe('ScenarioRunEstimate', () => {
         />
       </TestWrapper>,
     )
-    expect(screen.getByText('Exact total')).toBeInTheDocument()
-    expect(screen.getByText('unavailable')).toBeInTheDocument()
+    expect(screen.getByText('Select targets')).toBeInTheDocument()
+    expect(screen.getByText('to calculate')).toBeInTheDocument()
+    expect(screen.queryByText('Exact total')).not.toBeInTheDocument()
   })
 
   it('does not render implementation terminology in the shared estimate surfaces', () => {
diff --git a/frontend/src/components/Scenarios/ScenarioRunEstimate.tsx b/frontend/src/components/Scenarios/ScenarioRunEstimate.tsx
index f15d4d7583..eb21a7aee8 100644
--- a/frontend/src/components/Scenarios/ScenarioRunEstimate.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunEstimate.tsx
@@ -234,7 +234,9 @@ function resultOperand(estimate: ScenarioRunEstimate): CalculationOperand {
       result: true,
     }
   }
-  return { id: 'result', value: 'Exact total', label: 'unavailable', result: true }
+  return estimate.scope === 'default'
+    ? { id: 'result', value: 'Select targets', label: 'to calculate', result: true }
+    : { id: 'result', value: 'Confirmed', label: 'at launch', result: true }
 }
 
 function adaptivePlannedCalculation(estimate: ScenarioRunEstimate): RunCalculation {

From b842fdabdf86ea473b3e5868360313f521629cf2 Mon Sep 17 00:00:00 2001
From: Roman Lutz <romanlutz13@gmail.com>
Date: Mon, 24 Aug 2026 19:18:16 -0700
Subject: [PATCH 10/12] TEST: Keep auth bootstrap responsive in slow API E2E

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 frontend/e2e/api.spec.ts | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/frontend/e2e/api.spec.ts b/frontend/e2e/api.spec.ts
index 9b5556ef29..2e87ad51fe 100644
--- a/frontend/e2e/api.spec.ts
+++ b/frontend/e2e/api.spec.ts
@@ -138,8 +138,21 @@ test.describe("Scenarios API", () => {
 
 test.describe("Error Handling", () => {
   test("should display UI when backend is slow", async ({ page }) => {
-    // Intercept and delay API calls
+    // Auth configuration must resolve before the application can render.
     await page.route("**/api/**", async (route) => {
+      if (new URL(route.request().url()).pathname === "/api/auth/config") {
+        await route.fulfill({
+          status: 200,
+          contentType: "application/json",
+          body: JSON.stringify({
+            clientId: "",
+            tenantId: "",
+            allowedGroupIds: "",
+          }),
+        });
+        return;
+      }
+
       await new Promise((resolve) => setTimeout(resolve, 2000));
       await route.continue();
     });

From 4f99222c45df8084408486f27459bbdc8b9c3d8e Mon Sep 17 00:00:00 2001
From: Roman Lutz <romanlutz13@gmail.com>
Date: Mon, 24 Aug 2026 19:21:12 -0700
Subject: [PATCH 11/12] STYLE: Remove stale jailbreak test import

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../src/components/Scenarios/scenarioRunEstimateAdapter.ts    | 4 ++--
 tests/unit/scenario/airt/test_jailbreak.py                    | 1 -
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/frontend/src/components/Scenarios/scenarioRunEstimateAdapter.ts b/frontend/src/components/Scenarios/scenarioRunEstimateAdapter.ts
index 63f3bed303..c8fce80d8e 100644
--- a/frontend/src/components/Scenarios/scenarioRunEstimateAdapter.ts
+++ b/frontend/src/components/Scenarios/scenarioRunEstimateAdapter.ts
@@ -105,7 +105,7 @@ export function mapScenarioRunEstimate(
     total,
     minimum: response.minimum_attack_count ?? null,
     maximum: response.maximum_attack_count ?? null,
-    condition: isRichEstimate ? response.condition : null,
+    condition: isRichEstimate ? response.condition ?? null : null,
     components: response.components.map((component) => {
       const id = nextStableId('component', component.label, componentOccurrences)
       return {
@@ -114,7 +114,7 @@ export function mapScenarioRunEstimate(
         count: component.count,
         factors: mapFactors(id, component.factors ?? []),
         isBaseline: component.is_baseline,
-        condition: component.condition,
+        condition: component.condition ?? null,
         note: component.note,
       }
     }),
diff --git a/tests/unit/scenario/airt/test_jailbreak.py b/tests/unit/scenario/airt/test_jailbreak.py
index e8db0b18c3..488d987782 100644
--- a/tests/unit/scenario/airt/test_jailbreak.py
+++ b/tests/unit/scenario/airt/test_jailbreak.py
@@ -3,7 +3,6 @@
 
 """Tests for the Jailbreak class."""
 
-import logging
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock, patch
 

From 88f163f2e2f8ef3d9d5903d5712db1848f5434db Mon Sep 17 00:00:00 2001
From: Behnam Ousat <behnamousat@microsoft.com>
Date: Wed, 2 Sep 2026 10:50:06 -0700
Subject: [PATCH 12/12] FIX: Restore scenario dataset sizing contract

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 49641a15-4119-43bd-becc-9c43eef407f2
---
 pyrit/scenario/core/scenario.py               | 27 ++++++++++++++++---
 tests/unit/models/test_scenario_catalog.py    |  4 +--
 tests/unit/scenario/core/test_scenario.py     | 25 +++++++++++++++++
 .../test_default_run_size_estimates.py        |  1 +
 4 files changed, 52 insertions(+), 5 deletions(-)

diff --git a/pyrit/scenario/core/scenario.py b/pyrit/scenario/core/scenario.py
index 877142a019..2d6888f187 100644
--- a/pyrit/scenario/core/scenario.py
+++ b/pyrit/scenario/core/scenario.py
@@ -15,7 +15,7 @@
 from collections.abc import Mapping, Sequence
 from enum import Enum
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, final
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, final
 
 try:
     # Built-in on Python 3.11+. Fall back to the ``exceptiongroup`` backport on 3.10
@@ -60,7 +60,11 @@
 from pyrit.registry import ScorerRegistry
 from pyrit.registry.resolution import resolve_declared_params, resolve_reference_value
 from pyrit.scenario.core.atomic_attack import AtomicAttack
-from pyrit.scenario.core.dataset_configuration import DatasetAttackConfiguration, read_only_dataset_resolution
+from pyrit.scenario.core.dataset_configuration import (
+    CompoundDatasetAttackConfiguration,
+    DatasetAttackConfiguration,
+    read_only_dataset_resolution,
+)
 from pyrit.scenario.core.scenario_context import ScenarioContext
 from pyrit.scenario.core.scenario_target_defaults import get_default_scorer_target
 from pyrit.scenario.core.scenario_technique import ScenarioTechnique
@@ -140,6 +144,10 @@ class Scenario(ABC):
     #: Whether the default estimator must mirror matrix-builder seed compatibility.
     RUN_SIZE_USES_FACTORY_COMPATIBILITY: ClassVar[bool] = False
 
+    #: How a generic dataset-size run override is interpreted. ``None`` derives the
+    #: standard behavior from the default configuration.
+    DATASET_SIZE_LIMIT_OVERRIDE_SCOPE: ClassVar[Literal["per_dataset", "combined", "unsupported"] | None] = None
+
     def __init_subclass__(cls, **kwargs: Any) -> None:
         """
         Enforce the keyword-only constructor contract on subclasses.
@@ -263,6 +271,19 @@ def __init__(
         # before _build_atomic_attacks_async is awaited so overrides can read it.
         self._include_baseline: bool = False
 
+    def get_dataset_size_limit_override_scope(self) -> Literal["per_dataset", "combined", "unsupported"]:
+        """
+        Return how this scenario interprets a generic dataset-size run override.
+
+        Returns:
+            Literal: The explicit override scope exposed through the scenario catalog.
+        """
+        if self.DATASET_SIZE_LIMIT_OVERRIDE_SCOPE is not None:
+            return self.DATASET_SIZE_LIMIT_OVERRIDE_SCOPE
+        if isinstance(self._default_dataset_config, CompoundDatasetAttackConfiguration):
+            return "per_dataset"
+        return "per_dataset" if len(self._default_dataset_config.dataset_names) <= 1 else "combined"
+
     @property
     def name(self) -> str:
         """The name of the scenario."""
@@ -831,7 +852,7 @@ async def _resolve_dataset_groups_for_estimate_async(
             selected_count = len(selected_groups.get(name, []))
             selection_note = None
             if selected_count != logical_count:
-                selection_note = f"The default selection uses {selected_count} of {logical_count} logical seed groups."
+                selection_note = f"The default selection uses {selected_count} of {logical_count} available objectives."
             datasets.append(
                 ScenarioDatasetSummary(
                     name=name,
diff --git a/tests/unit/models/test_scenario_catalog.py b/tests/unit/models/test_scenario_catalog.py
index 9943beb7ff..60000fbee4 100644
--- a/tests/unit/models/test_scenario_catalog.py
+++ b/tests/unit/models/test_scenario_catalog.py
@@ -275,7 +275,7 @@ def test_conditional_estimate_exposes_dataset_counts_structurally() -> None:
                 name="harmbench",
                 logical_seed_group_count=100,
                 selected_seed_group_count=4,
-                selection_note="The default selection uses 4 of 100 logical seed groups.",
+                selection_note="The default selection uses 4 of 100 available objectives.",
                 configured_caps=[
                     ScenarioDatasetSizeCap(
                         label="per-dataset cap",
@@ -301,7 +301,7 @@ def test_conditional_estimate_exposes_dataset_counts_structurally() -> None:
             "kind": "dataset",
             "logical_seed_group_count": 100,
             "selected_seed_group_count": 4,
-            "selection_note": "The default selection uses 4 of 100 logical seed groups.",
+            "selection_note": "The default selection uses 4 of 100 available objectives.",
             "configured_caps": [
                 {
                     "label": "per-dataset cap",
diff --git a/tests/unit/scenario/core/test_scenario.py b/tests/unit/scenario/core/test_scenario.py
index 23644d02ca..2cf7b7abd4 100644
--- a/tests/unit/scenario/core/test_scenario.py
+++ b/tests/unit/scenario/core/test_scenario.py
@@ -28,6 +28,7 @@
 )
 from pyrit.prompt_target import PromptTarget
 from pyrit.scenario import (
+    CompoundDatasetAttackConfiguration,
     DatasetAttackConfiguration,
     DatasetConfiguration,
     ScenarioIdentifier,
@@ -220,6 +221,30 @@ def test_subclass_implementing_build_atomic_attacks_async_is_concrete():
     assert not ConcreteScenario.__abstractmethods__
 
 
+@pytest.mark.parametrize(
+    ("default_dataset_config", "expected_scope"),
+    [
+        (DatasetAttackConfiguration(dataset_names=["one"]), "per_dataset"),
+        (DatasetAttackConfiguration(dataset_names=["one", "two"]), "combined"),
+        (
+            CompoundDatasetAttackConfiguration.per_dataset(
+                dataset_names=["one", "two"],
+                max_dataset_size=4,
+            ),
+            "per_dataset",
+        ),
+    ],
+)
+def test_dataset_size_limit_override_scope_follows_default_configuration(
+    default_dataset_config: DatasetAttackConfiguration,
+    expected_scope: str,
+) -> None:
+    """Dataset-size overrides preserve the scenario's default configuration semantics."""
+    scenario = ConcreteScenario(version=1, default_dataset_config=default_dataset_config)
+
+    assert scenario.get_dataset_size_limit_override_scope() == expected_scope
+
+
 @pytest.mark.usefixtures("patch_central_database")
 class TestScenarioInitialization:
     """Tests for Scenario class initialization."""
diff --git a/tests/unit/scenario/test_default_run_size_estimates.py b/tests/unit/scenario/test_default_run_size_estimates.py
index f636185315..614211f1ca 100644
--- a/tests/unit/scenario/test_default_run_size_estimates.py
+++ b/tests/unit/scenario/test_default_run_size_estimates.py
@@ -135,6 +135,7 @@ async def test_ordinary_matrix_estimate_uses_planned_seed_units_and_baseline() -
     assert [component.count for component in estimate.components] == [4, 2]
     assert estimate.datasets[0].logical_seed_group_count == 3
     assert estimate.datasets[0].selected_seed_group_count == 2
+    assert estimate.datasets[0].selection_note == "The default selection uses 2 of 3 available objectives."
 
 
 @pytest.mark.usefixtures("patch_central_database")