diff --git a/doc/gui/0_gui.md b/doc/gui/0_gui.md
index 85ce95fb5d..dd5168a713 100644
--- a/doc/gui/0_gui.md
+++ b/doc/gui/0_gui.md
@@ -129,14 +129,14 @@ Groups and objectives show success rates and completion counts separately.
 Completed scans offer an optional **Compare baseline and attack** disclosure
 below the objective results. It stays collapsed while you review individual attacks.
 
-**Watch live conversation** opens saved messages while an attack runs. This view
-is read-only and refreshes saved messages; it has no send controls. **Cancel scan**
-stops remaining scan work and keeps saved results. Ordinary manual chats do not
-have scan cancellation controls.
-After cancellation, saved messages remain available in the read-only chat.
-Saving these conversation links does not add attack outcomes or change success rates.
-
-**Rerun** opens the scenario launch page with saved settings filled in. It does
+**Watch live conversation** opens a running attack in Chat. While the scan runs it,
+Chat is read-only, shows **Attack in progress** in place of the prompt bar, and
+refreshes its messages and conversations; when the attack finishes, Chat shows its
+saved result on the same page. **Cancel** stops remaining scan work and keeps saved
+results; saved messages remain available in the read-only chat. Opening these
+conversations does not add attack outcomes or change success rates.
+
+**Rerun with changes** opens the scenario launch page with saved settings filled in. It does
 not start work or change the original run. Review or edit the settings before
 launching. Recorded target/scorer identities and the scenario version are checked.
 Settings that cannot be restored, including older records without a required identity,
diff --git a/frontend/README.md b/frontend/README.md
index 86d89a26f3..2162141b73 100644
--- a/frontend/README.md
+++ b/frontend/README.md
@@ -133,8 +133,59 @@ rows and keyboard focus. Selected conversation URLs, return-to-scan links and
 the originating History filters survive paging and reloads.
 On narrow screens, the saved viewer scrolls as one surface so loaded evidence
 and continuation controls remain reachable without squeezing the transcript.
-Selecting another saved conversation starts at its beginning; continuation
-keeps the current reading position.
+There, selecting another saved conversation starts at its beginning;
+continuation keeps the current reading position.
+
+## Scan results and live scan attacks
+
+A scan's run page shows its Operation as parent context above the title. Errors
+and scan-level notices (paused updates, overload, an incomplete plan, unmatched
+executions) stay explicit; a single attack's own error is not repeated as a run
+error. While the scan is active, the progress area shows elapsed time, an
+estimate of the time remaining, and **View live attacks**. When the scan
+finishes, the progress area collapses in place without moving the results.
+
+A run of one atomic attack shows that attack directly as one card, from
+preparing through completion. Other runs list atomic attack groups, datasets
+and objectives, and the scenario configuration; each result row opens the
+attack details. Attack details list the objective and outcome (with its score),
+the technique, objective scorer and dataset identities, and any findings that
+link the attack, followed by its conversation and **Attach to findings**.
+
+Every scan conversation opens in Chat at
+`/attack/chat/{attack_id}/conversations/{conversation_id}?scenarioResultId={run_id}`,
+whether the attack is still running or finished. Older
+`/scanner/history/{run_id}/conversations/{conversation_id}` links redirect there.
+While a scan is running the attack, Chat replaces the prompt bar with an
+**Attack in progress** bar and a link back to the scan, keeps the attack
+read-only, and refreshes its metadata, transcript, and conversation list at the
+scan's polling interval. A failed refresh keeps the loaded messages and offers
+**Retry**. When the attack finishes, Chat reloads its saved result in place on
+the same URL.
+
+An interrupted scan can retain recorded conversations without a saved attack
+result. Chat verifies that run, attack and conversation together and reads the
+stored evidence through the run-scoped API, including after reload or an older
+scan link. These conversations stay read-only; no result, score, main
+conversation or message count is invented. Result-dependent actions remain
+unavailable.
+
+Live and manual transcripts follow new messages only while the reader is within
+48 px of the end; scrolling further up keeps the reading position. Historical
+saved evidence keeps its bounded paging and narrow-screen reading behavior
+described above.
+
+**Evaluation metrics** in attack details shows the official evaluation quality
+of the recorded objective-scorer configuration, including configurations no
+longer in the registry. This is separate from the individual attack score in
+the outcome popover and the scan's attack-success rate. Missing evaluation
+metrics have an explicit unavailable state and a link to the scorer-metrics guide.
+
+The Scorer Registry keeps its compact comparison table; each scorer's
+**Evaluation metrics** opens the complete supplied metrics, including standard
+errors and sample counts. Runtime identity and behavioral evaluation identity
+remain separate. Registry names are not used to substitute metrics for a
+recorded run.
 
 ## Dataset catalog
 
diff --git a/frontend/e2e/scenario-hierarchy.spec.ts b/frontend/e2e/scenario-hierarchy.spec.ts
index 34560be577..6663ec35b0 100644
--- a/frontend/e2e/scenario-hierarchy.spec.ts
+++ b/frontend/e2e/scenario-hierarchy.spec.ts
@@ -320,7 +320,7 @@ test('browses compound results in the existing attack-group table with stable to
   await expect(table.getByText('Step 1', { exact: true })).toBeVisible()
   await expect(row('#2')).toContainText('Unresolved reference')
   await expect(row('#4')).toContainText('Unresolved reference')
-  await expect(row('Step 5').getByRole('cell').nth(2)).toHaveText('True')
+  await expect(row('Step 5').getByRole('cell', { name: 'Attack outcome', exact: true })).toHaveText('True')
   await expect(section.getByText('Showing 200 of 520 saved child positions')).toBeVisible()
 
   for (const shown of [400, 520]) {
@@ -348,12 +348,13 @@ test('browses compound results in the existing attack-group table with stable to
   await expect(section.getByText('Nested step 2', { exact: true })).toBeVisible()
   expect(await totals.textContent()).toBe(before)
 
-  await section.getByRole('button', { name: 'Open details for #5 sequential: Step 5' }).click()
+  const detailsRow = section.getByRole('row', { name: 'View attack details for #5 sequential: Step 5' })
+  await detailsRow.click()
   const dialog = page.getByRole('dialog', { name: 'sequential' })
   await expect(dialog.getByText('Step 5', { exact: true })).toBeVisible()
-  await dialog.getByRole('button', { name: 'Close', exact: true }).click()
+  await dialog.getByRole('button', { name: 'Close attack details', exact: true }).click()
   await expect(page.getByRole('dialog')).toHaveCount(0)
-  await expect(section.getByRole('button', { name: 'Open details for #5 sequential: Step 5' })).toBeFocused()
+  await expect(detailsRow).toBeFocused()
 
   await page.getByRole('heading', { name: 'Atomic attack groups', exact: true }).evaluate((heading) =>
     heading.scrollIntoView({ block: 'start' }),
@@ -371,8 +372,8 @@ test('opens an actual saved child chat and retains the existing scenario breadcr
   const section = page.getByRole('region', { name: 'Atomic attack groups', exact: true })
   await expect(section.getByRole('button', { name: 'Collapse attacks in Sequential' })).toHaveAttribute('aria-expanded', 'true')
   await section.getByRole('button', { name: 'Expand children of sequential: Sequential parent' }).click()
-  const row = section.getByRole('row', { name: 'View conversation for #5 sequential: Step 5' })
-  const chatLink = row.getByRole('link', { name: 'Step 5', exact: true })
+  const row = section.getByRole('row', { name: 'View attack details for #5 sequential: Step 5' })
+  const chatLink = row.getByRole('link', { name: 'Conversation', exact: true })
   await expect(chatLink).toHaveAttribute('href', new RegExp(`\\?scenarioResultId=${scenarioResultId}$`))
   await chatLink.click()
 
@@ -403,7 +404,7 @@ test('opens an actual saved child chat and retains the existing scenario breadcr
   await expect(page).toHaveURL(run)
   const groups = page.getByRole('region', { name: 'Atomic attack groups', exact: true })
   await expect(groups.getByText('2 groups, 524 executions', { exact: true })).toBeVisible()
-  const single = groups.getByRole('row', { name: 'View conversation for single: Single-turn attempt' })
+  const single = groups.getByRole('row', { name: 'View attack details for single: Single-turn attempt' })
   const collapseSingle = groups.getByRole('button', { name: 'Collapse attacks in Single turn' })
   await expect(collapseSingle).toHaveAttribute('aria-expanded', 'true')
   await expect(single).toBeVisible()
@@ -412,6 +413,9 @@ test('opens an actual saved child chat and retains the existing scenario breadcr
   await groups.getByRole('button', { name: 'Expand attacks in Single turn' }).click()
   await single.focus()
   await page.keyboard.press('Enter')
+  const singleDetails = page.getByRole('dialog', { name: 'single' })
+  await expect(singleDetails).toBeVisible()
+  await singleDetails.getByRole('link', { name: 'Open conversation' }).click()
   await expect(page.getByText('Stored example response for Single-turn attempt. This is offline sample data.', { exact: true })).toBeVisible()
   await page.getByRole('link', { name: 'Back to scan', exact: true }).click()
   await expect(page).toHaveURL(run)
@@ -708,8 +712,11 @@ test('owns pending continuations across rapid selection, attack navigation and u
   await expect(page).toHaveURL(run)
   const groups = page.getByRole('region', { name: 'Atomic attack groups', exact: true })
   await expect(groups.getByRole('button', { name: 'Collapse attacks in Single turn' })).toHaveAttribute('aria-expanded', 'true')
-  await groups.getByRole('row', { name: 'View conversation for single: Single-turn attempt' }).focus()
+  await groups.getByRole('row', { name: 'View attack details for single: Single-turn attempt' }).focus()
   await page.keyboard.press('Enter')
+  const details = page.getByRole('dialog', { name: 'single' })
+  await expect(details).toBeVisible()
+  await details.getByRole('link', { name: 'Open conversation', exact: true }).click()
   await expect(page.getByText('Stored example response for Single-turn attempt. This is offline sample data.', { exact: true })).toBeVisible()
   await controlSavedRead(page, 'release_messages')
   expect((await unmounted).status()).toBe(200)
diff --git a/frontend/e2e/scenario-history.spec.ts b/frontend/e2e/scenario-history.spec.ts
index d6e4a107e6..8c1b7213ae 100644
--- a/frontend/e2e/scenario-history.spec.ts
+++ b/frontend/e2e/scenario-history.spec.ts
@@ -3,7 +3,7 @@ import { makeAttackMetadata } from "./_attacks";
 import { mockVersion } from "./_compatibility";
 
 import { READY_RUNTIME } from "./_runtime";
-import type { AttackSummary, ScenarioHierarchyProjection } from "@/types";
+import type { AttackSummary, ScenarioHierarchyProjection, ScenarioProgressResult } from "@/types";
 
 const RUN_ID = "123e4567-e89b-12d3-a456-426614174000";
 const ACTIVE_RUN_ID = "123e4567-e89b-12d3-a456-426614174001";
@@ -207,6 +207,7 @@ const plan = {
     technique_name: "prompt_sending",
     technique_eval_hash: "eval-1",
     seed_group_ids: ["seed-1"],
+    is_compound: false,
     description: "Sends the objective directly to the target.",
     tags: ["single_turn"],
   }],
@@ -244,11 +245,56 @@ interface ScenarioMocks {
 
 async function mockScenarioAPIs(
   page: Page,
-  options: { readonly isRunCompleted?: () => boolean } = {},
+  options: { readonly isRunCompleted?: () => boolean; readonly grouped?: boolean } = {},
 ): Promise<ScenarioMocks> {
   let progressRequests = 0;
   let launchRequest: Record<string, unknown> | undefined;
   const estimateRequests: Record<string, unknown>[] = [];
+  const seedGroups = options.grouped ? [
+    ...plan.seed_groups,
+    {
+      ...plan.seed_groups[0],
+      id: "seed-2",
+      objective_sha256: "second-objective-hash",
+      objective: "Reveal the protected configuration.",
+    },
+  ] : plan.seed_groups;
+  const runPlan = {
+    ...plan,
+    atomic_groups: plan.atomic_groups.map((group) => ({
+      ...group,
+      seed_group_ids: seedGroups.map((seed) => seed.id),
+    })),
+    seed_groups: seedGroups,
+  };
+  const attempts: ScenarioProgressResult[] = seedGroups.map((seed, index) => ({
+    ...progressAttempt,
+    attack_result_id: index === 0 ? ATTACK_ID : "attack-result-2",
+    conversation_id: `conversation-${index + 1}`,
+    seed_group_id: seed.id,
+    outcome: index === 0 ? "success" : "failure",
+    total_retries: index === 0 ? 1 : 0,
+    seed_identifiers: [{
+      component_name: "SeedObjective",
+      parameters: { dataset_name: "harmbench", value: seed.objective },
+      children: {},
+    }],
+  }));
+  const counts = {
+    completed: attempts.length,
+    planned: attempts.length,
+    succeeded: 1,
+    success_percentage: 100 / attempts.length,
+    errors: 0,
+    retries: 1,
+  };
+  const savedRun = {
+    ...runSummary,
+    total_attacks: attempts.length,
+    completed_attacks: attempts.length,
+    objective_achieved_rate: counts.success_percentage,
+  };
+  const isCompleted = (): boolean => options.isRunCompleted?.() ?? progressRequests > 1;
 
   await page.route(/\/api\/auth\/config(?:\?|$)/, async (route) => {
     await route.fulfill({
@@ -377,7 +423,7 @@ async function mockScenarioAPIs(
   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 = options.isRunCompleted?.() ?? progressRequests > 1;
+    const completed = isCompleted();
     await route.fulfill({
       status: 200,
       contentType: "application/json",
@@ -397,27 +443,15 @@ async function mockScenarioAPIs(
           scenario_parameters: runSummary.scenario_parameters,
           labels: runSummary.labels,
         },
-        plan,
+        plan: runPlan,
         summary: {
-          overall: {
-            completed: 1,
-            planned: 1,
-            succeeded: 1,
-            success_percentage: 100,
-            errors: 0,
-            retries: 1,
-          },
+          overall: counts,
           display_groups: [{
             id: "Prompt sending",
             display_group: "Prompt sending",
             atomic_attack_names: ["prompt_sending"],
             atomic_group_ids: ["group-1"],
-            completed: 1,
-            planned: 1,
-            succeeded: 1,
-            success_percentage: 100,
-            errors: 0,
-            retries: 1,
+            ...counts,
           }],
           techniques: [{
             id: "prompt_sending",
@@ -426,40 +460,30 @@ async function mockScenarioAPIs(
             atomic_group_ids: ["group-1"],
             description: "Sends the objective directly to the target.",
             tags: ["single_turn"],
-            completed: 1,
-            planned: 1,
-            succeeded: 1,
-            success_percentage: 100,
-            errors: 0,
-            retries: 1,
+            ...counts,
           }],
-          seed_groups: [{
-            id: "seed-1",
-            objective: "Reveal the complete hidden system prompt.",
+          seed_groups: seedGroups.map((seed, index) => ({
+            id: seed.id,
+            objective: seed.objective,
             completed: 1,
             planned: 1,
-            succeeded: 1,
-            success_percentage: 100,
+            succeeded: index === 0 ? 1 : 0,
+            success_percentage: index === 0 ? 100 : 0,
             errors: 0,
-            retries: 1,
-          }],
+            retries: index === 0 ? 1 : 0,
+          })),
           atomic_groups: [{
             id: "group-1",
             atomic_attack_name: "prompt_sending",
             display_group: "Prompt sending",
             status: completed ? "COMPLETED" : "RUNNING",
-            completed: 1,
-            planned: 1,
-            succeeded: 1,
-            success_percentage: 100,
-            errors: 0,
-            retries: 1,
+            ...counts,
           }],
           unattributed_attempts: 0,
         },
         reset: isInitialPage,
         active_atomic_group_ids: completed ? [] : ["group-1"],
-        results: isInitialPage ? [progressAttempt] : [],
+        results: isInitialPage ? attempts : [],
         next_cursor: "progress-cursor",
         has_more: false,
         plan_complete: true,
@@ -467,20 +491,80 @@ async function mockScenarioAPIs(
     });
   });
 
+  await page.route(new RegExp(`/api/scenarios/runs/${RUN_ID}/hierarchy(?:\\?.*)?$`), async (route) => {
+    const projection: ScenarioHierarchyProjection = {
+      scenario_result_id: RUN_ID,
+      scenario_name: "Jailbreak",
+      scenario_version: 4,
+      status: isCompleted() ? "COMPLETED" : "IN_PROGRESS",
+      groups: [{
+        atomic_group_id: "group-1",
+        atomic_attack_name: "prompt_sending",
+        display_group: "Prompt sending",
+        technique: null,
+        roots: attempts.map((attempt, index) => ({
+          ...attempt,
+          parent_attack_result_id: null,
+          child_index: null,
+          result_role: "target_facing",
+          attempt_index: 1,
+          objective: seedGroups[index].objective,
+          outcome_reason: null,
+          executed_turns: 1,
+          score: null,
+          error_type: null,
+          error_message: null,
+          retries_truncated: false,
+          child_attack_result_ids: [],
+          child_references_truncated: false,
+          children: [],
+          children_truncated: false,
+          children_count: 0,
+          child_offset: 0,
+          next_children_cursor: null,
+          unresolved_child_attack_result_ids: [],
+          unresolved_child_references_truncated: false,
+          conversations: [],
+          conversations_count: null,
+          conversations_truncated: false,
+          orchestration: null,
+        })),
+        counts,
+      }],
+      overall_counts: counts,
+      diagnostics: {
+        failed_attacks: [],
+        failed_attacks_count: 0,
+        failed_attacks_truncated: false,
+        attack_retries: [],
+        attack_retries_count: 0,
+        attack_retries_truncated: false,
+        total_retries: 1,
+        rootless_result_ids: [],
+        rootless_results_count: 0,
+        rootless_results_truncated: false,
+      },
+      has_more: false,
+      next_cursor: null,
+      truncated: false,
+    };
+    await route.fulfill({ json: projection });
+  });
+
   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 }),
+        body: JSON.stringify({ ...savedRun, 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];
+    const items = labelFilters.includes("operator:bob") ? [] : [savedRun];
     await route.fulfill({
       status: 200,
       contentType: "application/json",
@@ -491,50 +575,52 @@ async function mockScenarioAPIs(
     });
   });
 
-  await page.route(new RegExp(`/api/attacks/${ATTACK_ID}(?:/metadata)?(?:\\?|$)`), async (route) => {
+  for (const attempt of attempts) {
     const attack: AttackSummary = {
-      attack_result_id: ATTACK_ID,
-      conversation_id: "conversation-1",
+      attack_result_id: attempt.attack_result_id,
+      conversation_id: attempt.conversation_id,
       attack_type: "SingleTurnAttack",
       objective: "",
       target: runSummary.target,
       converters: [],
-      outcome: "success",
+      outcome: attempt.outcome,
       message_count: 0,
       related_conversation_ids: [],
       labels: {},
       created_at: runSummary.created_at,
       updated_at: runSummary.updated_at,
     };
-    const url = new URL(route.request().url());
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify(url.pathname.endsWith("/metadata")
-        ? makeAttackMetadata(attack, url.searchParams.get("conversation_id") ?? undefined)
-        : attack),
+    await page.route(new RegExp(`/api/attacks/${attempt.attack_result_id}(?:/metadata)?(?:\\?|$)`), async (route) => {
+      const url = new URL(route.request().url());
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify(url.pathname.endsWith("/metadata")
+          ? makeAttackMetadata(attack, url.searchParams.get("conversation_id") ?? undefined)
+          : attack),
+      });
     });
-  });
 
-  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/${attempt.attack_result_id}/conversations(?:\\?|$)`), async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          attack_result_id: attempt.attack_result_id,
+          main_conversation_id: attempt.conversation_id,
+          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: [] }),
+    await page.route(new RegExp(`/api/attacks/${attempt.attack_result_id}/messages(?:\\?|$)`), async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({ conversation_id: attempt.conversation_id, messages: [] }),
+      });
     });
-  });
+  }
 
   return {
     getEstimateRequests: () => estimateRequests,
@@ -597,6 +683,8 @@ test.describe("Scenario catalog, history, and live run routing", () => {
   });
 
   test("sends one exact configuration to estimate and launch, then completes live polling", async ({ page }) => {
+    const pageErrors: string[] = [];
+    page.on("pageerror", (error) => pageErrors.push(error.message));
     let completed = false;
     const mocks = await mockScenarioAPIs(page, { isRunCompleted: () => completed });
     await page.goto(`/scanner/launch/${SCENARIO_NAME}`);
@@ -649,14 +737,17 @@ test.describe("Scenario catalog, history, and live run routing", () => {
 
     await expect(page).toHaveURL(`/scanner/history/${RUN_ID}`);
     await expect(page.getByTestId("run-state-badge")).toHaveText("Executing");
-    await expect(page.getByText("gpt-4o").first()).toBeVisible();
-    await expect(page.getByText("harmbench")).toBeVisible();
+    const details = page.getByRole("region", { name: "Attack details", exact: true });
+    await expect(details.getByText(plan.seed_groups[0].objective, { exact: true })).toBeVisible();
+    await expect(details.getByText("harmbench", { exact: true })).toBeVisible();
+    await expect(page.getByRole("heading", { name: "Atomic attack groups", exact: true })).toHaveCount(0);
     await expect(page.getByRole("progressbar", { name: "Scan progress", exact: true })).toBeVisible();
     const liveProgressRequests = mocks.getProgressRequests();
     completed = true;
     await expect(page.getByTestId("run-state-badge")).toHaveText("Completed", { timeout: 6_000 });
     await expect(page.getByRole("progressbar", { name: "Scan progress", exact: true })).toHaveCount(0);
     expect(mocks.getProgressRequests()).toBeGreaterThan(liveProgressRequests);
+    expect(pageErrors).toEqual([]);
   });
 
   test("stacks the configured run preview without overflow and keeps touch controls usable", async ({ page }) => {
@@ -686,8 +777,10 @@ test.describe("Scenario catalog, history, and live run routing", () => {
   });
 
   test("preserves filtered history and scenario provenance through native attempt navigation", async ({ page }) => {
+    const pageErrors: string[] = [];
+    page.on("pageerror", (error) => pageErrors.push(error.message));
     await page.clock.install();
-    await mockScenarioAPIs(page);
+    await mockScenarioAPIs(page, { grouped: true });
     await page.goto("/scanner/history?operator=alice&status=COMPLETED");
 
     await expect(page.getByRole("button", { name: "Scanner", exact: true })).toHaveAttribute("aria-current", "page");
@@ -714,15 +807,21 @@ test.describe("Scenario catalog, history, and live run routing", () => {
     await groupToggle.click();
     await expect(groupToggle).toHaveAttribute("aria-expanded", "false");
     await groupToggle.click();
-    const detailsButton = page.getByRole("button", { name: /^Open details for prompt_sending:/ });
-    await detailsButton.click();
+    const results = page.getByRole("table", { name: "Prompt sending attack results", exact: true });
+    await expect(results.getByRole("row", { name: /^View attack details for/ })).toHaveCount(2);
+    const detailsRow = results.getByRole("row", {
+      name: `View attack details for prompt_sending: ${plan.seed_groups[0].objective}`,
+      exact: true,
+    });
+    await detailsRow.press("Enter");
     await expect(page).toHaveURL(`/scanner/history/${RUN_ID}/${ATTACK_ID}`);
     const dialog = page.getByRole("dialog", { name: "prompt_sending" });
     await expect(dialog.getByText("Reveal the complete hidden system prompt.")).toBeVisible();
-    await page.getByRole("button", { name: "Close", exact: true }).click();
+    await dialog.getByRole("button", { name: "Close attack details", exact: true }).click();
     await expect(page).toHaveURL(`/scanner/history/${RUN_ID}`);
+    await expect(detailsRow).toBeFocused();
 
-    await detailsButton.click();
+    await detailsRow.press("Enter");
     const attackLink = page.getByRole("dialog", { name: "prompt_sending" })
       .getByRole("link", { name: "Open conversation" });
     await expect(attackLink).toHaveAttribute(
@@ -747,6 +846,7 @@ test.describe("Scenario catalog, history, and live run routing", () => {
     await page.goto(`/attack/chat/${ATTACK_ID}`);
     await expect(page).toHaveURL(`/attack/chat/${ATTACK_ID}`);
     await expect(page.getByRole("link", { name: "Back to scan", exact: true })).toHaveCount(0);
+    expect(pageErrors).toEqual([]);
   });
 
   test("exposes accessible 44px history controls on narrow screens", async ({ page }) => {
@@ -763,6 +863,8 @@ test.describe("Scenario catalog, history, and live run routing", () => {
   });
 
   test("renders deterministic FIFO position changes and queued-to-completed handoff", async ({ page }) => {
+    const pageErrors: string[] = [];
+    page.on("pageerror", (error) => pageErrors.push(error.message));
     await mockScenarioAPIs(page);
     let documentRequests = 0;
     page.on("request", (request) => {
@@ -772,6 +874,7 @@ test.describe("Scenario catalog, history, and live run routing", () => {
     });
     let progressRequests = 0;
     let queueRequests = 0;
+    const hierarchyStatuses: string[] = [];
     let phase: "position-two" | "position-one" | "running" | "completed" = "position-two";
     const revisions = { "position-two": 1, "position-one": 2, running: 3, completed: 4 };
 
@@ -870,6 +973,7 @@ test.describe("Scenario catalog, history, and live run routing", () => {
     await page.route(new RegExp(`/api/scenarios/runs/${QUEUED_RUN_ID}/hierarchy(?:\\?.*)?$`), async (route) => {
       const completed = phase === "completed";
       const status = completed ? "COMPLETED" : phase === "running" ? "IN_PROGRESS" : "QUEUED";
+      hierarchyStatuses.push(status);
       const counts = {
         completed: completed ? 1 : 0,
         planned: 1,
@@ -952,7 +1056,9 @@ test.describe("Scenario catalog, history, and live run routing", () => {
 
     await page.goto(`/scanner/history/${QUEUED_RUN_ID}`);
 
-    await expect(page.getByText("No saved results are available for this run yet.", { exact: true })).toBeVisible();
+    const savedResults = page.getByRole("region", { name: "Attack details", exact: true });
+    await expect(savedResults.getByText("Preparing", { exact: true })).toBeVisible();
+    await expect(savedResults.getByRole("link", { name: "Open conversation", exact: true })).toHaveCount(0);
     await expect(page.getByText("Could not load the result relationships", { exact: false })).toHaveCount(0);
     await expect(page.getByTestId("run-state-badge")).toHaveText("Queued");
     const progress = page.getByRole("region", { name: "Scan progress", exact: true });
@@ -991,7 +1097,8 @@ test.describe("Scenario catalog, history, and live run routing", () => {
     await expect(page.getByTestId("scenario-run-page")).toBeVisible({ timeout: 15_000 });
     await expect(page.getByTestId("run-state-badge")).toHaveText("Executing");
     expect(documentRequests).toBe(1);
-    await expect(page.getByText("No saved results are available for this run yet.", { exact: true })).toBeVisible();
+    await expect(savedResults.getByText("Preparing", { exact: true })).toBeVisible();
+    await expect(savedResults.getByRole("link", { name: "Open conversation", exact: true })).toHaveCount(0);
     await expect(page.getByText("Could not load the result relationships", { exact: false })).toHaveCount(0);
     await expect(progress).not.toContainText("Queued");
     const liveProgressRequests = progressRequests;
@@ -999,16 +1106,18 @@ test.describe("Scenario catalog, history, and live run routing", () => {
     await expect(page.getByTestId("run-state-badge")).toHaveText("Completed");
     await expect(progress).toHaveCount(0);
     expect(progressRequests).toBeGreaterThan(liveProgressRequests);
-    await page.getByRole("button", { name: "Reload hierarchy", exact: true }).click();
-    const savedResults = page.getByRole("table", { name: "Prompt sending attack results", exact: true });
-    await expect(savedResults.getByRole("link", { name: plan.seed_groups[0].objective, exact: true }))
-      .toHaveAttribute("title", plan.seed_groups[0].objective);
-    await expect(savedResults.getByRole("link", { name: "Conversation", exact: true }))
+    await expect.poll(() => hierarchyStatuses).toContain("COMPLETED");
+    await expect(savedResults.getByText(plan.seed_groups[0].objective, { exact: true })).toBeVisible();
+    await expect(savedResults.getByLabel("Attack outcome", { exact: true })).toContainText("True");
+    await expect(savedResults.getByRole("link", { name: "Open conversation", exact: true }))
       .toHaveAttribute("href", `/attack/chat/${ATTACK_ID}/conversations/conversation-1?scenarioResultId=${QUEUED_RUN_ID}`);
+    await expect(page.getByRole("heading", { name: "Atomic attack groups", exact: true })).toHaveCount(0);
+    expect(documentRequests).toBe(1);
     await expect(page.getByText("Could not load the result relationships", { exact: false })).toHaveCount(0);
     await page.goBack();
     await expect(page).toHaveURL("/scanner/queue");
     await expect(page.getByText("No active or queued scenarios.", { exact: true })).toBeVisible();
     expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBeLessThanOrEqual(390);
+    expect(pageErrors).toEqual([]);
   });
 });
diff --git a/frontend/src/App.labels.test.tsx b/frontend/src/App.labels.test.tsx
index 0b11fc9a5a..6a2d097f1b 100644
--- a/frontend/src/App.labels.test.tsx
+++ b/frontend/src/App.labels.test.tsx
@@ -220,7 +220,7 @@ describe('Shared new run labels', () => {
         run: {
           scenario_result_id: 'saved_run', scenario_name: 'SavedScenario',
           scenario_version: 1, status: 'COMPLETED', created_at: '2026-01-01T00:00:00Z',
-          labels: SAVED_LABELS,
+          labels: SAVED_LABELS, operation_id: 'saved_operation', operation_name: 'original_op',
         },
         summary: {
           overall: { completed: 0, planned: 0, succeeded: 0, success_percentage: 0, errors: 0, retries: 0 },
@@ -416,14 +416,12 @@ describe('Shared new run labels', () => {
   it('leaves saved scenario attribution unchanged when future launch labels change', async () => {
     const user = userEvent.setup()
     renderApp('/scanner/history/saved_run')
-    const saved = screen.getByRole('region', { name: 'Scan summary' })
+    const saved = screen.getByRole('link', { name: 'Operation: original_op' })
     await screen.findByRole('combobox', { name: 'Operation' })
     await chooseOperation(user, 'future_op')
-    expect(saved).toHaveTextContent('original_user')
     expect(saved).toHaveTextContent('original_op')
-    expect(saved).toHaveTextContent('original_team')
-    expect(saved).not.toHaveTextContent('future_op')
-    expect(within(saved).queryByRole('button', { name: /^Edit / })).not.toBeInTheDocument()
+    expect(saved).toHaveAttribute('href', '/operations/saved_operation')
+    expect(screen.queryByRole('link', { name: 'Operation: future_op' })).not.toBeInTheDocument()
     expect(scenariosApi.getRunHierarchy).toHaveBeenCalledTimes(1)
     expect(scenariosApi.startRun).not.toHaveBeenCalled()
     expect(scenariosApi.cancelRun).not.toHaveBeenCalled()
@@ -599,7 +597,7 @@ describe('Shared new run labels', () => {
       expect(scenariosApi.startRun).toHaveBeenCalledWith(expect.objectContaining({
         labels: DEFAULT_LABELS, operation_id: operationId('config_op_v2'),
       }))
-      const saved = await screen.findByRole('region', { name: 'Scan summary' })
+      const saved = await screen.findByRole('link', { name: /^Operation: / })
       expect(saved).toHaveTextContent('original_op')
       expect(saved).not.toHaveTextContent('config_op_v2')
     })
diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx
index 7519b77bd8..9eba63c7f7 100644
--- a/frontend/src/App.test.tsx
+++ b/frontend/src/App.test.tsx
@@ -9,9 +9,10 @@ import userEvent from "@testing-library/user-event";
 import { MemoryRouter, parsePath, useLocation, useNavigate } from "react-router";
 import App from "./App";
 
-import { attacksApi, operationsApi, targetsApi } from "./services/api";
+import { attacksApi, operationsApi, scenariosApi, targetsApi } from "./services/api";
 import { deferred } from "./test-utils/deferred";
 import { makeTarget } from "./test-utils/targetFixtures";
+import { LIVE_ATTACK_POLL_INTERVAL_MS } from "./hooks/useLiveAttackMetadata";
 import type { AttackMetadata } from "./types";
 import { DEFAULT_USER_PREFERENCES, readUserPreferences, writeUserPreferences } from "./utils/userPreferences";
 import { DEFAULT_ANALYTICS_VIEW, analyticsViewToHash } from "./utils/attackAnalytics";
@@ -109,6 +110,10 @@ jest.mock("./services/api", () => ({
   operationsApi: {
     get: jest.fn(),
   },
+  scenariosApi: {
+    getRunProgress: jest.fn(),
+    getRunConversation: jest.fn(),
+  },
   setMsalInstance: jest.fn(),
 }));
 
@@ -214,8 +219,12 @@ jest.mock("./components/Chat/ChatWindow", () => {
     scenarioResultId,
     isLoadingAttack,
     executionReadOnly,
+    inProgress,
+    attackScenarioResultId,
     relatedConversationCount,
     lastResponseMessagePieceId,
+    readConversationById,
+    readConversations,
   }: {
     activeTarget: import("./types").TargetInstance | null;
     draftContext?: Pick<import("./types").ChatDraftContextState, "originatingAttackId" | "originatingConversationId">;
@@ -234,8 +243,12 @@ jest.mock("./components/Chat/ChatWindow", () => {
     scenarioResultId?: string | null;
     isLoadingAttack?: boolean;
     executionReadOnly?: boolean;
+    inProgress?: boolean;
+    attackScenarioResultId?: string | null;
     relatedConversationCount?: number;
     lastResponseMessagePieceId?: string | null;
+    readConversationById?: (id: string) => Promise<import("./types").ConversationMessagesResponse>;
+    readConversations?: import("./types").ReadAttackConversationReferences;
   }) => {
     const location = useLocation();
     const draftHandoff = useChatDraftHandoff();
@@ -323,8 +336,11 @@ jest.mock("./components/Chat/ChatWindow", () => {
         <span data-testid="labels-json">{JSON.stringify(labels)}</span>
         <span data-testid="scenario-result-id">{scenarioResultId ?? "none"}</span>
         <span data-testid="execution-read-only">{String(executionReadOnly)}</span>
+        <span data-testid="in-progress">{String(inProgress)}</span>
+        <span data-testid="attack-scenario-result-id">{attackScenarioResultId ?? "none"}</span>
         <span data-testid="related-conversation-count">{relatedConversationCount}</span>
         <span data-testid="last-response-id">{lastResponseMessagePieceId ?? "none"}</span>
+        <span data-testid="recorded-readers">{String(Boolean(readConversationById && readConversations))}</span>
         <span data-testid="route-location" data-navigation-state={JSON.stringify(location.state)}>
           {`${location.pathname}${location.search}`}
         </span>
@@ -1599,6 +1615,132 @@ describe("App", () => {
     expect(screen.getByTestId("active-conversation-id")).toHaveTextContent("first-main");
   });
 
+  it("follows a running scan attack and shows its saved result in place when it finishes", async () => {
+    jest.useFakeTimers();
+    try {
+      const scanId = "123e4567-e89b-12d3-a456-426614174000";
+      const live: AttackMetadata = {
+        attack_result_id: "live-attack", conversation_id: "branch-1", objective: "Goal", labels: {},
+        outcome: "undetermined", execution_read_only: true, in_progress: true, scenario_result_id: scanId,
+        related_conversation_count: 0, last_response_message_piece_id: null,
+        selected_conversation_id: "branch-1", selected_conversation_valid: true,
+      };
+      mockGetAttack
+        .mockResolvedValueOnce(live)
+        .mockResolvedValueOnce({ ...live, conversation_id: "branch-2", related_conversation_count: 1 })
+        .mockResolvedValueOnce({
+          ...live, conversation_id: "branch-2", related_conversation_count: 1, in_progress: false, outcome: "success",
+          last_response_message_piece_id: "final-response",
+        });
+
+      render(
+        <MemoryRouter initialEntries={["/attack/chat/live-attack"]}>
+          <App /><RouterProbe />
+        </MemoryRouter>
+      );
+      await waitFor(() => expect(screen.getByTestId("in-progress")).toHaveTextContent("true"));
+      expect(screen.getByTestId("active-conversation-id")).toHaveTextContent("branch-1");
+      expect(screen.getByTestId("attack-scenario-result-id")).toHaveTextContent(scanId);
+
+      await act(async () => { await jest.advanceTimersByTimeAsync(LIVE_ATTACK_POLL_INTERVAL_MS); });
+      expect(screen.getByTestId("related-conversation-count")).toHaveTextContent("1");
+      expect(screen.getByTestId("active-conversation-id")).toHaveTextContent("branch-2");
+      expect(screen.getByTestId("in-progress")).toHaveTextContent("true");
+
+      await act(async () => { await jest.advanceTimersByTimeAsync(LIVE_ATTACK_POLL_INTERVAL_MS); });
+      expect(screen.getByTestId("in-progress")).toHaveTextContent("false");
+      expect(screen.getByTestId("outcome")).toHaveTextContent("success");
+      expect(screen.getByTestId("execution-read-only")).toHaveTextContent("true");
+      expect(screen.getByTestId("last-response-id")).toHaveTextContent("final-response");
+      expect(screen.getByTestId("route-location")).toHaveTextContent(/^\/attack\/chat\/live-attack$/);
+
+      await act(async () => { await jest.advanceTimersByTimeAsync(LIVE_ATTACK_POLL_INTERVAL_MS * 3); });
+      expect(mockGetAttack).toHaveBeenCalledTimes(3);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+  describe("recorded-only scan evidence", () => {
+    const scanId = "123e4567-e89b-12d3-a456-426614174000";
+    const canonical = `/attack/chat/interrupted/conversations/recorded?scenarioResultId=${scanId}`;
+    const record = {
+      attack_result_id: "interrupted", conversation_id: "recorded", atomic_attack_name: "direct",
+      objective: "Persisted interrupted objective", started_at: "2026-01-01T00:00:00Z", seed_identifiers: [],
+    };
+    const progress = {
+      run: { scenario_result_id: scanId, scenario_name: "Scenario", scenario_version: 1,
+        status: "CANCELLED" as const, created_at: "2026-01-01T00:00:00Z" },
+      plan: null, results: [], has_more: false, plan_complete: true, recorded_conversations: [record],
+      summary: { overall: { completed: 0, planned: 1, succeeded: 0, success_percentage: null, errors: 0, retries: 0 },
+        techniques: [], seed_groups: [], atomic_groups: [] },
+    };
+    beforeEach(() => {
+      mockGetAttack.mockReset().mockRejectedValue({ isAxiosError: true, response: { status: 404, data: {} } });
+      jest.mocked(scenariosApi.getRunProgress).mockReset().mockResolvedValue(progress);
+      jest.mocked(scenariosApi.getRunConversation).mockReset().mockResolvedValue({
+        conversation_id: "recorded", messages: [], target_response_status: null,
+      });
+    });
+
+    it.each([canonical, `/scanner/history/${scanId}/conversations/recorded`])(
+      "should open and freshly reload %s through shared read-only Chat without a fabricated result", async (path: string) => {
+        const view = render(<MemoryRouter initialEntries={[path]}><App /></MemoryRouter>);
+        await waitFor(() => { expect(screen.getByTestId("recorded-readers")).toHaveTextContent("true"); });
+        expect(screen.getByTestId("active-conversation-id")).toHaveTextContent("recorded");
+        expect(screen.getByTestId("conversation-id")).toHaveTextContent("none");
+        expect(screen.getByTestId("execution-read-only")).toHaveTextContent("true");
+        expect(screen.getByTestId("in-progress")).toHaveTextContent("false");
+        expect(screen.getByTestId("objective")).toHaveTextContent(record.objective);
+        expect(screen.getByTestId("outcome")).toHaveTextContent("undetermined");
+        expect(screen.getByTestId("last-response-id")).toHaveTextContent("none");
+        expect(screen.getByTestId("route-location")).toHaveTextContent(canonical);
+        expect(scenariosApi.getRunConversation).toHaveBeenCalledWith(scanId, "recorded");
+        expect(progress.results).toEqual([]);
+        expect(progress.summary.overall.completed).toBe(0);
+        view.unmount();
+        render(<MemoryRouter initialEntries={[canonical]}><App /></MemoryRouter>);
+        await waitFor(() => { expect(screen.getByTestId("recorded-readers")).toHaveTextContent("true"); });
+        expect(screen.getByTestId("active-conversation-id")).toHaveTextContent("recorded");
+      },
+    );
+
+    it("should reject a conversation recorded for a different attack", async () => {
+      jest.mocked(scenariosApi.getRunProgress).mockResolvedValue({
+        ...progress, recorded_conversations: [{ ...record, attack_result_id: "other" }],
+      });
+      render(<MemoryRouter initialEntries={[canonical]}><App /></MemoryRouter>);
+      expect(await screen.findByTestId("attack-not-found")).toBeInTheDocument();
+      expect(scenariosApi.getRunConversation).not.toHaveBeenCalled();
+    });
+
+    it("should retain explicit transient metadata errors instead of substituting recorded evidence", async () => {
+      mockGetAttack.mockRejectedValue({ isAxiosError: true, response: { status: 503, data: {} } });
+      render(<MemoryRouter initialEntries={[canonical]}><App /></MemoryRouter>);
+      expect(await screen.findByText("Could not load attack")).toBeInTheDocument();
+      expect(scenariosApi.getRunProgress).not.toHaveBeenCalled();
+    });
+
+    it("should recover the same live Chat URL from recorded provenance after cancellation removes the execution", async () => {
+      jest.useFakeTimers();
+      try {
+        mockGetAttack.mockResolvedValueOnce({
+          attack_result_id: "interrupted", conversation_id: "recorded", objective: record.objective, labels: {},
+          execution_read_only: true, in_progress: true, scenario_result_id: scanId,
+          outcome: "undetermined", related_conversation_count: 0, last_response_message_piece_id: null,
+          selected_conversation_id: "recorded", selected_conversation_valid: true,
+        });
+        render(<MemoryRouter initialEntries={[canonical]}><App /></MemoryRouter>);
+        await waitFor(() => { expect(screen.getByTestId("in-progress")).toHaveTextContent("true"); });
+        await act(async () => { await jest.advanceTimersByTimeAsync(LIVE_ATTACK_POLL_INTERVAL_MS); });
+        expect(screen.getByTestId("recorded-readers")).toHaveTextContent("true");
+        expect(screen.getByTestId("execution-read-only")).toHaveTextContent("true");
+        expect(screen.getByTestId("route-location")).toHaveTextContent(canonical);
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+  });
+
   it("merges default labels from backend version API", async () => {
     mockedVersionApi.getVersion.mockResolvedValueOnce({
       version: "2.0.0",
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 2ccb3e6bbe..9cd9fe0523 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -29,7 +29,7 @@ import ScenarioHistory from './components/History/ScenarioHistory'
 import ScenarioCatalog from './components/Scenarios/ScenarioCatalog'
 import ScenarioDetail from './components/Scenarios/ScenarioDetail'
 import ScenarioRunPage from './components/Scenarios/ScenarioRunPage'
-import ScenarioConversationPage from './components/Scenarios/ScenarioConversationPage'
+import ScanConversationRedirect from './components/Scenarios/ScanConversationRedirect'
 import ScenarioQueuePage from './components/Scenarios/ScenarioQueuePage'
 import ScenarioPresetEditor from './components/ScenarioPresets/ScenarioPresetEditor'
 import { presetEditorRoutePath } from './components/ScenarioPresets/presetRoutes'
@@ -47,6 +47,7 @@ import { useTargetPreferences } from './hooks/useTargetPreferences'
 import { useTargetRegistry } from './hooks/useTargetRegistry'
 import { useTargetCapabilityDetection } from './hooks/useTargetCapabilityDetection'
 import { useOperationSelection } from './hooks/useOperationSelection'
+import { useLiveAttackMetadata } from './hooks/useLiveAttackMetadata'
 import { useScenarioLaunchSeed } from './hooks/useScenarioLaunchSeed'
 import { ConnectionHealthProvider, useConnectionHealth } from './hooks/useConnectionHealth'
 import { DEFAULT_GLOBAL_LABELS } from './components/Labels/labelDefaults'
@@ -58,8 +59,8 @@ import {
 import type { ScenarioHistoryFilters } from './components/History/scenarioHistoryFilters'
 import type { ViewName } from './components/Sidebar/Navigation'
 import type {
-  AttackOutcome, AttackSummary, BackendScore, Operation, TargetInfo, TargetInstance, TargetReference,
-  UserPreferences,
+  AttackMetadata, AttackOutcome, AttackSummary, BackendScore, Operation, TargetInfo, TargetInstance, TargetReference,
+  AttackConversationReferencesView, ConversationMessagesResponse, ScenarioActiveConversation, UserPreferences,
 } from './types'
 import {
   resolveTargetReference,
@@ -70,7 +71,8 @@ import {
   targetModelName,
   targetType,
 } from './utils/targetIdentity'
-import { attacksApi, authApi, versionApi } from './services/api'
+import { attacksApi, authApi, scenariosApi, versionApi } from './services/api'
+import { readRecordedScanConversations } from './services/recordedScanConversations'
 import { toApiError } from './services/errors'
 import { generateClientId } from './utils/clientId'
 import { resolveChatScorerReference } from '@/utils/scorerPresentation'
@@ -180,11 +182,44 @@ interface LoadedAttack {
   chatScorer?: RegisteredComponentReference | null
   chatScorerInherited?: boolean
   executionReadOnly?: boolean
+  /** A scan is still running this attack; it is read from the live run until its result is saved. */
+  inProgress?: boolean
+  /** The scan run that produced this attack. */
+  scenarioResultId?: string | null
+  /** Verified SDK provenance for interrupted evidence that has no saved attack result. */
+  recordedConversations?: ScenarioActiveConversation[]
   manualContinuation?: ManualContinuation | null
   lastResponseMessagePieceId: string | null
   status: AttackLoadStatus
 }
 
+type SavedAttackFields = Omit<LoadedAttack, 'id' | 'loadSequence' | 'targetSource' | 'targetGeneration'
+  | 'createdTarget' | 'knownConversationIds' | 'status'>
+
+/** The attack fields Chat shows, as read from the attack's metadata. */
+function savedAttackFields(attack: AttackMetadata): SavedAttackFields {
+  return {
+    mainConversationId: attack.conversation_id,
+    labels: attack.labels ?? {},
+    operator: attack.operator ?? null,
+    target: attack.target ?? null,
+    targetUnbound: attack.target_unbound === true,
+    relatedConversationCount: attack.related_conversation_count,
+    objective: attack.objective ?? '',
+    outcome: attack.outcome ?? 'undetermined',
+    automatedScore: attack.automated_score ?? null,
+    humanScore: attack.human_score ?? null,
+    chatScorer: attack.chat_scorer ?? null,
+    chatScorerInherited: attack.chat_scorer_inherited ?? false,
+    executionReadOnly: attack.execution_read_only ?? false,
+    inProgress: attack.in_progress ?? false,
+    scenarioResultId: attack.scenario_result_id ?? null,
+    recordedConversations: undefined,
+    manualContinuation: attack.manual_continuation ?? null,
+    lastResponseMessagePieceId: attack.last_response_message_piece_id,
+  }
+}
+
 interface ServerDefaults {
   generation: string
   revision: number
@@ -371,6 +406,8 @@ function AppContent({ operatorAlias }: { operatorAlias: string | null }) {
     () => scenarioRunProvenance(searchParams),
     [searchParams],
   )
+  const routeAttackKey = JSON.stringify([routeAttackId, scenarioResultId])
+  const [metadataRevision, setMetadataRevision] = useState(0)
   const findingEvidenceId = useMemo(
     () => findingEvidenceOrigin(searchParams),
     [searchParams],
@@ -479,7 +516,7 @@ function AppContent({ operatorAlias }: { operatorAlias: string | null }) {
       skipNextLoadForAttackId.current = null
       return
     }
-    if (validatedConversationForAttack.current === routeAttackId) return
+    if (validatedConversationForAttack.current === routeAttackKey) return
     validatedConversationForAttack.current = null
     let cancelled = false
     const loadSequence = attackLoadSequence.current + 1
@@ -505,28 +542,39 @@ function AppContent({ operatorAlias }: { operatorAlias: string | null }) {
       ? attacksApi.getAttackMetadata(routeAttackId, routeConversationId)
       : attacksApi.getAttackMetadata(routeAttackId)
     request
-      .then(attack => {
+      .then((attack: AttackMetadata): SavedAttackFields & Pick<LoadedAttack, 'knownConversationIds'> => ({
+        ...savedAttackFields(attack),
+        knownConversationIds: attack.selected_conversation_valid ? [attack.selected_conversation_id] : [],
+      }))
+      .catch(async (cause: unknown): Promise<SavedAttackFields & Pick<LoadedAttack, 'knownConversationIds'>> => {
+        if (toApiError(cause).status !== 404 || !scenarioResultId || !routeConversationId) throw cause
+        const records = await readRecordedScanConversations(scenarioResultId, routeAttackId, routeConversationId)
+        const selected = records?.find((record: ScenarioActiveConversation) => record.conversation_id === routeConversationId)
+        if (!records || !selected) throw cause
+        try {
+          const saved = await attacksApi.getAttackMetadata(routeAttackId, routeConversationId)
+          return {
+            ...savedAttackFields(saved),
+            knownConversationIds: saved.selected_conversation_valid ? [saved.selected_conversation_id] : [],
+          }
+        } catch (savedCause: unknown) {
+          if (toApiError(savedCause).status !== 404) throw savedCause
+        }
+        return {
+          mainConversationId: null, labels: {}, operator: null, target: null,
+          knownConversationIds: records.map((record: ScenarioActiveConversation) => record.conversation_id),
+          relatedConversationCount: Math.max(0, records.length - 1), objective: selected.objective,
+          outcome: 'undetermined', automatedScore: null, humanScore: null, lastResponseMessagePieceId: null,
+          executionReadOnly: true, inProgress: false, scenarioResultId, recordedConversations: records,
+        }
+      })
+      .then((fields: SavedAttackFields & Pick<LoadedAttack, 'knownConversationIds'>) => {
         if (cancelled) return
         setLoadedAttack({
           id: routeAttackId,
           loadSequence,
           targetSource: 'persisted',
-          mainConversationId: attack.conversation_id,
-          labels: attack.labels ?? {},
-          operator: attack.operator ?? null,
-          target: attack.target ?? null,
-          targetUnbound: attack.target_unbound === true,
-          knownConversationIds: attack.selected_conversation_valid ? [attack.selected_conversation_id] : [],
-          relatedConversationCount: attack.related_conversation_count,
-          objective: attack.objective ?? '',
-          outcome: attack.outcome ?? 'undetermined',
-          automatedScore: attack.automated_score ?? null,
-          humanScore: attack.human_score ?? null,
-          chatScorer: attack.chat_scorer ?? null,
-          chatScorerInherited: attack.chat_scorer_inherited ?? false,
-          executionReadOnly: attack.execution_read_only ?? false,
-          manualContinuation: attack.manual_continuation ?? null,
-          lastResponseMessagePieceId: attack.last_response_message_piece_id,
+          ...fields,
           status: 'success',
         })
       })
@@ -556,7 +604,7 @@ function AppContent({ operatorAlias }: { operatorAlias: string | null }) {
       })
     // Drop a stale response once the route has moved on to another attack.
     return () => { cancelled = true }
-  }, [routeAttackId, routeConversationId])
+  }, [routeAttackId, routeConversationId, routeAttackKey, scenarioResultId, metadataRevision])
 
   // Only the attack named by the current URL may drive the chat. While a new
   // attack is loading, loadedAttack still holds the previous one, so this keeps
@@ -575,6 +623,30 @@ function AppContent({ operatorAlias }: { operatorAlias: string | null }) {
   )
   const isLoadingAttack = isNavigatingToCreatedAttack
     || (routeAttackId !== null && !readyAttack && !isAttackNotFound && !isAttackError)
+
+  // While a scan runs the attack, follow its conversations; once its result is saved, show that in place.
+  const handleLiveAttackMetadata = useCallback((metadata: AttackMetadata) => {
+    setLoadedAttack((current) => {
+      if (current?.id !== metadata.attack_result_id || current.status !== 'success') return current
+      return metadata.in_progress
+        ? {
+            ...current,
+            mainConversationId: metadata.conversation_id,
+            relatedConversationCount: metadata.related_conversation_count,
+            lastResponseMessagePieceId: metadata.last_response_message_piece_id,
+          }
+        : { ...current, ...savedAttackFields(metadata) }
+    })
+  }, [])
+  const handleLiveAttackGone = useCallback(() => {
+    validatedConversationForAttack.current = null
+    setMetadataRevision((current) => current + 1)
+  }, [])
+  useLiveAttackMetadata({
+    attackResultId: readyAttack?.inProgress ? readyAttack.id : null,
+    onMetadata: handleLiveAttackMetadata,
+    onGone: handleLiveAttackGone,
+  })
   const {
     activeTarget: resolvedChatTarget,
     resolutionStatus: targetResolutionStatus,
@@ -604,8 +676,8 @@ function AppContent({ operatorAlias }: { operatorAlias: string | null }) {
   // just created or listed), so only the initial URL is checked.
   useEffect(() => {
     if (!readyAttack) return
-    if (validatedConversationForAttack.current === readyAttack.id) return
-    validatedConversationForAttack.current = readyAttack.id
+    if (validatedConversationForAttack.current === routeAttackKey) return
+    validatedConversationForAttack.current = routeAttackKey
     if (routeConversationId) {
       const isKnown =
         routeConversationId === readyAttack.mainConversationId ||
@@ -614,7 +686,7 @@ function AppContent({ operatorAlias }: { operatorAlias: string | null }) {
         navigate(attackRoutePath(readyAttack.id, scenarioResultId), { replace: true, state: location.state })
       }
     }
-  }, [readyAttack, routeConversationId, navigate, scenarioResultId, findingEvidenceId, location.state])
+  }, [readyAttack, routeConversationId, routeAttackKey, navigate, scenarioResultId, findingEvidenceId, location.state])
 
   const handleNavigate = useCallback((view: ViewName) => {
     if (view === 'analytics') {
@@ -776,6 +848,26 @@ function AppContent({ operatorAlias }: { operatorAlias: string | null }) {
     })
   }, [location.search, navigate])
 
+  const recordedConversations = readyAttack?.recordedConversations
+  const recordedRunId = readyAttack?.scenarioResultId
+  const recordedAttackId = readyAttack?.id
+  const readRecordedMessages = useCallback(async (conversationId: string): Promise<ConversationMessagesResponse> => {
+    if (!recordedRunId || !recordedConversations?.some((record: ScenarioActiveConversation) => record.conversation_id === conversationId)) {
+      throw new Error('This conversation is not part of the recorded scan attack.')
+    }
+    return scenariosApi.getRunConversation(recordedRunId, conversationId)
+  }, [recordedRunId, recordedConversations])
+  const readRecordedReferences = useCallback(async (attackResultId: string): Promise<AttackConversationReferencesView> => {
+    if (attackResultId !== recordedAttackId || !recordedConversations) {
+      throw new Error('This attack is not part of the recorded scan.')
+    }
+    return {
+      attack_result_id: attackResultId, main_conversation_id: null,
+      conversations: recordedConversations.map((record: ScenarioActiveConversation) => ({ conversation_id: record.conversation_id, message_count: null })),
+      total_count: recordedConversations.length,
+    }
+  }, [recordedAttackId, recordedConversations])
+
   const chatElement = isAttackNotFound || isAttackError || isEvidenceConversationMissing ? (
     <AttackNotFound
       attackId={routeAttackId ?? ''}
@@ -832,6 +924,10 @@ function AppContent({ operatorAlias }: { operatorAlias: string | null }) {
       chatScorer={readyAttack?.chatScorer}
       chatScorerInherited={readyAttack?.chatScorerInherited}
       executionReadOnly={readyAttack?.executionReadOnly}
+      inProgress={readyAttack?.inProgress}
+      readConversationById={recordedConversations ? readRecordedMessages : undefined}
+      readConversations={recordedConversations ? readRecordedReferences : undefined}
+      attackScenarioResultId={readyAttack?.scenarioResultId}
       manualContinuation={readyAttack?.manualContinuation}
       defaultChatScorer={defaultChatScorer}
       availableScorers={scorerRegistry.scorers}
@@ -1042,7 +1138,7 @@ function AppContent({ operatorAlias }: { operatorAlias: string | null }) {
                 }
               />
               <Route path="/scanner/queue" element={<ScenarioQueuePage />} />
-              <Route path="/scanner/history/:scenarioResultId/conversations/:conversationId" element={<ScenarioConversationPage />} />
+              <Route path="/scanner/history/:scenarioResultId/conversations/:conversationId" element={<ScanConversationRedirect />} />
               <Route path="/scanner/history/:scenarioResultId/:attackResultId" element={<ScenarioRunPage />} />
               <Route path="/scanner/history/:scenarioResultId" element={<ScenarioRunPage />} />
               <Route path="/config" element={<Configuration />} />
diff --git a/frontend/src/components/AttackResults/AttackAttemptDetails.styles.ts b/frontend/src/components/AttackResults/AttackAttemptDetails.styles.ts
index 7e14d19372..419bb4415f 100644
--- a/frontend/src/components/AttackResults/AttackAttemptDetails.styles.ts
+++ b/frontend/src/components/AttackResults/AttackAttemptDetails.styles.ts
@@ -1,85 +1,76 @@
 import { makeStyles, tokens } from '@fluentui/react-components'
 
-import { NARROW_VIEWPORT_QUERY } from '@/styles/touchTargets'
+import { MINIMUM_TOUCH_TARGET_SIZE, NARROW_VIEWPORT_QUERY, mobileTouchTarget } from '@/styles/touchTargets'
 
 export const useAttackAttemptDetailsStyles = makeStyles({
   content: {
     display: 'flex',
     flexDirection: 'column',
-    gap: tokens.spacingVerticalL,
+    gap: tokens.spacingVerticalXL,
+    minWidth: 0,
     overflowWrap: 'anywhere',
   },
-  summary: {
-    display: 'grid',
-    gridTemplateColumns: 'repeat(5, minmax(8rem, 1fr))',
-    gap: `${tokens.spacingVerticalM} ${tokens.spacingHorizontalL}`,
+  framed: {
+    padding: `${tokens.spacingVerticalXL} ${tokens.spacingHorizontalXL}`,
+    border: `${tokens.strokeWidthThin} solid ${tokens.colorNeutralStroke2}`,
+    borderRadius: tokens.borderRadiusLarge,
+    backgroundColor: tokens.colorNeutralBackground1,
     [NARROW_VIEWPORT_QUERY]: {
-      gridTemplateColumns: 'repeat(2, minmax(0, 1fr))',
+      padding: `${tokens.spacingVerticalL} ${tokens.spacingHorizontalL}`,
     },
   },
-  section: {
-    display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalXS,
+  divided: {
+    paddingTop: tokens.spacingVerticalXL,
+    borderTop: `${tokens.strokeWidthThin} solid ${tokens.colorNeutralStroke2}`,
   },
-  sectionLabel: {
-    color: tokens.colorNeutralForeground3,
+  components: {
+    rowGap: tokens.spacingVerticalM,
   },
-  surface: {
-    display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalM,
-    padding: tokens.spacingVerticalL,
-    borderLeft: `3px solid ${tokens.colorBrandStroke1}`,
-    borderRadius: tokens.borderRadiusMedium,
-    backgroundColor: tokens.colorNeutralBackground2,
+  objective: {
+    display: 'block',
+    maxWidth: '75ch',
+    whiteSpace: 'pre-wrap',
   },
-  bodyText: {
-    margin: 0,
+  rationale: {
+    maxWidth: '75ch',
     whiteSpace: 'pre-wrap',
-    overflowWrap: 'anywhere',
+    color: tokens.colorNeutralForeground2,
   },
-  collapsedSeedText: {
-    display: '-webkit-box',
-    overflow: 'hidden',
-    WebkitBoxOrient: 'vertical',
-    WebkitLineClamp: 5,
+  meta: {
+    color: tokens.colorNeutralForeground3,
+    fontVariantNumeric: 'tabular-nums',
   },
-  badgeList: {
-    display: 'flex',
-    flexWrap: 'wrap',
-    gap: tokens.spacingHorizontalXS,
+  error: {
+    alignSelf: 'stretch',
   },
-  seed: {
+  retry: { ...mobileTouchTarget },
+  findings: {
     display: 'flex',
     flexDirection: 'column',
     gap: tokens.spacingVerticalS,
+    margin: 0,
+    padding: 0,
+    listStyleType: 'none',
   },
-  seedImage: {
-    display: 'block',
-    width: 'auto',
-    maxWidth: '100%',
-    maxHeight: '24rem',
-    borderRadius: tokens.borderRadiusMedium,
-    objectFit: 'contain',
-  },
-  seedMedia: {
-    width: 'min(36rem, 100%)',
-  },
-  seedToggle: {
-    alignSelf: 'flex-start',
-    minWidth: 0,
-    paddingInline: 0,
-    color: tokens.colorBrandForegroundLink,
+  finding: {
+    display: 'grid',
+    gridTemplateColumns: 'auto minmax(0, 1fr)',
+    alignItems: 'baseline',
+    gap: tokens.spacingHorizontalS,
   },
-  fileLink: {
-    color: tokens.colorBrandForegroundLink,
+  actions: {
+    display: 'flex',
+    alignItems: 'center',
+    flexWrap: 'wrap',
+    gap: tokens.spacingHorizontalM,
+    [NARROW_VIEWPORT_QUERY]: { flexDirection: 'column', alignItems: 'stretch' },
   },
   conversationLink: {
     display: 'inline-flex',
     alignItems: 'center',
     gap: tokens.spacingHorizontalS,
-    alignSelf: 'flex-start',
+    minHeight: MINIMUM_TOUCH_TARGET_SIZE,
+    boxSizing: 'border-box',
     color: tokens.colorBrandForegroundLink,
     backgroundColor: tokens.colorBrandBackground2,
     borderRadius: tokens.borderRadiusMedium,
@@ -87,5 +78,6 @@ export const useAttackAttemptDetailsStyles = makeStyles({
     fontWeight: tokens.fontWeightSemibold,
     textDecorationLine: 'none',
     ':hover': { backgroundColor: tokens.colorBrandBackground2Hover },
+    [NARROW_VIEWPORT_QUERY]: { justifyContent: 'center' },
   },
 })
diff --git a/frontend/src/components/AttackResults/AttackAttemptDetails.test.tsx b/frontend/src/components/AttackResults/AttackAttemptDetails.test.tsx
new file mode 100644
index 0000000000..104be49025
--- /dev/null
+++ b/frontend/src/components/AttackResults/AttackAttemptDetails.test.tsx
@@ -0,0 +1,76 @@
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen, within } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { MemoryRouter } from 'react-router'
+
+import { attacksApi } from '@/services/api'
+import type { ScenarioObjectiveScorer, ScenarioProgressResult } from '@/types'
+
+import AttackAttemptDetails from './AttackAttemptDetails'
+
+jest.mock('@/services/api', () => ({ attacksApi: { getAttackFindings: jest.fn() } }))
+
+function TestWrapper({ children }: { children: React.ReactNode }) {
+  return <FluentProvider theme={webLightTheme}><MemoryRouter>{children}</MemoryRouter></FluentProvider>
+}
+
+const attempt: ScenarioProgressResult = {
+  attack_result_id: 'saved-attack', conversation_id: 'saved-conversation', atomic_group_id: 'group',
+  atomic_attack_name: 'PromptSendingAttack', seed_group_id: 'seed', outcome: 'success',
+  execution_time_ms: 0, total_retries: 0, timestamp: '2026-01-01T00:00:00Z', retries: [],
+  score: { scorer_name: 'recorded judge', score_type: 'true_false', status: 'complete',
+    score_value: 'true', score_rationale: 'The objective was met.' },
+}
+const recordedScorer: ScenarioObjectiveScorer = {
+  component_name: 'old registry alias', parameters: { scorer_type: 'true_false', eval_hash: 'recorded-configuration' },
+  children: {}, metrics: { accuracy: 0, recall: 0, num_responses: 100 },
+}
+
+describe('AttackAttemptDetails', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.mocked(attacksApi.getAttackFindings).mockResolvedValue({ attack_result_id: attempt.attack_result_id, items: [] })
+  })
+
+  it('should retain readable recorded metrics without registry lookup and keep individual attack score details', async () => {
+    const user = userEvent.setup()
+    const rendered = render(<TestWrapper><AttackAttemptDetails attempt={attempt} objective="Recorded objective"
+      objectiveScorer={recordedScorer} conversationPath="/saved" /></TestWrapper>)
+    await user.click(screen.getByRole('button', { name: 'Evaluation metrics for old registry alias' }))
+    const dialog = screen.getByRole('dialog')
+    expect(dialog).toHaveTextContent('Quality of the recorded scorer configuration')
+    expect(within(dialog).getByRole('group', { name: 'Accuracy' })).toHaveTextContent('0.00%')
+    expect(within(dialog).getByRole('group', { name: 'Num responses' })).toHaveTextContent('100')
+    await user.keyboard('{Escape}')
+    rendered.rerender(<TestWrapper><AttackAttemptDetails attempt={attempt} objective="Recorded objective"
+      objectiveScorer={{ ...recordedScorer, component_name: 'renamed or unregistered judge' }} conversationPath="/saved" /></TestWrapper>)
+    await user.click(screen.getByRole('button', { name: 'Evaluation metrics for renamed or unregistered judge' }))
+    expect(screen.getByRole('dialog')).toHaveTextContent('0.00%')
+    await user.keyboard('{Escape}')
+    await user.click(screen.getByRole('button', { name: 'True: View attack score' }))
+    expect(screen.getByText('Score details')).toBeVisible()
+    expect(screen.getByText('Final score')).toBeVisible()
+    expect(screen.getByText('recorded judge')).toBeVisible()
+  })
+
+  it('should distinguish failed findings reads from empty links and recover with a keyboard retry', async () => {
+    const user = userEvent.setup()
+    jest.mocked(attacksApi.getAttackFindings).mockRejectedValueOnce({
+      isAxiosError: true, response: { status: 503, data: { detail: 'Findings unavailable' } },
+    }).mockResolvedValueOnce({
+      attack_result_id: attempt.attack_result_id, items: [{
+        id: 'finding', operation_id: 'operation', operation_name: 'Recorded operation', evidence_id: 'evidence',
+        title: 'Recovered attached finding', description: 'Stored evidence', severity: 'low', created_at: attempt.timestamp,
+      }],
+    })
+    render(<TestWrapper><AttackAttemptDetails attempt={attempt} conversationPath="/saved" /></TestWrapper>)
+    expect(await screen.findByText(/Could not load attached findings: Findings unavailable/)).toBeVisible()
+    expect(screen.queryByRole('list', { name: 'Attached findings' })).not.toBeInTheDocument()
+    const retry = screen.getByRole('button', { name: 'Retry findings' })
+    retry.focus()
+    await user.keyboard('{Enter}')
+    expect(await screen.findByRole('list', { name: 'Attached findings' })).toHaveTextContent('Recovered attached finding')
+    expect(attacksApi.getAttackFindings).toHaveBeenCalledTimes(2)
+    expect(screen.queryByText(/Could not load attached findings/)).not.toBeInTheDocument()
+  })
+})
diff --git a/frontend/src/components/AttackResults/AttackAttemptDetails.tsx b/frontend/src/components/AttackResults/AttackAttemptDetails.tsx
index d71974c01a..2a335d2c09 100644
--- a/frontend/src/components/AttackResults/AttackAttemptDetails.tsx
+++ b/frontend/src/components/AttackResults/AttackAttemptDetails.tsx
@@ -1,10 +1,15 @@
-import { useState } from 'react'
-
-import { Badge, MessageBar, MessageBarBody, Table, TableBody, TableCell, TableHeader, TableHeaderCell, TableRow, Text } from '@fluentui/react-components'
+import { Button, MessageBar, MessageBarActions, MessageBarBody, Text, mergeClasses } from '@fluentui/react-components'
 import { Link } from 'react-router'
 
-import RegistryIdentityRow from '@/components/Registry/RegistryIdentityRow'
+import AttachToFindingsButton from '@/components/Chat/AttachToFindingsButton'
+import DetailFacts, { DetailFact } from '@/components/DetailFacts'
+import FindingSeverityBadge from '@/components/Operations/FindingSeverityBadge'
+import OutcomeBadge from '@/components/OutcomeBadge'
+import IdentityDisclosure from '@/components/Registry/IdentityDisclosure'
+import ScorerEvaluationDetails from '@/components/Scorers/ScorerEvaluationDetails'
+import { useAttackFindings } from '@/hooks/useAttackFindings'
 import type {
+  AttackDisplayOutcome,
   ScenarioActiveConversation,
   ScenarioAttackTechniqueDetails,
   ScenarioHierarchyNode,
@@ -12,20 +17,16 @@ import type {
   ScenarioProgressResult,
   ScenarioRunPlanAtomicGroup,
 } from '@/types'
+import { scoreSummaryFromProgressScore } from '@/utils/scoreSummary'
 
-import ComponentIdentityDetails, { DetailMetric } from './ComponentIdentityDetails'
-import ObjectiveScorerDetails from './ObjectiveScorerDetails'
-import {
-  formatAttackSuccess,
-  formatDuration,
-  formatScore,
-  formatScoreRationale,
-  formatTimestamp,
-} from './attackAttemptFormatting'
+import { formatAttemptTiming, formatScoreRationale } from './attackAttemptFormatting'
 import { useAttackAttemptDetailsStyles } from './AttackAttemptDetails.styles'
 
 interface AttackAttemptDetailsProps {
-  readonly attempt: ScenarioProgressResult | ScenarioActiveConversation | ScenarioHierarchyNode
+  /** A saved result or hierarchy node, a running attack, or null before the attack starts. */
+  readonly attempt: ScenarioProgressResult | ScenarioActiveConversation | ScenarioHierarchyNode | null
+  /** The attack has not started yet but will; otherwise a missing attempt is unavailable. */
+  readonly preparing?: boolean
   readonly objective?: string | null
   readonly atomicGroup?: ScenarioRunPlanAtomicGroup | null
   readonly techniqueDetails?: ScenarioAttackTechniqueDetails | null
@@ -33,107 +34,101 @@ interface AttackAttemptDetailsProps {
   /** Route to the attempt's conversation. Supplied by the host so this stays route-agnostic. */
   readonly conversationPath: string | null
   readonly conversationState?: unknown
+  /** Offered first when attaching this attack to a finding. */
+  readonly findingOperationId?: string | null
+  /** Frame the details as a standalone card when they are shown inline on a page. */
+  readonly framed?: boolean
 }
 
+/** One attack's objective and outcome, the components it ran with, its findings, and its conversation. */
 export default function AttackAttemptDetails({
   attempt,
+  preparing = false,
   objective,
   atomicGroup,
   techniqueDetails,
   objectiveScorer,
   conversationPath,
   conversationState,
+  findingOperationId,
+  framed = false,
 }: AttackAttemptDetailsProps) {
   const styles = useAttackAttemptDetailsStyles()
-  const [expanded, setExpanded] = useState<Set<string>>(new Set())
-  const completed = 'outcome' in attempt ? attempt : null
-  const techniqueName = atomicGroup?.technique_name ?? atomicGroup?.display_group ?? attempt.atomic_attack_name
-  const seeds = 'seed_identifiers' in attempt ? attempt.seed_identifiers ?? [] : []
+  const completed = attempt && 'outcome' in attempt ? attempt : null
+  const { findings, loading: findingsLoading, error: findingsError, refresh: refreshFindings } = useAttackFindings(completed?.attack_result_id)
+  const techniqueName = atomicGroup?.technique_name ?? atomicGroup?.display_group ?? attempt?.atomic_attack_name ?? 'Not recorded'
+  const seeds = attempt && 'seed_identifiers' in attempt ? attempt.seed_identifiers ?? [] : []
   const datasetNames = [...new Set(seeds.flatMap((seed) =>
     typeof seed.parameters.dataset_name === 'string' ? [seed.parameters.dataset_name] : []))]
-  const identities = [
-    { key: 'technique', name: techniqueName, kind: 'Technique', type: techniqueDetails?.component_name ?? attempt.atomic_attack_name, identity: techniqueDetails },
-    { key: 'scorer', name: objectiveScorer?.component_name ?? 'Not recorded', kind: 'Scorer', type: 'Objective scorer', identity: objectiveScorer },
-    { key: 'dataset', name: datasetNames.join(', ') || 'Dataset seeds', kind: 'Dataset', type: 'Seed group', identity: seeds.length ? seeds : null },
-  ]
-  const techniqueDescription = atomicGroup?.description ?? 'No description is available for this attack technique.'
-  const techniqueTags = atomicGroup?.tags ?? []
-  const errorMessage = completed?.outcome === 'error'
-    ? completed.error_message ?? 'No error detail was persisted.'
-    : null
-
-  function toggle(key: string): void {
-    setExpanded((current: Set<string>) => {
-      const next = new Set(current)
-      if (next.has(key)) next.delete(key)
-      else next.add(key)
-      return next
-    })
-  }
+  const outcome: AttackDisplayOutcome = completed ? completed.outcome
+    : attempt ? 'in_progress' : preparing ? 'preparing' : 'undetermined'
+  const rationale = completed
+    ? completed.outcome === 'error' ? 'This attack did not produce a scored outcome.' : formatScoreRationale(completed.score?.score_rationale)
+    : attempt || preparing ? 'The outcome will appear after scoring.' : 'Attack details are not available.'
 
   return (
-    <div className={styles.content}>
-      <section className={styles.section}>
-        <Text size={200} className={styles.sectionLabel}>Objective</Text>
-        <Text as="p" className={styles.bodyText}>{objective ?? 'Objective text is not available.'}</Text>
-      </section>
-      <section className={styles.surface} aria-label="Attack outcome">
-        <div><Badge appearance="tint" color={!completed ? 'brand' : completed.outcome === 'success' ? 'success' : completed.outcome === 'error' ? 'danger' : 'informative'}>
-          {completed ? formatAttackSuccess(completed.outcome) : 'In progress'}
-        </Badge></div>
-        <Text as="p" className={styles.bodyText}>
-          {!completed ? 'The outcome will appear after scoring.' : completed.outcome === 'error'
-            ? 'This attack did not produce a scored outcome.' : formatScoreRationale(completed.score?.score_rationale)}
-        </Text>
-      </section>
-      {completed && <div className={styles.summary}>
-        <DetailMetric label="Score" value={formatScore(completed.score)} />
-        <DetailMetric label="Execution time" value={formatDuration(completed.execution_time_ms)} />
-        <DetailMetric label="Retries" value={String(completed.total_retries)} />
-        <DetailMetric label="Timestamp" value={formatTimestamp(completed.timestamp)} />
-      </div>}
-      <section className={styles.section}>
-        <Text size={200} className={styles.sectionLabel}>Attack technique</Text>
-        <div className={styles.surface}>
-          <Text weight="semibold">{techniqueName}</Text>
-          <Text as="p" className={styles.bodyText}>{techniqueDescription}</Text>
-          {techniqueTags.length > 0 && (
-            <div className={styles.badgeList} aria-label="Technique tags">
-              {techniqueTags.map((tag) => <Badge key={tag} appearance="tint">{tag}</Badge>)}
-            </div>
-          )}
-          {techniqueDetails && <ComponentIdentityDetails identity={techniqueDetails} hideComponentName />}
-        </div>
-      </section>
-      <section className={styles.section}>
-        <Text size={200} className={styles.sectionLabel}>Objective Scorer</Text>
-        {objectiveScorer
-          ? <ObjectiveScorerDetails scorer={objectiveScorer} />
-          : <Text>Objective scorer information is unavailable for this attempt.</Text>}
-      </section>
-      {conversationPath ? (
-        <Link className={styles.conversationLink} to={conversationPath} state={conversationState}>
-          {completed ? 'Open conversation' : 'Watch live conversation'}
-        </Link>
-      ) : (
-        <Text>No conversation was saved for this result.</Text>
-      )}
-      <Table size="small" aria-label="Attack components">
-        <TableHeader><TableRow><TableHeaderCell>Name</TableHeaderCell><TableHeaderCell>Component</TableHeaderCell><TableHeaderCell>Type</TableHeaderCell></TableRow></TableHeader>
-        <TableBody>{identities.map((item: typeof identities[number]) => item.identity ? (
-          <RegistryIdentityRow key={item.key} name={item.name} identity={item.identity} columns={3}
-            expanded={expanded.has(item.key)} onToggle={() => { toggle(item.key) }}>
-            <TableCell>{item.kind}</TableCell><TableCell>{item.type}</TableCell>
-          </RegistryIdentityRow>
+    <div className={mergeClasses(styles.content, framed && styles.framed)}>
+      <DetailFacts label="Attack outcome">
+        <DetailFact label="Objective:" tone="primary" valueClassName={styles.objective}>
+          {objective ?? 'Objective text is not available.'}
+        </DetailFact>
+        <DetailFact label="Outcome:" tone="primary">
+          <OutcomeBadge appearance="tint" outcome={outcome} labelStyle="success"
+            label={!attempt && !preparing ? 'Not available' : undefined}
+            score={completed?.score ? scoreSummaryFromProgressScore(completed.score) : null}
+            scoreButtonLabel="View attack score" />
+          <Text className={styles.rationale}>{rationale}</Text>
+          {completed && <Text size={200} className={styles.meta} aria-label="Attack timing">
+            {formatAttemptTiming(completed)}
+          </Text>}
+          {completed?.outcome === 'error' && <MessageBar intent="error" className={styles.error}>
+            <MessageBarBody>
+              {completed.error_type ? `${completed.error_type}: ` : ''}{completed.error_message ?? 'No error detail was persisted.'}
+            </MessageBarBody>
+          </MessageBar>}
+        </DetailFact>
+      </DetailFacts>
+      <DetailFacts label="Attack components" className={mergeClasses(styles.divided, styles.components)}>
+        <DetailFact label="Technique"><IdentityDisclosure name={techniqueName} identity={techniqueDetails} /></DetailFact>
+        <DetailFact label="Objective scorer">
+          <IdentityDisclosure name={objectiveScorer?.component_name ?? 'Not recorded'} identity={objectiveScorer} />
+          <ScorerEvaluationDetails name={objectiveScorer?.component_name ?? 'Not recorded'}
+            metrics={objectiveScorer?.metrics ? { ...objectiveScorer.metrics } : null}
+            scoreType={typeof objectiveScorer?.parameters.scorer_type === 'string' ? objectiveScorer.parameters.scorer_type : undefined}
+            recorded />
+        </DetailFact>
+        <DetailFact label="Dataset">
+          <IdentityDisclosure name={datasetNames.join(', ') || 'Not recorded'} identity={seeds.length > 0 ? seeds : null} />
+        </DetailFact>
+        {(findings.length > 0 || findingsLoading || findingsError) && <DetailFact label="Findings">
+          {findingsLoading && <Text role="status">Loading attached findings...</Text>}
+          {findingsError && <MessageBar intent="error">
+            <MessageBarBody>Could not load attached findings: {findingsError}</MessageBarBody>
+            <MessageBarActions><Button className={styles.retry} disabled={findingsLoading} onClick={refreshFindings}>
+              Retry findings
+            </Button></MessageBarActions>
+          </MessageBar>}
+          {findings.length > 0 && <ul className={styles.findings} aria-label="Attached findings">
+            {findings.map((finding) => <li key={finding.evidence_id} className={styles.finding}>
+              <FindingSeverityBadge finding={finding} />
+              <Text>{finding.title}</Text>
+            </li>)}
+          </ul>}
+        </DetailFact>}
+      </DetailFacts>
+      <div className={mergeClasses(styles.actions, styles.divided)}>
+        {conversationPath ? (
+          <Link className={styles.conversationLink} to={conversationPath} state={conversationState}>
+            {completed ? 'Open conversation' : 'Watch live conversation'}
+          </Link>
+        ) : !attempt && preparing ? (
+          <Button disabled>Watch live conversation</Button>
         ) : (
-          <TableRow key={item.key}><TableCell>{item.name}</TableCell><TableCell>{item.kind}</TableCell><TableCell>No saved identity</TableCell></TableRow>
-        ))}</TableBody>
-      </Table>
-      {errorMessage && (
-        <MessageBar intent="error">
-          <MessageBarBody>{completed?.error_type ? `${completed.error_type}: ` : ''}{errorMessage}</MessageBarBody>
-        </MessageBar>
-      )}
+          <Text className={styles.meta}>No conversation was saved for this result.</Text>
+        )}
+        {attempt && <AttachToFindingsButton attackResultId={attempt.attack_result_id} defaultOperationId={findingOperationId}
+          disabled={!completed} onAttached={refreshFindings} />}
+      </div>
     </div>
   )
 }
diff --git a/frontend/src/components/AttackResults/ComponentIdentityDetails.styles.ts b/frontend/src/components/AttackResults/ComponentIdentityDetails.styles.ts
deleted file mode 100644
index a72992fc49..0000000000
--- a/frontend/src/components/AttackResults/ComponentIdentityDetails.styles.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { makeStyles, tokens } from '@fluentui/react-components'
-
-export const useComponentIdentityDetailsStyles = makeStyles({
-  identity: {
-    display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalS,
-    minWidth: 0,
-  },
-  fields: {
-    display: 'grid',
-    gridTemplateColumns: 'repeat(auto-fit, minmax(14rem, 1fr))',
-    gap: `${tokens.spacingVerticalM} ${tokens.spacingHorizontalL}`,
-  },
-  metric: {
-    display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalXXS,
-    minWidth: 0,
-  },
-  label: {
-    color: tokens.colorNeutralForeground3,
-  },
-  value: {
-    overflowWrap: 'anywhere',
-    whiteSpace: 'pre-wrap',
-  },
-  collapsedValue: {
-    display: '-webkit-box',
-    overflow: 'hidden',
-    WebkitBoxOrient: 'vertical',
-    WebkitLineClamp: 4,
-  },
-  valueToggle: {
-    alignSelf: 'flex-start',
-    minWidth: 0,
-    paddingInline: 0,
-    color: tokens.colorBrandForegroundLink,
-  },
-  childSection: {
-    display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalS,
-  },
-  childList: {
-    display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalS,
-  },
-  child: {
-    padding: tokens.spacingVerticalM,
-    borderLeft: `3px solid ${tokens.colorNeutralStroke2}`,
-    backgroundColor: tokens.colorNeutralBackground1,
-  },
-})
diff --git a/frontend/src/components/AttackResults/ComponentIdentityDetails.tsx b/frontend/src/components/AttackResults/ComponentIdentityDetails.tsx
deleted file mode 100644
index 9372b4347c..0000000000
--- a/frontend/src/components/AttackResults/ComponentIdentityDetails.tsx
+++ /dev/null
@@ -1,132 +0,0 @@
-import { useId, useState, type ReactNode } from 'react'
-
-import { Button, mergeClasses, Text } from '@fluentui/react-components'
-import { ChevronDownRegular, ChevronUpRegular } from '@fluentui/react-icons'
-
-import type { ScenarioComponentIdentity, ScenarioIdentityValue } from '@/types'
-
-import { useComponentIdentityDetailsStyles } from './ComponentIdentityDetails.styles'
-
-const NO_OMITTED_PARAMETERS = new Set<string>()
-const COLLAPSIBLE_VALUE_LENGTH = 240
-
-export interface DetailMetricProps {
-  readonly label: string
-  readonly value: string
-  readonly collapsible?: boolean
-}
-
-export function DetailMetric({ label, value, collapsible = false }: DetailMetricProps) {
-  const styles = useComponentIdentityDetailsStyles()
-  const contentId = useId()
-  const [expanded, setExpanded] = useState(false)
-  const canCollapse = collapsible && value.length > COLLAPSIBLE_VALUE_LENGTH
-  return (
-    <div className={styles.metric} role="group" aria-label={label}>
-      <Text size={200} className={styles.label}>{label}</Text>
-      <Text
-        id={contentId}
-        weight="semibold"
-        className={mergeClasses(styles.value, canCollapse && !expanded && styles.collapsedValue)}
-      >
-        {value}
-      </Text>
-      {canCollapse && (
-        <Button
-          appearance="transparent"
-          size="small"
-          className={styles.valueToggle}
-          icon={expanded ? <ChevronUpRegular /> : <ChevronDownRegular />}
-          aria-controls={contentId}
-          aria-expanded={expanded}
-          aria-label={expanded ? `Collapse ${label}` : `Show full ${label}`}
-          onClick={() => setExpanded((current) => !current)}
-        >
-          {expanded ? 'Show less' : 'Show more'}
-        </Button>
-      )}
-    </div>
-  )
-}
-
-export interface IdentityChildRenderContext {
-  readonly childName: string
-  readonly identity: ScenarioComponentIdentity
-  readonly index: number
-}
-
-interface ComponentIdentityDetailsProps {
-  readonly identity: ScenarioComponentIdentity
-  readonly hideComponentName?: boolean
-  readonly omittedParameters?: ReadonlySet<string>
-  readonly collapseParameterValues?: boolean
-  readonly renderChild?: (context: IdentityChildRenderContext) => ReactNode
-}
-
-export default function ComponentIdentityDetails({
-  identity,
-  hideComponentName = false,
-  omittedParameters = NO_OMITTED_PARAMETERS,
-  collapseParameterValues = false,
-  renderChild,
-}: ComponentIdentityDetailsProps) {
-  const styles = useComponentIdentityDetailsStyles()
-  const parameters = Object.entries(identity.parameters)
-    .filter(([name]) => !omittedParameters.has(name))
-  const children = Object.entries(identity.children)
-
-  return (
-    <div className={styles.identity}>
-      {!hideComponentName && <Text weight="semibold">{identity.component_name}</Text>}
-      {parameters.length > 0 && (
-        <div className={styles.fields}>
-          {parameters.map(([name, value]) => (
-            <DetailMetric
-              key={name}
-              label={formatIdentityLabel(name)}
-              value={formatIdentityValue(value)}
-              collapsible={collapseParameterValues}
-            />
-          ))}
-        </div>
-      )}
-      {children.map(([childName, childIdentities]) => (
-        <div key={childName} className={styles.childSection}>
-          <Text size={200} className={styles.label}>{formatIdentityLabel(childName)}</Text>
-          <div className={styles.childList}>
-            {childIdentities.map((childIdentity, index) => {
-              const customChild = renderChild?.({ childName, identity: childIdentity, index })
-              return (
-                <div key={`${childIdentity.component_name}-${index}`} className={styles.child}>
-                  {customChild ?? (
-                    <ComponentIdentityDetails
-                      identity={childIdentity}
-                      omittedParameters={omittedParameters}
-                      collapseParameterValues={collapseParameterValues}
-                      renderChild={renderChild}
-                    />
-                  )}
-                </div>
-              )
-            })}
-          </div>
-        </div>
-      ))}
-    </div>
-  )
-}
-
-function formatIdentityLabel(name: string): string {
-  const words = name.replace(/_/g, ' ')
-  return words.charAt(0).toUpperCase() + words.slice(1)
-}
-
-function formatIdentityValue(value: ScenarioIdentityValue): string {
-  if (typeof value === 'string') {
-    return value
-  }
-  if (Array.isArray(value) || (typeof value === 'object' && value !== null)) {
-    return JSON.stringify(value)
-  }
-  return String(value)
-}
diff --git a/frontend/src/components/AttackResults/ObjectiveScorerDetails.styles.ts b/frontend/src/components/AttackResults/ObjectiveScorerDetails.styles.ts
deleted file mode 100644
index e5e194b13f..0000000000
--- a/frontend/src/components/AttackResults/ObjectiveScorerDetails.styles.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { makeStyles, tokens } from '@fluentui/react-components'
-
-export const useObjectiveScorerDetailsStyles = makeStyles({
-  card: {
-    display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalL,
-    padding: tokens.spacingVerticalL,
-    border: `1px solid ${tokens.colorNeutralStroke2}`,
-    borderRadius: tokens.borderRadiusLarge,
-    backgroundColor: tokens.colorNeutralBackground1,
-  },
-  section: {
-    display: 'flex',
-    flexDirection: 'column',
-    gap: tokens.spacingVerticalM,
-  },
-  hint: {
-    color: tokens.colorNeutralForeground3,
-  },
-  documentationLink: {
-    alignSelf: 'flex-start',
-    color: tokens.colorBrandForegroundLink,
-    fontSize: tokens.fontSizeBase200,
-  },
-})
diff --git a/frontend/src/components/AttackResults/ObjectiveScorerDetails.tsx b/frontend/src/components/AttackResults/ObjectiveScorerDetails.tsx
deleted file mode 100644
index b01a9104d9..0000000000
--- a/frontend/src/components/AttackResults/ObjectiveScorerDetails.tsx
+++ /dev/null
@@ -1,47 +0,0 @@
-import { Text } from '@fluentui/react-components'
-
-import type { ScenarioObjectiveScorer } from '@/types'
-
-import ScorerMetricsDetails from '@/components/Scorers/ScorerMetricsDetails'
-import ComponentIdentityDetails from './ComponentIdentityDetails'
-import { useObjectiveScorerDetailsStyles } from './ObjectiveScorerDetails.styles'
-
-const SCORER_METRICS_DOCUMENTATION_URL = 'https://microsoft.github.io/PyRIT/latest/code/scoring/scorer-metrics/'
-const OMITTED_SCORER_PARAMETERS = new Set<string>(['scorer_type'])
-
-interface ObjectiveScorerDetailsProps {
-  readonly scorer: ScenarioObjectiveScorer
-}
-
-export default function ObjectiveScorerDetails({ scorer }: ObjectiveScorerDetailsProps) {
-  const styles = useObjectiveScorerDetailsStyles()
-  return (
-    <article className={styles.card}>
-      <div className={styles.section}>
-        <ComponentIdentityDetails
-          identity={scorer}
-          omittedParameters={OMITTED_SCORER_PARAMETERS}
-          collapseParameterValues
-        />
-      </div>
-      <div className={styles.section}>
-        <Text weight="semibold">Accuracy Metrics</Text>
-        {scorer.metrics ? (
-          <ScorerMetricsDetails metrics={{ ...scorer.metrics }} fallback="Unavailable" />
-        ) : (
-          <Text className={styles.hint}>
-            Official evaluation has not been run for this scorer configuration.
-          </Text>
-        )}
-        <a
-          className={styles.documentationLink}
-          href={SCORER_METRICS_DOCUMENTATION_URL}
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          About scorer metrics
-        </a>
-      </div>
-    </article>
-  )
-}
diff --git a/frontend/src/components/AttackResults/attackAttemptFormatting.test.ts b/frontend/src/components/AttackResults/attackAttemptFormatting.test.ts
index 7d7e20833d..e40824e624 100644
--- a/frontend/src/components/AttackResults/attackAttemptFormatting.test.ts
+++ b/frontend/src/components/AttackResults/attackAttemptFormatting.test.ts
@@ -1,4 +1,4 @@
-import { objectivePreview } from './attackAttemptFormatting'
+import { formatAttemptTiming, formatRetries, formatTimestamp, objectivePreview } from './attackAttemptFormatting'
 
 const LONE_SURROGATE_REGEX = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/
 
@@ -45,3 +45,21 @@ describe('objectivePreview', () => {
     expect(objectivePreview('', 'seed-456')).toBe('Objective unavailable (seed-456)')
   })
 })
+
+describe('formatRetries', () => {
+  it('says when there were no retries and pluralizes the rest', () => {
+    expect(formatRetries(0)).toBe('No retries')
+    expect(formatRetries(1)).toBe('1 retry')
+    expect(formatRetries(3)).toBe('3 retries')
+  })
+})
+
+describe('formatAttemptTiming', () => {
+  it('joins duration, retries, and timestamp on one line', () => {
+    const timestamp = '2026-01-01T00:04:30Z'
+    expect(formatAttemptTiming({ execution_time_ms: 270_000, total_retries: 0, timestamp }))
+      .toBe(`4m 30s · No retries · ${formatTimestamp(timestamp)}`)
+    expect(formatAttemptTiming({ execution_time_ms: 5_000, total_retries: 2, timestamp }))
+      .toBe(`5s · 2 retries · ${formatTimestamp(timestamp)}`)
+  })
+})
diff --git a/frontend/src/components/AttackResults/attackAttemptFormatting.ts b/frontend/src/components/AttackResults/attackAttemptFormatting.ts
index 65862007f9..49876215d3 100644
--- a/frontend/src/components/AttackResults/attackAttemptFormatting.ts
+++ b/frontend/src/components/AttackResults/attackAttemptFormatting.ts
@@ -33,13 +33,6 @@ export function formatAttackOutcome(outcome: ScenarioProgressResult['outcome']):
   return outcome.replace(/^\w/, (letter) => letter.toUpperCase())
 }
 
-export function formatScore(score: ScenarioProgressResult['score']): string {
-  if (!score || score.status === 'undetermined') {
-    return 'Undetermined'
-  }
-  return score.score_value ?? 'Unavailable'
-}
-
 export function formatScoreRationale(rationale: string | null | undefined): string {
   return rationale?.trim() || 'No rationale is available.'
 }
@@ -76,6 +69,22 @@ export function formatDuration(milliseconds: number): string {
   return `${seconds}s`
 }
 
+export function formatRetries(retries: number): string {
+  if (retries === 0) return 'No retries'
+  return `${retries} ${retries === 1 ? 'retry' : 'retries'}`
+}
+
+/** One line of attempt timing, such as "4m 30s · No retries · Jan 1, 2026, 12:00:05 AM". */
+export function formatAttemptTiming(
+  attempt: Pick<ScenarioProgressResult, 'execution_time_ms' | 'total_retries' | 'timestamp'>,
+): string {
+  return [
+    formatDuration(attempt.execution_time_ms),
+    formatRetries(attempt.total_retries),
+    formatTimestamp(attempt.timestamp),
+  ].join(' · ')
+}
+
 export function objectivePreview(objective: string | null, fallbackId: string): string {
   if (!objective) {
     return `Objective unavailable (${fallbackId})`
diff --git a/frontend/src/components/Chat/AttachToFindingsButton.styles.ts b/frontend/src/components/Chat/AttachToFindingsButton.styles.ts
new file mode 100644
index 0000000000..76db3b84dd
--- /dev/null
+++ b/frontend/src/components/Chat/AttachToFindingsButton.styles.ts
@@ -0,0 +1,9 @@
+import { makeStyles } from '@fluentui/react-components'
+
+import { mobileTouchTargetHeight } from '@/styles/touchTargets'
+
+export const useAttachToFindingsButtonStyles = makeStyles({
+  button: {
+    ...mobileTouchTargetHeight,
+  },
+})
diff --git a/frontend/src/components/Chat/AttachToFindingsButton.test.tsx b/frontend/src/components/Chat/AttachToFindingsButton.test.tsx
new file mode 100644
index 0000000000..e40b4677d1
--- /dev/null
+++ b/frontend/src/components/Chat/AttachToFindingsButton.test.tsx
@@ -0,0 +1,75 @@
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { MemoryRouter } from 'react-router'
+
+import { attacksApi, operationsApi } from '@/services/api'
+
+import AttachToFindingsButton from './AttachToFindingsButton'
+
+jest.mock('@/services/api', () => ({
+  attacksApi: { getAttack: jest.fn() },
+  operationsApi: {
+    get: jest.fn(), list: jest.fn(), listFindings: jest.fn(), attachFindingEvidence: jest.fn(), createFinding: jest.fn(),
+    getFindingOptions: jest.fn(),
+  },
+}))
+
+const OPERATION = { id: 'scan-operation', name: 'Scan operation', created_at: '2026-10-08T12:00:00Z' }
+const FINDING = {
+  id: 'finding', operation_id: OPERATION.id, title: 'Proof', severity: 'low', description: '',
+  created_at: '2026-10-08T12:00:00Z', evidence_count: 0,
+}
+
+function TestWrapper({ children }: { readonly children: React.ReactNode }) {
+  return <FluentProvider theme={webLightTheme}><MemoryRouter>{children}</MemoryRouter></FluentProvider>
+}
+
+describe('AttachToFindingsButton', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.mocked(attacksApi.getAttack).mockResolvedValue({ operation_id: null } as never)
+    jest.mocked(operationsApi.get).mockResolvedValue(OPERATION as never)
+    jest.mocked(operationsApi.list).mockResolvedValue({ items: [{ ...OPERATION, finding_counts: {} }] } as never)
+    jest.mocked(operationsApi.listFindings).mockResolvedValue({ items: [FINDING], has_more: false, next_offset: null } as never)
+    jest.mocked(operationsApi.attachFindingEvidence).mockResolvedValue({ item: { id: 'evidence' }, created: true } as never)
+  })
+
+  it('should attach the attack to a finding in the default operation and report it', async () => {
+    const user = userEvent.setup()
+    const onAttached = jest.fn()
+    render(<TestWrapper>
+      <AttachToFindingsButton attackResultId="attack-1" defaultOperationId={OPERATION.id} onAttached={onAttached} />
+    </TestWrapper>)
+
+    const button = screen.getByRole('button', { name: 'Attach to findings' })
+    await user.click(button)
+    expect(await screen.findByRole('dialog')).toBeInTheDocument()
+    expect(operationsApi.get).toHaveBeenCalledWith(OPERATION.id)
+    await user.click(await screen.findByRole('radio', { name: /Proof/ }))
+    await user.click(screen.getByRole('button', { name: 'Attach attack' }))
+
+    await waitFor(() => { expect(onAttached).toHaveBeenCalledTimes(1) })
+    expect(operationsApi.attachFindingEvidence).toHaveBeenCalledWith(OPERATION.id, FINDING.id, { attack_result_id: 'attack-1' })
+    await waitFor(() => { expect(button).toHaveFocus() })
+  })
+
+  it('should not report an attachment when the dialog is cancelled', async () => {
+    const user = userEvent.setup()
+    const onAttached = jest.fn()
+    render(<TestWrapper><AttachToFindingsButton attackResultId="attack-1" onAttached={onAttached} /></TestWrapper>)
+
+    await user.click(screen.getByRole('button', { name: 'Attach to findings' }))
+    await user.click(await screen.findByRole('button', { name: 'Cancel' }))
+
+    await waitFor(() => { expect(screen.queryByRole('dialog')).not.toBeInTheDocument() })
+    expect(onAttached).not.toHaveBeenCalled()
+  })
+
+  it('should explain why a running attack cannot be attached yet', () => {
+    render(<TestWrapper><AttachToFindingsButton attackResultId="attack-1" disabled /></TestWrapper>)
+    const button = screen.getByRole('button', { name: 'Attach to findings' })
+    expect(button).toBeDisabled()
+    expect(button).toHaveAttribute('title', 'Available after the attack finishes')
+  })
+})
diff --git a/frontend/src/components/Chat/AttachToFindingsButton.tsx b/frontend/src/components/Chat/AttachToFindingsButton.tsx
new file mode 100644
index 0000000000..8f5e06688a
--- /dev/null
+++ b/frontend/src/components/Chat/AttachToFindingsButton.tsx
@@ -0,0 +1,37 @@
+import { useRef, useState } from 'react'
+
+import { Button } from '@fluentui/react-components'
+import { AttachRegular } from '@fluentui/react-icons'
+
+import { useAttachToFindingsButtonStyles } from './AttachToFindingsButton.styles'
+import FindingEvidenceDialog from './FindingEvidenceDialog'
+
+interface AttachToFindingsButtonProps {
+  readonly attackResultId: string
+  /** The Operation offered first when the attack has no Operation of its own. */
+  readonly defaultOperationId?: string | null
+  /** Running attacks cannot be attached until they are saved. */
+  readonly disabled?: boolean
+  /** Called after the attack is attached, such as to refresh `useAttackFindings`. */
+  readonly onAttached?: () => void
+}
+
+/** Opens the finding picker to attach one attack as evidence, returning focus to the button. */
+export default function AttachToFindingsButton({
+  attackResultId, defaultOperationId = null, disabled = false, onAttached,
+}: AttachToFindingsButtonProps) {
+  const styles = useAttachToFindingsButtonStyles()
+  const [open, setOpen] = useState(false)
+  const trigger = useRef<HTMLButtonElement>(null)
+  return (
+    <>
+      <Button ref={trigger} className={styles.button} icon={<AttachRegular />} disabled={disabled}
+        title={disabled ? 'Available after the attack finishes' : 'Attach this attack as evidence to a finding'}
+        onClick={() => { setOpen(true) }}>
+        Attach to findings
+      </Button>
+      <FindingEvidenceDialog attackResultId={attackResultId} disabled={disabled} defaultOperationId={defaultOperationId}
+        open={open} onOpenChange={setOpen} returnFocusRef={trigger} onAttached={onAttached} />
+    </>
+  )
+}
diff --git a/frontend/src/components/Chat/AttackInProgressBar.styles.ts b/frontend/src/components/Chat/AttackInProgressBar.styles.ts
new file mode 100644
index 0000000000..19ef8b9e89
--- /dev/null
+++ b/frontend/src/components/Chat/AttackInProgressBar.styles.ts
@@ -0,0 +1,33 @@
+import { makeStyles, tokens } from '@fluentui/react-components'
+
+import { MINIMUM_TOUCH_TARGET_SIZE, NARROW_VIEWPORT_QUERY } from '@/styles/touchTargets'
+
+export const useAttackInProgressBarStyles = makeStyles({
+  root: {
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    flexWrap: 'wrap',
+    gap: tokens.spacingHorizontalL,
+    flexShrink: 0,
+    padding: `${tokens.spacingVerticalS} ${tokens.spacingHorizontalXL}`,
+    borderTop: `${tokens.strokeWidthThin} solid ${tokens.colorNeutralStroke2}`,
+    backgroundColor: tokens.colorNeutralBackground1,
+    [NARROW_VIEWPORT_QUERY]: {
+      paddingInline: tokens.spacingHorizontalL,
+    },
+  },
+  scanLink: {
+    display: 'inline-flex',
+    alignItems: 'center',
+    gap: tokens.spacingHorizontalXS,
+    minHeight: MINIMUM_TOUCH_TARGET_SIZE,
+    color: tokens.colorBrandForegroundLink,
+    textDecorationLine: 'none',
+    ':hover': { textDecorationLine: 'underline' },
+    ':focus-visible': {
+      outline: `${tokens.strokeWidthThick} solid ${tokens.colorStrokeFocus2}`,
+      borderRadius: tokens.borderRadiusSmall,
+    },
+  },
+})
diff --git a/frontend/src/components/Chat/AttackInProgressBar.test.tsx b/frontend/src/components/Chat/AttackInProgressBar.test.tsx
new file mode 100644
index 0000000000..3a5183b04a
--- /dev/null
+++ b/frontend/src/components/Chat/AttackInProgressBar.test.tsx
@@ -0,0 +1,41 @@
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { MemoryRouter, Route, Routes, useLocation } from 'react-router'
+
+import AttackInProgressBar from './AttackInProgressBar'
+
+function Destination() {
+  const location = useLocation()
+  return <h1 data-state={JSON.stringify(location.state)}>Scan</h1>
+}
+
+describe('AttackInProgressBar', () => {
+  it('returns a metadata-only fresh tab to scan history with fallback navigation state', async () => {
+    const user = userEvent.setup()
+    render(<FluentProvider theme={webLightTheme}><MemoryRouter initialEntries={['/chat']}>
+      <Routes>
+        <Route path="/chat" element={<AttackInProgressBar scanPath="/scan" />} />
+        <Route path="/scan" element={<Destination />} />
+      </Routes>
+    </MemoryRouter></FluentProvider>)
+    await user.click(screen.getByRole('link', { name: 'Back to scan' }))
+    expect(screen.getByRole('heading', { name: 'Scan' })).toHaveAttribute('data-state', '{"fromScenarioHistory":true}')
+  })
+
+  it('uses the return callback for ordinary clicks but preserves modified link navigation', async () => {
+    const user = userEvent.setup()
+    const onReturnToScan = jest.fn()
+    render(<FluentProvider theme={webLightTheme}><MemoryRouter>
+      <AttackInProgressBar scanPath="/scan" onReturnToScan={onReturnToScan} />
+    </MemoryRouter></FluentProvider>)
+    const link = screen.getByRole('link', { name: 'Back to scan' })
+    await user.click(link)
+    expect(onReturnToScan).toHaveBeenCalledTimes(1)
+    await user.keyboard('{Control>}')
+    await user.click(link)
+    await user.keyboard('{/Control}')
+    expect(onReturnToScan).toHaveBeenCalledTimes(1)
+    expect(link).toHaveAttribute('href', '/scan')
+  })
+})
diff --git a/frontend/src/components/Chat/AttackInProgressBar.tsx b/frontend/src/components/Chat/AttackInProgressBar.tsx
new file mode 100644
index 0000000000..01bf6c5d32
--- /dev/null
+++ b/frontend/src/components/Chat/AttackInProgressBar.tsx
@@ -0,0 +1,33 @@
+import { Link } from 'react-router'
+import { ArrowLeftRegular } from '@fluentui/react-icons'
+
+import AttackActivity from '@/components/Scenarios/AttackActivity'
+
+import { useAttackInProgressBarStyles } from './AttackInProgressBar.styles'
+
+interface AttackInProgressBarProps {
+  /** The scan running the attack, when known. */
+  readonly scanPath: string | null
+  /** Router state carried back to the scan, so its own back link still works. */
+  readonly scanState?: unknown
+  readonly onReturnToScan?: () => void
+}
+
+/** Takes the prompt bar's place while a scan is still running the attack shown in Chat. */
+export default function AttackInProgressBar({ scanPath, scanState, onReturnToScan }: AttackInProgressBarProps) {
+  const styles = useAttackInProgressBarStyles()
+  return (
+    <div className={styles.root} data-testid="attack-in-progress-bar">
+      <AttackActivity label="Attack in progress" />
+      {scanPath && <Link className={styles.scanLink} to={scanPath} state={scanState ?? { fromScenarioHistory: true }}
+        onClick={(event) => {
+          if (onReturnToScan && event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey) {
+            event.preventDefault()
+            onReturnToScan()
+          }
+        }}>
+        <ArrowLeftRegular aria-hidden="true" /> Back to scan
+      </Link>}
+    </div>
+  )
+}
diff --git a/frontend/src/components/Chat/ChatWindow.test.tsx b/frontend/src/components/Chat/ChatWindow.test.tsx
index 6f51334fde..0cf3784fb2 100644
--- a/frontend/src/components/Chat/ChatWindow.test.tsx
+++ b/frontend/src/components/Chat/ChatWindow.test.tsx
@@ -33,6 +33,7 @@ import {
 } from "@/types";
 import { attacksApi, convertersApi, mediaApi, scoresApi, targetsApi } from "@/services/api";
 import * as messageMapper from "@/utils/messageMapper";
+import { LIVE_ATTACK_POLL_INTERVAL_MS } from "@/hooks/useLiveAttackMetadata";
 
 jest.mock("./FindingEvidenceDialog", () => ({
   __esModule: true,
@@ -572,7 +573,7 @@ describe("ChatWindow Integration", () => {
     mockMatchMedia(false);
     // Default: panel API returns empty conversations
     mockedAttacksApi.getConversations.mockImplementation(async (attackId: string, params?: ConversationPageParams) => ({
-      attack_result_id: attackId, conversations: [], main_conversation_id: null,
+      attack_result_id: attackId, conversations: [], main_conversation_id: "main",
       ...(params ? { total_count: 0, pagination: { limit: params.limit ?? 50, has_more: false, next_cursor: null } } : {}),
     }));
     // Default: getMessages never resolves so loadConversation won't trigger
@@ -588,6 +589,123 @@ describe("ChatWindow Integration", () => {
     jest.restoreAllMocks();
   });
 
+  describe("running scan attack", () => {
+    const SCAN_ID = "123e4567-e89b-12d3-a456-426614174000";
+    const props = {
+      ...defaultProps, attackResultId: "live-attack", conversationId: "branch-1", activeConversationId: "branch-1",
+      executionReadOnly: true, inProgress: true, attackScenarioResultId: SCAN_ID, objective: "Live objective",
+    };
+    function liveRead(...texts: string[]): ConversationMessagesResponse {
+      return {
+        conversation_id: "branch-1", target_response_status: null,
+        messages: texts.map((text: string, index: number) => ({
+          turn_number: index, role: index % 2 === 0 ? "user" : "assistant", created_at: "2026-01-01T00:00:00Z",
+          message_pieces: [{
+            id: `piece-${index}`, original_value: text, converted_value: text, original_value_data_type: "text",
+            converted_value_data_type: "text", scores: [], response_error: "none",
+          }],
+        })),
+      };
+    }
+    const unavailable = { isAxiosError: true, response: { status: 503, data: { detail: "Live read unavailable" } } };
+
+    beforeEach(() => { jest.useFakeTimers(); });
+    afterEach(() => { jest.useRealTimers(); });
+
+    async function advancePoll(): Promise<void> {
+      await act(async () => { await jest.advanceTimersByTimeAsync(LIVE_ATTACK_POLL_INTERVAL_MS); });
+    }
+
+    it("replaces the prompt with an in-progress bar and refreshes the transcript in place", async () => {
+      mockedAttacksApi.getMessages.mockResolvedValueOnce(liveRead("Live prompt"))
+        .mockResolvedValueOnce(liveRead("Live prompt", "Live response"));
+      render(<TestWrapper><ChatWindow {...props} /></TestWrapper>);
+      expect(await screen.findByText("Live prompt", { exact: true })).toBeInTheDocument();
+      const bubble = screen.getByTestId("message-bubble-0");
+      const bar = screen.getByTestId("attack-in-progress-bar");
+      expect(bar).toHaveTextContent("Attack in progress");
+      expect(within(bar).getByRole("link", { name: "Back to scan" })).toHaveAttribute("href", `/scanner/history/${SCAN_ID}`);
+      expect(screen.queryByTestId("chat-input")).not.toBeInTheDocument();
+      expect(screen.queryByRole("button", { name: "Continue manually" })).not.toBeInTheDocument();
+      expect(screen.getByRole("button", { name: "Edit Conversation", exact: true })).toBeDisabled();
+      expect(mockedAttacksApi.getMessages).toHaveBeenLastCalledWith("live-attack", "branch-1");
+
+      await advancePoll();
+      expect(screen.getByText("Live response", { exact: true })).toBeInTheDocument();
+      expect(screen.getByTestId("message-bubble-0")).toBe(bubble);
+      expect(mockedAttacksApi.getMessages).toHaveBeenCalledTimes(2);
+    });
+
+    it("reloads the saved transcript in place once the attack finishes and stops polling", async () => {
+      let finishSaved: (response: ConversationMessagesResponse) => void = () => { throw new Error("No saved read") };
+      mockedAttacksApi.getMessages.mockResolvedValueOnce(liveRead("Live prompt", "Live response"))
+        .mockImplementationOnce(() => new Promise<ConversationMessagesResponse>((resolve) => { finishSaved = resolve; }));
+      const rendered = render(<TestWrapper><ChatWindow {...props} /></TestWrapper>);
+      expect(await screen.findByText("Live response", { exact: true })).toBeInTheDocument();
+      rendered.rerender(<TestWrapper><ChatWindow {...props} inProgress={false} outcome="success" /></TestWrapper>);
+      expect(mockedAttacksApi.getMessages).toHaveBeenLastCalledWith("live-attack", "branch-1", { limit: 100 });
+      expect(screen.queryByTestId("loading-state")).not.toBeInTheDocument();
+      expect(screen.getByText("Live response", { exact: true })).toBeInTheDocument();
+      expect(screen.queryByTestId("attack-in-progress-bar")).not.toBeInTheDocument();
+      expect(screen.getByTestId("chat-input")).toBeInTheDocument();
+      await act(async () => {
+        finishSaved({
+          ...liveRead("Live prompt", "Saved response"), pagination: { limit: 100, has_more: false, next_cursor: null },
+          partial_message_sequences: [],
+        });
+      });
+      expect(screen.getByText("Saved response", { exact: true })).toBeInTheDocument();
+      expect(screen.getByRole("region", { name: "Saved transcript paging" })).toHaveTextContent("End of saved transcript.");
+      await advancePoll();
+      await advancePoll();
+      expect(mockedAttacksApi.getMessages).toHaveBeenCalledTimes(2);
+    });
+
+    it("keeps loaded messages and offers Retry when a background refresh fails", async () => {
+      mockedAttacksApi.getMessages.mockResolvedValueOnce(liveRead("Live prompt")).mockRejectedValueOnce(unavailable)
+        .mockResolvedValueOnce(liveRead("Live prompt", "Recovered response"));
+      render(<TestWrapper><ChatWindow {...props} /></TestWrapper>);
+      expect(await screen.findByText("Live prompt", { exact: true })).toBeInTheDocument();
+      await advancePoll();
+      expect(screen.getByText(/Could not load conversation: Live read unavailable/)).toBeInTheDocument();
+      expect(screen.getByText("Live prompt", { exact: true })).toBeInTheDocument();
+      fireEvent.click(screen.getByRole("button", { name: "Retry conversation load" }));
+      expect(await screen.findByText("Recovered response", { exact: true })).toBeInTheDocument();
+      expect(screen.queryByText(/Could not load conversation/)).not.toBeInTheDocument();
+    });
+
+    it("does not show the previous branch while another branch loads", async () => {
+      mockedAttacksApi.getMessages.mockResolvedValueOnce(liveRead("First branch prompt"))
+        .mockImplementationOnce(() => new Promise<ConversationMessagesResponse>(() => {}));
+      const rendered = render(<TestWrapper><ChatWindow {...props} /></TestWrapper>);
+      expect(await screen.findByText("First branch prompt", { exact: true })).toBeInTheDocument();
+      rendered.rerender(<TestWrapper><ChatWindow {...props} activeConversationId="branch-2" /></TestWrapper>);
+      expect(screen.getByTestId("loading-state")).toBeInTheDocument();
+      expect(screen.queryByText("First branch prompt", { exact: true })).not.toBeInTheDocument();
+      expect(mockedAttacksApi.getMessages).toHaveBeenLastCalledWith("live-attack", "branch-2");
+    });
+
+    it("refreshes the whole conversation list while the attack runs", async () => {
+      mockedAttacksApi.getMessages.mockResolvedValue(liveRead("Live prompt"));
+      mockedAttacksApi.getConversations.mockResolvedValueOnce({
+        attack_result_id: "live-attack", main_conversation_id: "branch-1",
+        conversations: [{ conversation_id: "branch-1", message_count: 1, created_at: "2026-01-01T00:00:00Z" }],
+      }).mockResolvedValue({
+        attack_result_id: "live-attack", main_conversation_id: "branch-2",
+        conversations: [
+          { conversation_id: "branch-1", message_count: 2, created_at: "2026-01-01T00:00:00Z" },
+          { conversation_id: "branch-2", message_count: 1, created_at: "2026-01-01T00:00:01Z" },
+        ],
+      });
+      render(<TestWrapper><ChatWindow {...props} relatedConversationCount={1} /></TestWrapper>);
+      expect(await screen.findByTestId("conversation-item-branch-1")).toBeInTheDocument();
+      expect(mockedAttacksApi.getConversations).toHaveBeenLastCalledWith("live-attack");
+      const row = screen.getByTestId("conversation-item-branch-1");
+      await advancePoll();
+      expect(screen.getByTestId("conversation-item-branch-2")).toBeInTheDocument();
+      expect(screen.getByTestId("conversation-item-branch-1")).toBe(row);
+    });
+  });
   describe("bounded saved evidence", () => {
     const props = {
       ...defaultProps, attackResultId: "saved-attack", conversationId: "saved-main",
@@ -3766,13 +3884,14 @@ describe("ChatWindow Integration", () => {
     const scenarioResultId = "123e4567-e89b-12d3-a456-426614174000";
     const { rerender } = render(
       <TestWrapper>
-        <ChatWindow {...defaultProps} scenarioResultId={scenarioResultId} />
+        <ChatWindow {...defaultProps} scenarioResultId={scenarioResultId} inProgress attackScenarioResultId={scenarioResultId} />
       </TestWrapper>
     );
 
     expect(within(screen.getByRole("group", { name: "Conversation actions" })).getByRole("link", {
       name: "Back to scan",
     })).toHaveAttribute("href", `/scanner/history/${scenarioResultId}`);
+    expect(screen.getAllByRole("link", { name: "Back to scan" })).toHaveLength(1);
 
     rerender(
       <TestWrapper>
@@ -3802,7 +3921,7 @@ describe("ChatWindow Integration", () => {
           <Routes>
             <Route
               path="/attack/chat/:attackResultId"
-              element={<ChatWindow {...defaultProps} scenarioResultId={scenarioResultId} />}
+              element={<ChatWindow {...defaultProps} scenarioResultId={scenarioResultId} inProgress />}
             />
             <Route
               path="/scanner/history/:scenarioResultId"
@@ -3826,6 +3945,17 @@ describe("ChatWindow Integration", () => {
       .toHaveAttribute("data-navigation-state", JSON.stringify(navigationState));
   });
 
+  it("uses the only scan return link for the return callback while running", async () => {
+    const user = userEvent.setup();
+    const onReturnToScan = jest.fn();
+    render(<TestWrapper><ChatWindow {...defaultProps} inProgress scenarioResultId="scan"
+      attackScenarioResultId="scan" onReturnToScan={onReturnToScan} /></TestWrapper>);
+    await user.click(screen.getByRole("link", { name: "Back to scan" }));
+    expect(onReturnToScan).toHaveBeenCalledTimes(1);
+    expect(within(screen.getByTestId("attack-in-progress-bar")).queryByRole("link", { name: "Back to scan" }))
+      .not.toBeInTheDocument();
+  });
+
   it("should apply and persist the Markdown choice across remounts", async () => {
     const user = userEvent.setup();
     mockedAttacksApi.getMessages.mockResolvedValue(makeTextResponse("**Hello**").messages);
diff --git a/frontend/src/components/Chat/ChatWindow.tsx b/frontend/src/components/Chat/ChatWindow.tsx
index 88c0def851..f3d8262645 100644
--- a/frontend/src/components/Chat/ChatWindow.tsx
+++ b/frontend/src/components/Chat/ChatWindow.tsx
@@ -34,7 +34,7 @@ import ChatTargetPicker from './ChatTargetPicker'
 import { generateClientId } from '@/utils/clientId'
 import FileDropZone from '@/components/Media/FileDropZone'
 import ObjectiveHeader from './ObjectiveHeader'
-import type { ApplyScorerStatus, RegisteredComponentReference, ScoringFailure, ManualContinuation, ScorerInstance, RequestGenerationDraft } from '@/types'
+import type { ApplyScorerStatus, RegisteredComponentReference, ScoringFailure, ManualContinuation, ScorerInstance, RequestGenerationDraft, ReadAttackConversationReferences } from '@/types'
 import ConversationEditor from './ConversationEditor'
 import type { ConversationEditorHandle } from './ConversationEditor'
 import {
@@ -118,6 +118,8 @@ import type {
 } from '../../types'
 import { isTargetResolutionBlocking, targetInfoMatchesTarget } from '../../utils/targetIdentity'
 import { attackConversationRoutePath, scenarioRunRoutePath } from '../../utils/routeParams'
+import { LIVE_ATTACK_POLL_INTERVAL_MS } from '@/hooks/useLiveAttackMetadata'
+import AttackInProgressBar from './AttackInProgressBar'
 import type { ViewName } from '../Sidebar/Navigation'
 import { CHAT_NOTICE_FADE_DURATION_MS, useChatWindowStyles } from './ChatWindow.styles'
 
@@ -362,6 +364,10 @@ interface ChatWindowProps {
   chatScorer?: RegisteredComponentReference | null
   chatScorerInherited?: boolean
   executionReadOnly?: boolean
+  /** A scan is still running this attack: its transcript and conversations refresh until the result is saved. */
+  inProgress?: boolean
+  /** The scan run that produced this attack, for returning to it while the attack runs. */
+  attackScenarioResultId?: string | null
   manualContinuation?: ManualContinuation | null
   defaultChatScorer?: RegisteredComponentReference | null
   availableScorers?: ScorerInstance[]
@@ -373,6 +379,9 @@ interface ChatWindowProps {
   scenarioResultId?: string | null
   onReturnToScan?: () => void
   findingEvidenceId?: string | null
+  /** Verified scan-scoped readers for recorded evidence without a saved attack result. */
+  readConversationById?: (conversationId: string) => Promise<ConversationMessagesResponse>
+  readConversations?: ReadAttackConversationReferences
 }
 
 export default function ChatWindow({
@@ -412,6 +421,8 @@ export default function ChatWindow({
   chatScorer = null,
   chatScorerInherited = false,
   executionReadOnly = false,
+  inProgress = false,
+  attackScenarioResultId = null,
   manualContinuation,
   defaultChatScorer,
   availableScorers = [],
@@ -422,6 +433,8 @@ export default function ChatWindow({
   scenarioResultId,
   onReturnToScan,
   findingEvidenceId,
+  readConversationById,
+  readConversations,
 }: ChatWindowProps) {
   const styles = useChatWindowStyles()
   const transcriptStatusId = useId()
@@ -524,6 +537,12 @@ export default function ChatWindow({
   const globalMarkdown = preferences.chatMarkdown
   const location = useLocation()
   const viewedConversationId = activeConversationId ?? conversationId
+  const transcriptKey = JSON.stringify([attackResultId, viewedConversationId])
+  const [transcriptSource, setTranscriptSource] = useState({ key: transcriptKey, openedLive: inProgress })
+  if (transcriptSource.key !== transcriptKey || (inProgress && !transcriptSource.openedLive)) {
+    setTranscriptSource({ key: transcriptKey, openedLive: inProgress })
+  }
+  const preservesLiveLayout = transcriptSource.key === transcriptKey && transcriptSource.openedLive
   useLayoutEffect(() => {
     const area = chatAreaRef.current
     if (area && (executionReadOnly || wasSavedEvidenceRef.current)) area.scrollTop = 0
@@ -684,6 +703,9 @@ export default function ChatWindow({
     }
     return frontendMessages
   }, [])
+  // Saved evidence is read in bounded pages; a running scan attack is re-read whole as it grows.
+  const pagesSavedEvidence = executionReadOnly && !inProgress && !readConversationById
+  const rendersSavedEvidence = pagesSavedEvidence && !preservesLiveLayout
   const {
     messages,
     setMessages,
@@ -714,12 +736,17 @@ export default function ChatWindow({
     conversationId,
     activeConversationId,
     findingEvidenceId,
-    messagePageSize: executionReadOnly ? SAVED_MESSAGE_PAGE_SIZE : undefined,
+    readConversationById,
+    messagePageSize: pagesSavedEvidence ? SAVED_MESSAGE_PAGE_SIZE : undefined,
+    pollIntervalMs: inProgress ? LIVE_ATTACK_POLL_INTERVAL_MS : undefined,
     sendingConversations,
     isSendInFlight,
     onConversationLoaded: handleConversationLoaded,
   })
   const incompleteTranscriptReason = isTranscriptIncomplete ? INCOMPLETE_TRANSCRIPT_REASON : undefined
+  // Refreshes of a running attack, including the reload when it finishes, keep the shown transcript in place.
+  const refreshesInPlace = preservesLiveLayout && loadedConversationId === viewedConversationId
+  const liveScanId = scenarioResultId ?? attackScenarioResultId
   const loadedPieceSummary = `${loadedPieceCount} message ${loadedPieceCount === 1 ? 'piece' : 'pieces'} loaded.`
   const savedRecovery = viewedConversationId
     ? recoverableSends[viewedConversationId]
@@ -981,7 +1008,7 @@ export default function ChatWindow({
     setSystemPrompt('')
   }
 
-  const isFindingActionDisabled = Boolean(editDraft !== null || !attackResultId || !activeConversationId
+  const isFindingActionDisabled = Boolean(readConversationById || editDraft !== null || !attackResultId || !activeConversationId
     || isEvidenceUnavailable || isLoadingAttack || isLoadingMessages || awaitingConversationLoad || isTranscriptIncomplete)
 
   const pending = draftHandoff.pendingImport
@@ -2393,7 +2420,9 @@ export default function ChatWindow({
     : isTargetResolutionLocked ? 'The source target cannot be safely resolved. Choose New attack.'
     : targetResolutionStatus !== 'unbound' && activeTarget ? historyReplayDisabledReason(activeTarget, editor.history)
     : undefined
-  const newAttackDisabledReason = !runtime.ready || !defaultsReady
+  const newAttackDisabledReason = readConversationById
+    ? 'No attack result was saved for this interrupted scan.'
+    : !runtime.ready || !defaultsReady
     ? newActivityBlockedReason ?? 'Default labels are not ready. Retry after default labels finish loading.'
     : !scorerSelectionReady ? 'The remembered chat scorer is loading. Wait for it to load.'
     : undefined
@@ -2681,22 +2710,24 @@ export default function ChatWindow({
           controller={converters}
         />
       )}
-      <FileDropZone ref={chatAreaRef} className={mergeClasses(styles.chatArea, executionReadOnly && styles.savedChatArea)} testId="chat-area"
+      <FileDropZone ref={chatAreaRef} className={mergeClasses(styles.chatArea, rendersSavedEvidence && styles.savedChatArea)} testId="chat-area"
         disabled={inputDisabledReasons.length > 0}
         disabledReason={inputDisabledReasons.join(' ')}
         onFiles={(files: File[]) => inputBoxRef.current?.addFiles(files)}>
         {toolbarContainer ? createPortal(toolbar, toolbarContainer) : toolbar}
-        {executionReadOnly && <MessageBar intent="info">
+        {executionReadOnly && !inProgress && <MessageBar intent="info">
           <MessageBarBody>
-            This automated result is read-only. Continue in a separate manual attack to keep the original execution unchanged.
+            {readConversationById
+              ? 'Recorded conversation from an interrupted scan. No attack outcome was saved.'
+              : 'This automated result is read-only. Continue in a separate manual attack to keep the original execution unchanged.'}
           </MessageBarBody>
-          <MessageBarActions><Button className={styles.ribbonAction}
+          {!readConversationById && <MessageBarActions><Button className={styles.ribbonAction}
             disabled={isLoadingEdit || isLoadingAttack || isLoadingMessages || awaitingConversationLoad
               || isTranscriptIncomplete || Boolean(newAttackDisabledReason)}
             aria-describedby={messagePagination && isTranscriptIncomplete ? transcriptDisabledReasonId : undefined}
             onClick={() => { void copyConversation(recoverableSend?.failedRequestMessageIndex ?? messages.length - 1, 'new_attack') }}>
             {isLoadingEdit ? 'Creating continuation...' : 'Continue manually'}
-          </Button></MessageBarActions>
+          </Button></MessageBarActions>}
         </MessageBar>}
         {manualContinuation && <MessageBar intent="info"><MessageBarBody>
           Manual continuation of{' '}
@@ -2838,9 +2869,9 @@ export default function ChatWindow({
           getBranchConversationDescription={(index: number) => activeTarget && canBranchFirstPrompt(activeTarget, messages, index)
             ? 'Restore this prompt as an unsent draft in a new conversation in the same attack. The response is not copied.'
             : undefined}
-          isLoading={isLoadingAttack || isLoadingMessages || awaitingConversationLoad}
-          autoScroll={!executionReadOnly}
-          savedEvidence={executionReadOnly}
+          isLoading={isLoadingAttack || awaitingConversationLoad || (isLoadingMessages && !refreshesInPlace)}
+          savedEvidence={rendersSavedEvidence}
+          announceUpdates={!executionReadOnly || inProgress || preservesLiveLayout}
           globalMarkdown={globalMarkdown}
           onEditConversation={executionReadOnly ? undefined : () => { void beginEdit() }}
         />}
@@ -2914,7 +2945,9 @@ export default function ChatWindow({
             </MessageBarActions>
           </MessageBar>
         )}
-        <div hidden={editDraft !== null}>
+        {inProgress ? <AttackInProgressBar scanPath={!scenarioResultId && liveScanId ? scenarioRunRoutePath(liveScanId) : null}
+          scanState={location.state} onReturnToScan={onReturnToScan} />
+          : <div hidden={editDraft !== null}>
         <ChatInputArea
           fileDropEnabled={false}
           ref={inputBoxRef}
@@ -2972,7 +3005,7 @@ export default function ChatWindow({
             .map(([, conversion]) => conversion)}
           onClearMediaConversion={converters.clear}
         />
-        </div>
+        </div>}
       </FileDropZone>
       <Drawer
         as="aside"
@@ -2990,7 +3023,9 @@ export default function ChatWindow({
       >
         <ConversationPanel
           attackResultId={attackResultId}
-          referencePageSize={executionReadOnly ? SAVED_REFERENCE_PAGE_SIZE : undefined}
+          referencePageSize={pagesSavedEvidence ? SAVED_REFERENCE_PAGE_SIZE : undefined}
+          pollIntervalMs={inProgress ? LIVE_ATTACK_POLL_INTERVAL_MS : undefined}
+          readConversations={readConversations}
           activeConversationId={activeConversationId}
           onSelectConversation={handlePanelSelectConversation}
           onNewConversation={handleNewConversation}
diff --git a/frontend/src/components/Chat/ConversationPanel.test.tsx b/frontend/src/components/Chat/ConversationPanel.test.tsx
index 11233ddd03..ccfef8f29e 100644
--- a/frontend/src/components/Chat/ConversationPanel.test.tsx
+++ b/frontend/src/components/Chat/ConversationPanel.test.tsx
@@ -32,6 +32,73 @@ describe("ConversationPanel", () => {
     jest.clearAllMocks();
   });
 
+  it("preserves unknown recorded-only counts and main identity through the view reader", async () => {
+    const readConversations = jest.fn(async () => ({
+      attack_result_id: defaultProps.attackResultId, main_conversation_id: null,
+      conversations: [{ conversation_id: "recorded", message_count: null }],
+    }));
+    render(<TestWrapper><ConversationPanel {...defaultProps} readConversations={readConversations}
+      lockedReason="Recorded evidence is read-only." /></TestWrapper>);
+    const row = await screen.findByRole("button", { name: "Select conversation recorded" });
+    expect(within(row).getByText("Not counted")).toBeInTheDocument();
+    expect(within(row).queryByRole("button", { name: "Main conversation recorded" })).not.toBeInTheDocument();
+    expect(mockedAttacksApi.getConversations).not.toHaveBeenCalled();
+  });
+
+  describe("live polling", () => {
+    const conversation = (id: string, count: number): ConversationSummary => ({ conversation_id: id, message_count: count })
+    beforeEach(() => { jest.useFakeTimers(); });
+    afterEach(() => { jest.useRealTimers(); });
+
+    it("should settle a slow read without overlapping polls and discard a prior attack's late response", async () => {
+      let finishFirst: (response: AttackConversationsResponse) => void = () => { throw new Error("No first read"); };
+      let finishNext: (response: AttackConversationsResponse) => void = () => { throw new Error("No next read"); };
+      mockedAttacksApi.getConversations.mockReset();
+      mockedAttacksApi.getConversations
+        .mockResolvedValue({ attack_result_id: "other", main_conversation_id: "other-main", conversations: [] })
+        .mockImplementationOnce(() => new Promise<AttackConversationsResponse>((resolve) => { finishFirst = resolve; }))
+        .mockImplementationOnce(() => new Promise<AttackConversationsResponse>((resolve) => { finishNext = resolve; }));
+      const rendered = render(<TestWrapper><ConversationPanel {...defaultProps} pollIntervalMs={2_500} /></TestWrapper>);
+      await act(async () => { await jest.advanceTimersByTimeAsync(7_500); });
+      expect(mockedAttacksApi.getConversations).toHaveBeenCalledTimes(1);
+      await act(async () => {
+        finishFirst({ attack_result_id: defaultProps.attackResultId, main_conversation_id: "attack-123", conversations: [conversation("attack-123", 1)] });
+      });
+      expect(screen.getByTestId("conversation-item-attack-123")).toBeInTheDocument();
+      await act(async () => { await jest.advanceTimersByTimeAsync(2_500); });
+      expect(mockedAttacksApi.getConversations).toHaveBeenCalledTimes(2);
+      rendered.rerender(<TestWrapper><ConversationPanel {...defaultProps} attackResultId="other" pollIntervalMs={2_500} /></TestWrapper>);
+      await act(async () => {
+        finishNext({ attack_result_id: defaultProps.attackResultId, main_conversation_id: "stale", conversations: [conversation("stale", 1)] });
+      });
+      expect(screen.queryByTestId("conversation-item-stale")).not.toBeInTheDocument();
+      rendered.unmount();
+      const calls = mockedAttacksApi.getConversations.mock.calls.length;
+      await act(async () => { await jest.advanceTimersByTimeAsync(10_000); });
+      expect(mockedAttacksApi.getConversations).toHaveBeenCalledTimes(calls);
+    });
+
+    it("should refresh at the poll interval, keep rows through a failed read, and recover", async () => {
+      mockedAttacksApi.getConversations
+        .mockResolvedValueOnce({ attack_result_id: "ar-attack-123", main_conversation_id: "attack-123", conversations: [conversation("attack-123", 1)] })
+        .mockRejectedValueOnce({ isAxiosError: true, response: { status: 503, data: { detail: "Live references unavailable" } } })
+        .mockResolvedValueOnce({
+          attack_result_id: "ar-attack-123", main_conversation_id: "branch-2",
+          conversations: [conversation("attack-123", 2), conversation("branch-2", 1)],
+        });
+      render(<TestWrapper><ConversationPanel {...defaultProps} pollIntervalMs={2_500} /></TestWrapper>);
+      const row = await screen.findByTestId("conversation-item-attack-123");
+      await act(async () => { await jest.advanceTimersByTimeAsync(2_500); });
+      expect(screen.getByText("Live references unavailable")).toBeInTheDocument();
+      expect(screen.getByTestId("conversation-item-attack-123")).toBe(row);
+      expect(screen.getByTestId("conversation-retry-btn")).toBeInTheDocument();
+      await act(async () => { await jest.advanceTimersByTimeAsync(2_500); });
+      expect(screen.queryByText("Live references unavailable")).not.toBeInTheDocument();
+      expect(screen.getByTestId("conversation-item-branch-2")).toBeInTheDocument();
+      expect(screen.getByTestId("conversation-item-attack-123")).toBe(row);
+      expect(mockedAttacksApi.getConversations.mock.calls).toEqual([["ar-attack-123"], ["ar-attack-123"], ["ar-attack-123"]]);
+    });
+  });
   describe("bounded saved references", () => {
     const props = { ...defaultProps, referencePageSize: 50 };
     const references: ConversationSummary[] = Array.from({ length: 55 }, (_value: unknown, index: number) => ({
diff --git a/frontend/src/components/Chat/ConversationPanel.tsx b/frontend/src/components/Chat/ConversationPanel.tsx
index 356ca08700..b1abbf0873 100644
--- a/frontend/src/components/Chat/ConversationPanel.tsx
+++ b/frontend/src/components/Chat/ConversationPanel.tsx
@@ -21,21 +21,21 @@ import {
 } from '@fluentui/react-icons'
 import { attacksApi } from '@/services/api'
 import { toApiError } from '@/services/errors'
-import type { AttackConversationsResponse, ConversationSummary } from '@/types'
+import type { AttackConversationReferencesView, ConversationReferenceView, ReadAttackConversationReferences } from '@/types'
 import { useConversationPanelStyles } from './ConversationPanel.styles'
 
 interface SavedReferencePage {
   attackResultId: string
   pageSize: number
   refreshKey?: number
-  response: AttackConversationsResponse
+  response: AttackConversationReferencesView
   consumedCursors: ReadonlySet<string>
 }
 
 function mergeReferencePage(
-  previous: AttackConversationsResponse | null, incoming: AttackConversationsResponse, attackResultId: string,
+  previous: AttackConversationReferencesView | null, incoming: AttackConversationReferencesView, attackResultId: string,
   cursor?: string, consumedCursors?: ReadonlySet<string>,
-): AttackConversationsResponse {
+): AttackConversationReferencesView {
   const pagination = incoming.pagination
   if (incoming.attack_result_id !== attackResultId || !pagination || typeof pagination.has_more !== 'boolean'
     || !Number.isInteger(pagination.limit) || pagination.limit < 1 || pagination.limit > 200
@@ -45,7 +45,7 @@ function mergeReferencePage(
     || (previous && (previous.main_conversation_id !== incoming.main_conversation_id || previous.total_count !== incoming.total_count))) {
     throw new Error('The server returned changed or invalid conversation references. Restart reference loading.')
   }
-  const conversations = new Map<string, ConversationSummary>()
+  const conversations = new Map<string, ConversationReferenceView>()
   for (const conversation of [...(previous?.conversations ?? []), ...incoming.conversations]) {
     conversations.set(conversation.conversation_id, conversation)
   }
@@ -65,6 +65,10 @@ interface ConversationPanelProps {
   refreshKey?: number
   /** Saved evidence pages references independently from the selected transcript. */
   referencePageSize?: number
+  /** Re-reads the unpaged list at this interval, keeping its rows, such as while a scan runs the attack. */
+  pollIntervalMs?: number
+  /** A verified read-only source for interrupted scan conversations without a saved result. */
+  readConversations?: ReadAttackConversationReferences
 }
 
 export default function ConversationPanel({
@@ -77,9 +81,11 @@ export default function ConversationPanel({
   lockedReason,
   refreshKey,
   referencePageSize,
+  pollIntervalMs,
+  readConversations = attacksApi.getConversations,
 }: ConversationPanelProps) {
   const styles = useConversationPanelStyles()
-  const [unpagedConversations, setUnpagedConversations] = useState<ConversationSummary[]>([])
+  const [unpagedConversations, setUnpagedConversations] = useState<ConversationReferenceView[]>([])
   const [unpagedMainConversationId, setUnpagedMainConversationId] = useState<string | null>(null)
   const [savedReferencePage, setSavedReferencePage] = useState<SavedReferencePage | null>(null)
   const savedReferencePageRef = useRef<SavedReferencePage | null>(null)
@@ -98,6 +104,14 @@ export default function ConversationPanel({
   // calling setState synchronously in an effect body.
   const [retryCount, setRetryCount] = useState(0)
   const selectionRefreshId = referencePageSize === undefined ? activeConversationId : null
+  const [pollCount, setPollCount] = useState(0)
+  useEffect(() => {
+    if (!pollIntervalMs || !attackResultId) return
+    const timer = setInterval(() => {
+      if (activeReadRef.current === null) setPollCount((count: number) => count + 1)
+    }, pollIntervalMs)
+    return () => { clearInterval(timer) }
+  }, [pollIntervalMs, attackResultId])
 
   const saveReferencePage = useCallback((page: SavedReferencePage): void => {
     savedReferencePageRef.current = page
@@ -110,7 +124,7 @@ export default function ConversationPanel({
       savedReferencePageRef.current = null
     }
     return () => { activeReadRef.current = null }
-  }, [attackResultId, referencePageSize, refreshKey, retryCount, selectionRefreshId])
+  }, [attackResultId, referencePageSize, refreshKey, retryCount, selectionRefreshId, readConversations])
 
   useEffect(() => {
     if (!attackResultId) {
@@ -121,8 +135,8 @@ export default function ConversationPanel({
     const readId = ++nextReadIdRef.current
     activeReadRef.current = readId
     const request = referencePageSize === undefined
-      ? attacksApi.getConversations(attackResultId)
-      : attacksApi.getConversations(attackResultId, { limit: referencePageSize })
+      ? readConversations(attackResultId)
+      : readConversations(attackResultId, { limit: referencePageSize })
     request
       .then((response) => {
         if (cancelled || activeReadRef.current !== readId) return
@@ -150,7 +164,7 @@ export default function ConversationPanel({
     return () => {
       cancelled = true
     }
-  }, [attackResultId, referencePageSize, selectionRefreshId, refreshKey, retryCount, saveReferencePage])
+  }, [attackResultId, referencePageSize, selectionRefreshId, refreshKey, retryCount, pollCount, saveReferencePage, readConversations])
 
   // Reset attack/paging identity, but retain keyed rows during manual background
   // refreshes so keyboard focus survives. Adjust state during render instead of
@@ -187,7 +201,7 @@ export default function ConversationPanel({
     let restartRequired = false
     const isCurrentRead = (): boolean => activeReadRef.current === readId && savedReferencePageRef.current === page
     try {
-      const incoming = await attacksApi.getConversations(page.attackResultId, { limit: page.pageSize, cursor })
+      const incoming = await readConversations(page.attackResultId, { limit: page.pageSize, cursor })
       if (!isCurrentRead()) return
       restartRequired = true
       const response = mergeReferencePage(page.response, incoming, page.attackResultId, cursor, page.consumedCursors)
@@ -215,7 +229,7 @@ export default function ConversationPanel({
   const hasLoadedConversations = currentPage !== null || (referencePageSize === undefined && unpagedConversations.length > 0)
   const showRows = (!isLoading || hasLoadedConversations) && (!error || hasLoadedConversations)
   const selectionOutsidePage = currentPage && activeConversationId
-    && !conversations.some((conversation: ConversationSummary) => conversation.conversation_id === activeConversationId)
+    && !conversations.some((conversation: ConversationReferenceView) => conversation.conversation_id === activeConversationId)
 
   return (
     <div id="conversation-panel" className={styles.root} data-testid="conversation-panel">
@@ -310,7 +324,7 @@ export default function ConversationPanel({
           </Text>
         )}
 
-        {showRows && conversations.map((conv: ConversationSummary) => {
+        {showRows && conversations.map((conv: ConversationReferenceView) => {
           const isActive = conv.conversation_id === activeConversationId
           const selectConversation = () => onSelectConversation(conv.conversation_id)
           return (
@@ -363,7 +377,7 @@ export default function ConversationPanel({
                     />
                   </Tooltip>
                   <Badge appearance="tint" size="small">
-                    {conv.message_count}
+                    {conv.message_count ?? 'Not counted'}
                   </Badge>
                 </div>
               </div>
diff --git a/frontend/src/components/Chat/FindingEvidenceDialog.tsx b/frontend/src/components/Chat/FindingEvidenceDialog.tsx
index d38aa2e7eb..4162ee49c4 100644
--- a/frontend/src/components/Chat/FindingEvidenceDialog.tsx
+++ b/frontend/src/components/Chat/FindingEvidenceDialog.tsx
@@ -28,6 +28,8 @@ interface FindingEvidenceDialogProps {
   onOpenChange: (open: boolean) => void
   /** Receives focus when the dialog closes, such as the control that opened it. */
   returnFocusRef?: React.RefObject<HTMLElement | null>
+  /** Called after the attack is linked to a finding, new or existing. */
+  onAttached?: () => void
 }
 
 interface AttachmentSource {
@@ -36,7 +38,7 @@ interface AttachmentSource {
 }
 
 export default function FindingEvidenceDialog({
-  attackResultId, disabled, defaultOperationId = null, open, onOpenChange, returnFocusRef,
+  attackResultId, disabled, defaultOperationId = null, open, onOpenChange, returnFocusRef, onAttached,
 }: FindingEvidenceDialogProps) {
   const styles = useFindingEvidenceDialogStyles()
   const viewKey = attackResultId
@@ -144,6 +146,7 @@ export default function FindingEvidenceDialog({
     setCreating(false)
     onOpenChange(false)
     setNotice({ key: viewKey, text: `Finding created and attack attached: ${finding.title}` })
+    onAttached?.()
   }
 
   const attach = async (): Promise<void> => {
@@ -158,6 +161,7 @@ export default function FindingEvidenceDialog({
       })
       setNotice({ key: viewKey, text: response.created ? 'Attached' : 'Already attached' })
       onOpenChange(false)
+      onAttached?.()
     } catch (cause: unknown) {
       setAttachError(toApiError(cause).detail)
     } finally {
diff --git a/frontend/src/components/Chat/MessageList.styles.ts b/frontend/src/components/Chat/MessageList.styles.ts
index 174c63ee6f..db408c6df1 100644
--- a/frontend/src/components/Chat/MessageList.styles.ts
+++ b/frontend/src/components/Chat/MessageList.styles.ts
@@ -241,50 +241,6 @@ export const useMessageListStyles = makeStyles({
     textOverflow: 'ellipsis',
     whiteSpace: 'nowrap',
   },
-  scoreSurface: {
-    display: 'flex',
-    flexDirection: 'column',
-    rowGap: tokens.spacingVerticalXS,
-    width: 'min(360px, calc(100vw - 64px))',
-    minWidth: 0,
-    maxWidth: '100%',
-  },
-  scoreRow: {
-    display: 'flex',
-    alignItems: 'flex-start',
-    columnGap: tokens.spacingHorizontalS,
-    width: '100%',
-    minWidth: 0,
-  },
-  scoreLabel: {
-    flex: '0 0 72px',
-    color: tokens.colorNeutralForeground2,
-  },
-  scoreValue: {
-    display: 'block',
-    flex: '0 1 auto',
-    minWidth: 0,
-    maxWidth: '100%',
-    height: 'auto',
-    whiteSpace: 'normal',
-    overflowWrap: 'anywhere',
-    wordBreak: 'break-word',
-  },
-  scoreRationale: {
-    display: 'flex',
-    flexDirection: 'column',
-    rowGap: tokens.spacingVerticalXXS,
-    marginTop: tokens.spacingVerticalXS,
-    paddingTop: tokens.spacingVerticalXS,
-    borderTop: `1px solid ${tokens.colorNeutralStroke2}`,
-  },
-  scoreRationaleText: {
-    color: tokens.colorNeutralForeground2,
-    whiteSpace: 'pre-wrap',
-    wordBreak: 'break-word',
-    maxHeight: '30vh',
-    overflowY: 'auto',
-  },
   loadingEllipsis: {
     fontSize: tokens.fontSizeBase500,
     animationName: {
diff --git a/frontend/src/components/Chat/MessageList.test.tsx b/frontend/src/components/Chat/MessageList.test.tsx
index 3ead04511a..bea70c4c53 100644
--- a/frontend/src/components/Chat/MessageList.test.tsx
+++ b/frontend/src/components/Chat/MessageList.test.tsx
@@ -49,26 +49,68 @@ describe("MessageList", () => {
 
   it("should label a split turn and preserve its bubble when ordered evidence is extended", () => {
     const first = { ...mockMessages[0], sequence: 0, isPartial: true };
-    const rendered = render(<TestWrapper><MessageList messages={[first]} autoScroll={false} /></TestWrapper>);
+    const rendered = render(<TestWrapper><MessageList messages={[first]} /></TestWrapper>);
     const bubble = screen.getByTestId("message-bubble-0");
     expect(screen.getByText("Incomplete turn")).toBeVisible();
-    rendered.rerender(<TestWrapper><MessageList autoScroll={false} messages={[
+    rendered.rerender(<TestWrapper><MessageList messages={[
       { ...mockMessages[1], role: "system", sequence: -1 }, { ...first, isPartial: false },
     ]} /></TestWrapper>);
     expect(screen.getByTestId("message-bubble-1")).toBe(bubble);
     expect(screen.queryByText("Incomplete turn")).not.toBeInTheDocument();
   });
 
-  it("should keep saved evidence in place while retaining live Chat auto-scroll", () => {
-    const scroll = jest.mocked(Element.prototype.scrollIntoView);
-    scroll.mockClear();
-    const rendered = render(<TestWrapper><MessageList messages={[mockMessages[0]]} autoScroll={false} /></TestWrapper>);
-    rendered.rerender(<TestWrapper><MessageList messages={mockMessages} autoScroll={false} /></TestWrapper>);
-    expect(scroll).not.toHaveBeenCalled();
+  it("should open at the latest message and follow new ones only while the reader stays near the end", () => {
+    const rendered = render(<TestWrapper><MessageList messages={[mockMessages[0]]} /></TestWrapper>);
+    const list = screen.getByTestId("message-list");
+    Object.defineProperties(list, {
+      scrollHeight: { configurable: true, writable: true, value: 1000 },
+      clientHeight: { configurable: true, value: 200 },
+    });
+    rendered.rerender(<TestWrapper><MessageList messages={mockMessages.slice(0, 2)} /></TestWrapper>);
+    expect(list.scrollTop).toBe(1000);
+    list.scrollTop = 770;
+    fireEvent.scroll(list);
+    Object.defineProperty(list, "scrollHeight", { value: 1200 });
     rendered.rerender(<TestWrapper><MessageList messages={mockMessages} /></TestWrapper>);
-    expect(scroll).toHaveBeenCalledTimes(1);
+    expect(list.scrollTop).toBe(1200);
+    list.scrollTop = 100;
+    fireEvent.scroll(list);
+    Object.defineProperty(list, "scrollHeight", { value: 1400 });
+    rendered.rerender(<TestWrapper><MessageList messages={[...mockMessages, mockMessages[1]]} /></TestWrapper>);
+    expect(list.scrollTop).toBe(100);
+    expect(screen.getByTestId("message-list")).toBe(list);
+    expect(Element.prototype.scrollIntoView).not.toHaveBeenCalled();
+  });
+
+  it("should preserve historical saved evidence position instead of following its inner non-scrolling body", () => {
+    const rendered = render(<TestWrapper><MessageList messages={[mockMessages[0]]} savedEvidence /></TestWrapper>);
+    const list = screen.getByTestId("message-list");
+    Object.defineProperties(list, {
+      scrollHeight: { configurable: true, writable: true, value: 900 },
+      clientHeight: { configurable: true, value: 300 },
+    });
+    rendered.rerender(<TestWrapper><MessageList messages={mockMessages.slice(0, 2)} savedEvidence announceUpdates={false} /></TestWrapper>);
+    expect(list.scrollTop).toBe(0);
+    expect(screen.queryByRole("log")).not.toBeInTheDocument();
+    list.scrollTop = 200;
+    fireEvent.scroll(list);
+    rendered.rerender(<TestWrapper><MessageList messages={mockMessages} savedEvidence /></TestWrapper>);
+    expect(list.scrollTop).toBe(200);
   });
 
+  it("should announce appended live messages politely without replacing existing keyed bubbles", () => {
+    const rendered = render(<TestWrapper><MessageList messages={[mockMessages[0]]} /></TestWrapper>);
+    const log = screen.getByRole("log");
+    const bubble = screen.getByTestId("message-bubble-0");
+    expect(log).toHaveAttribute("aria-live", "polite");
+    expect(log).toHaveAttribute("aria-relevant", "additions text");
+    expect(log).toHaveAttribute("aria-atomic", "false");
+    rendered.rerender(<TestWrapper><MessageList messages={mockMessages} /></TestWrapper>);
+    expect(screen.getByRole("log")).toBe(log);
+    expect(screen.getByTestId("message-bubble-0")).toBe(bubble);
+    rendered.rerender(<TestWrapper><MessageList messages={mockMessages} /></TestWrapper>);
+    expect(screen.getByTestId("message-bubble-0")).toBe(bubble);
+  });
   it.each([2, 3])("should retain gapped sequence %s beside optimistic user and loading rows without duplicate keys", (sequence: number) => {
     const errors = jest.spyOn(console, "error").mockImplementation(() => {});
     const stored: Message[] = [
diff --git a/frontend/src/components/Chat/MessageList.tsx b/frontend/src/components/Chat/MessageList.tsx
index 28f96dacdd..08e4814a8d 100644
--- a/frontend/src/components/Chat/MessageList.tsx
+++ b/frontend/src/components/Chat/MessageList.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from 'react'
+import { useEffect, useId, useLayoutEffect, useMemo, useRef, useState, type UIEvent } from 'react'
 import {
   Text,
   Avatar,
@@ -31,9 +31,11 @@ import MarkdownContent from '@/components/Markdown/MarkdownContent'
 import MediaPreview from '@/components/Media/MediaPreview'
 
 import type { DisplayScore, Message, MessageAttachment } from '@/types'
+import { scoreSummaryFromBackendScore, scoreSummaryValue } from '@/utils/scoreSummary'
 
 import { useMessageListStyles } from './MessageList.styles'
 import { formatStructuredMessage, getRenderMessagePieces } from './messageViewModel'
+import ScoreDetails from './ScoreDetails'
 
 interface MessageListProps {
   onEditConversation?: () => void
@@ -51,10 +53,10 @@ interface MessageListProps {
   getBranchConversationDescription?: (messageIndex: number) => string | undefined
   /** True while loading a historical attack's messages */
   isLoading?: boolean
-  /** Live Chat follows the latest response; saved evidence keeps the reader's position. */
-  autoScroll?: boolean
   /** Saved evidence uses one scroll surface with its controls on narrow screens. */
   savedEvidence?: boolean
+  /** Announce new live/manual messages, not an initial page of historical evidence. */
+  announceUpdates?: boolean
   /** Only show temperature evidence when the viewed target supports runtime temperature. */
   showGenerationInfo?: boolean
   /** Conversation-wide default: render message text as Markdown. */
@@ -62,51 +64,13 @@ interface MessageListProps {
 }
 
 function scoreDisplayValue(score: DisplayScore): string {
-  // An undetermined score has no value, so name its status instead.
-  return score.score_value ?? score.status ?? ''
+  return scoreSummaryValue(scoreSummaryFromBackendScore(score))
 }
 
 function scoreDisplayLabel(score: DisplayScore): string {
   return `${score.is_objective_score ? 'Final score' : 'Score'}: ${scoreDisplayValue(score)}`
 }
 
-function ScoreDetails({ score, testId }: { score: DisplayScore; testId: string }) {
-  const styles = useMessageListStyles()
-  const categories = score.score_category?.filter(Boolean) ?? []
-
-  return (
-    <div className={styles.scoreSurface} data-testid={testId}>
-      <Text weight="semibold">Score details</Text>
-      <div className={styles.scoreRow}>
-        <Text size={200} weight="semibold" className={styles.scoreLabel}>Score</Text>
-        <Badge appearance="tint" color="brand" size="small" className={styles.scoreValue}>{scoreDisplayValue(score)}</Badge>
-      </div>
-      <div className={styles.scoreRow}>
-        <Text size={200} weight="semibold" className={styles.scoreLabel}>Scorer</Text>
-        <Text size={200} className={styles.scoreValue}>{score.scorer_type}</Text>
-      </div>
-      <div className={styles.scoreRow}>
-        <Text size={200} weight="semibold" className={styles.scoreLabel}>Result role</Text>
-        <Text size={200} className={styles.scoreValue}>
-          {score.is_objective_score ? 'Final score' : 'Supporting score'}
-        </Text>
-      </div>
-      {categories.length > 0 && (
-        <div className={styles.scoreRow}>
-          <Text size={200} weight="semibold" className={styles.scoreLabel}>Category</Text>
-          <Text size={200} className={styles.scoreValue}>{categories.join(', ')}</Text>
-        </div>
-      )}
-      {score.score_rationale && (
-        <div className={styles.scoreRationale}>
-          <Text size={200} weight="semibold">Rationale</Text>
-          <Text size={200} className={styles.scoreRationaleText}>{score.score_rationale}</Text>
-        </div>
-      )}
-    </div>
-  )
-}
-
 function MessageScore({ score, groupId, scoreIndex }: { score: DisplayScore; groupId: string | number; scoreIndex: number }) {
   const styles = useMessageListStyles()
   const displayValue = scoreDisplayValue(score)
@@ -130,7 +94,7 @@ function MessageScore({ score, groupId, scoreIndex }: { score: DisplayScore; gro
         </PopoverTrigger>
       </Tooltip>
       <PopoverSurface>
-        <ScoreDetails score={score} testId={`message-score-details-${groupId}-${scoreIndex}`} />
+        <ScoreDetails score={scoreSummaryFromBackendScore(score)} testId={`message-score-details-${groupId}-${scoreIndex}`} />
       </PopoverSurface>
     </Popover>
   )
@@ -167,6 +131,8 @@ interface ScoreOverflowMenuProps {
 const SCORE_TAB_WIDTH_PX = 152
 const SCORE_TAB_GAP_PX = 4
 const SCORE_OVERFLOW_BUTTON_WIDTH_PX = 112
+// Readers this close to the end keep following new messages; scrolling further up keeps their place.
+const FOLLOW_LATEST_THRESHOLD_PX = 48
 
 function scoreTabLabel({
   score,
@@ -429,7 +395,7 @@ function MessageScores({ scores, groupId }: { scores: DisplayScore[]; groupId: s
             id={`message-score-panel-${groupId}`}
             aria-labelledby={`message-score-tab-${groupId}-${selectedIndex}`}
           >
-            <ScoreDetails score={selectedScore} testId={`message-score-details-${groupId}-${selectedIndex}`} />
+            <ScoreDetails score={scoreSummaryFromBackendScore(selectedScore)} testId={`message-score-details-${groupId}-${selectedIndex}`} />
           </div>
         </PopoverSurface>
       </Popover>
@@ -447,10 +413,12 @@ export default function MessageList({
   messages, onCopyToInput, onCopyToNewConversation, onCopyToNewAttack, onUseInTechnique, copyConversationDisabled = false,
   copyConversationDisabledReason,
   newConversationDisabledReason, getBranchConversationDisabledReason, getBranchConversationDescription, copyToInputDisabledReason,
-  isLoading, autoScroll = true, savedEvidence = false, showGenerationInfo = false, globalMarkdown = false, onEditConversation,
+  isLoading, savedEvidence = false, announceUpdates = !savedEvidence, showGenerationInfo = false, globalMarkdown = false, onEditConversation,
 }: MessageListProps) {
   const styles = useMessageListStyles()
-  const messagesEndRef = useRef<HTMLDivElement>(null)
+  const listRef = useRef<HTMLDivElement>(null)
+  const followedListRef = useRef<HTMLDivElement | null>(null)
+  const followLatestRef = useRef(true)
   const copyMenuId = useId()
   const isCopyConversationDisabled = copyConversationDisabled || Boolean(copyConversationDisabledReason)
 
@@ -474,9 +442,16 @@ export default function MessageList({
     }
   }
 
-  useEffect(() => {
-    if (autoScroll) messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
-  }, [messages, autoScroll])
+  // Historical pages keep their reading position; live/manual transcripts follow near the end.
+  useLayoutEffect(() => {
+    const list = listRef.current
+    if (!list || savedEvidence) return
+    if (list !== followedListRef.current) {
+      followedListRef.current = list
+      followLatestRef.current = true
+    }
+    if (followLatestRef.current) list.scrollTop = list.scrollHeight
+  }, [messages, savedEvidence])
 
   if (isLoading) {
     return (
@@ -497,7 +472,13 @@ export default function MessageList({
   }
 
   return (
-    <div className={mergeClasses(styles.root, savedEvidence && styles.savedEvidenceBody)} data-testid="message-list" onDoubleClick={(event) => {
+    <div ref={listRef} className={mergeClasses(styles.root, savedEvidence && styles.savedEvidenceBody)} data-testid="message-list"
+      role={announceUpdates ? 'log' : undefined} aria-live={announceUpdates ? 'polite' : undefined}
+      aria-relevant={announceUpdates ? 'additions text' : undefined} aria-atomic={announceUpdates ? false : undefined}
+      onScroll={(event: UIEvent<HTMLDivElement>) => {
+        const list = event.currentTarget
+        followLatestRef.current = list.scrollHeight - list.clientHeight - list.scrollTop <= FOLLOW_LATEST_THRESHOLD_PX
+      }} onDoubleClick={(event) => {
       if (event.target instanceof Element && event.target.closest('button, a, input, textarea, select, audio, video, [role="button"]')) return
       onEditConversation?.()
     }}>
@@ -762,7 +743,6 @@ export default function MessageList({
           </div>
         )
       })}
-      <div ref={messagesEndRef} />
     </div>
   )
 }
diff --git a/frontend/src/components/Chat/ScoreDetails.styles.ts b/frontend/src/components/Chat/ScoreDetails.styles.ts
new file mode 100644
index 0000000000..c47dccc28d
--- /dev/null
+++ b/frontend/src/components/Chat/ScoreDetails.styles.ts
@@ -0,0 +1,48 @@
+import { makeStyles, tokens } from '@fluentui/react-components'
+
+export const useScoreDetailsStyles = makeStyles({
+  surface: {
+    display: 'flex',
+    flexDirection: 'column',
+    rowGap: tokens.spacingVerticalXS,
+    width: 'min(360px, calc(100vw - 64px))',
+    minWidth: 0,
+    maxWidth: '100%',
+  },
+  row: {
+    display: 'flex',
+    alignItems: 'flex-start',
+    columnGap: tokens.spacingHorizontalS,
+    width: '100%',
+    minWidth: 0,
+  },
+  label: {
+    flex: '0 0 72px',
+    color: tokens.colorNeutralForeground2,
+  },
+  value: {
+    display: 'block',
+    flex: '0 1 auto',
+    minWidth: 0,
+    maxWidth: '100%',
+    height: 'auto',
+    whiteSpace: 'normal',
+    overflowWrap: 'anywhere',
+    wordBreak: 'break-word',
+  },
+  rationale: {
+    display: 'flex',
+    flexDirection: 'column',
+    rowGap: tokens.spacingVerticalXXS,
+    marginTop: tokens.spacingVerticalXS,
+    paddingTop: tokens.spacingVerticalXS,
+    borderTop: `1px solid ${tokens.colorNeutralStroke2}`,
+  },
+  rationaleText: {
+    color: tokens.colorNeutralForeground2,
+    whiteSpace: 'pre-wrap',
+    wordBreak: 'break-word',
+    maxHeight: '30vh',
+    overflowY: 'auto',
+  },
+})
diff --git a/frontend/src/components/Chat/ScoreDetails.test.tsx b/frontend/src/components/Chat/ScoreDetails.test.tsx
new file mode 100644
index 0000000000..e162cc3bd0
--- /dev/null
+++ b/frontend/src/components/Chat/ScoreDetails.test.tsx
@@ -0,0 +1,36 @@
+import type { ReactNode } from 'react'
+
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen } from '@testing-library/react'
+
+import ScoreDetails from './ScoreDetails'
+
+function TestWrapper({ children }: { readonly children: ReactNode }) {
+  return <FluentProvider theme={webLightTheme}>{children}</FluentProvider>
+}
+
+describe('ScoreDetails', () => {
+  it('should show the value, scorer, role, categories, and rationale', () => {
+    render(<TestWrapper><ScoreDetails testId="details" score={{
+      scorer: 'SelfAskRefusalScorer', scoreType: 'true_false', value: 'true', status: 'complete',
+      rationale: 'The target complied.', categories: ['jailbreak', '', 'harm'], isObjective: true,
+    }} /></TestWrapper>)
+
+    const details = screen.getByTestId('details')
+    expect(details).toHaveTextContent('Score details')
+    expect(screen.getByText('true')).toBeInTheDocument()
+    expect(screen.getByText('SelfAskRefusalScorer')).toBeInTheDocument()
+    expect(screen.getByText('Final score')).toBeInTheDocument()
+    expect(screen.getByText('jailbreak, harm')).toBeInTheDocument()
+    expect(screen.getByText('The target complied.')).toBeInTheDocument()
+  })
+
+  it('should name an undetermined score by its status and omit empty sections', () => {
+    render(<TestWrapper><ScoreDetails score={{ scorer: 'Judge', scoreType: 'float_scale', status: 'undetermined' }} /></TestWrapper>)
+
+    expect(screen.getByText('undetermined')).toBeInTheDocument()
+    expect(screen.getByText('Supporting score')).toBeInTheDocument()
+    expect(screen.queryByText('Category')).not.toBeInTheDocument()
+    expect(screen.queryByText('Rationale')).not.toBeInTheDocument()
+  })
+})
diff --git a/frontend/src/components/Chat/ScoreDetails.tsx b/frontend/src/components/Chat/ScoreDetails.tsx
new file mode 100644
index 0000000000..49a721e5d1
--- /dev/null
+++ b/frontend/src/components/Chat/ScoreDetails.tsx
@@ -0,0 +1,49 @@
+import { Badge, Text } from '@fluentui/react-components'
+
+import type { ScoreSummary } from '@/types'
+import { scoreSummaryValue } from '@/utils/scoreSummary'
+
+import { useScoreDetailsStyles } from './ScoreDetails.styles'
+
+interface ScoreDetailsProps {
+  readonly score: ScoreSummary
+  readonly testId?: string
+}
+
+/** One score's value, scorer, role, categories, and rationale, as shown in a score popover. */
+export default function ScoreDetails({ score, testId }: ScoreDetailsProps) {
+  const styles = useScoreDetailsStyles()
+  const categories = score.categories?.filter(Boolean) ?? []
+
+  return (
+    <div className={styles.surface} data-testid={testId}>
+      <Text weight="semibold">Score details</Text>
+      <div className={styles.row}>
+        <Text size={200} weight="semibold" className={styles.label}>Score</Text>
+        <Badge appearance="tint" color="brand" size="small" className={styles.value}>{scoreSummaryValue(score)}</Badge>
+      </div>
+      <div className={styles.row}>
+        <Text size={200} weight="semibold" className={styles.label}>Scorer</Text>
+        <Text size={200} className={styles.value}>{score.scorer}</Text>
+      </div>
+      <div className={styles.row}>
+        <Text size={200} weight="semibold" className={styles.label}>Result role</Text>
+        <Text size={200} className={styles.value}>
+          {score.isObjective ? 'Final score' : 'Supporting score'}
+        </Text>
+      </div>
+      {categories.length > 0 && (
+        <div className={styles.row}>
+          <Text size={200} weight="semibold" className={styles.label}>Category</Text>
+          <Text size={200} className={styles.value}>{categories.join(', ')}</Text>
+        </div>
+      )}
+      {score.rationale && (
+        <div className={styles.rationale}>
+          <Text size={200} weight="semibold">Rationale</Text>
+          <Text size={200} className={styles.rationaleText}>{score.rationale}</Text>
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/frontend/src/components/DetailFacts.styles.ts b/frontend/src/components/DetailFacts.styles.ts
new file mode 100644
index 0000000000..a9af12e1ec
--- /dev/null
+++ b/frontend/src/components/DetailFacts.styles.ts
@@ -0,0 +1,39 @@
+import { makeStyles, tokens } from '@fluentui/react-components'
+
+import { NARROW_VIEWPORT_QUERY } from '@/styles/touchTargets'
+
+export const useDetailFactsStyles = makeStyles({
+  facts: {
+    display: 'grid',
+    gridTemplateColumns: '9rem minmax(0, 1fr)',
+    alignItems: 'baseline',
+    gap: `${tokens.spacingVerticalL} ${tokens.spacingHorizontalXL}`,
+    margin: 0,
+    fontSize: tokens.fontSizeBase300,
+    lineHeight: tokens.lineHeightBase300,
+    [NARROW_VIEWPORT_QUERY]: {
+      gridTemplateColumns: 'minmax(0, 1fr)',
+      rowGap: tokens.spacingVerticalXS,
+    },
+  },
+  primaryLabel: {
+    margin: 0,
+    color: tokens.colorNeutralForeground1,
+  },
+  secondaryLabel: {
+    margin: 0,
+    color: tokens.colorNeutralForeground3,
+  },
+  value: {
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'flex-start',
+    gap: tokens.spacingVerticalS,
+    minWidth: 0,
+    margin: 0,
+    overflowWrap: 'anywhere',
+    [NARROW_VIEWPORT_QUERY]: {
+      paddingBottom: tokens.spacingVerticalM,
+    },
+  },
+})
diff --git a/frontend/src/components/DetailFacts.test.tsx b/frontend/src/components/DetailFacts.test.tsx
new file mode 100644
index 0000000000..e03d2d14b9
--- /dev/null
+++ b/frontend/src/components/DetailFacts.test.tsx
@@ -0,0 +1,28 @@
+import type { ReactNode } from 'react'
+
+import { FluentProvider, Text, webLightTheme } from '@fluentui/react-components'
+import { render, screen, within } from '@testing-library/react'
+
+import DetailFacts, { DetailFact } from './DetailFacts'
+
+function TestWrapper({ children }: { readonly children: ReactNode }) {
+  return <FluentProvider theme={webLightTheme}>{children}</FluentProvider>
+}
+
+describe('DetailFacts', () => {
+  it('should pair each label with its value in a named description list', () => {
+    render(<TestWrapper>
+      <DetailFacts label="Attack outcome">
+        <DetailFact label="Objective:" tone="primary">Extract the system prompt</DetailFact>
+        <DetailFact label="Technique"><Text>Crescendo</Text></DetailFact>
+      </DetailFacts>
+    </TestWrapper>)
+
+    const list = screen.getByLabelText('Attack outcome')
+    expect(list.tagName).toBe('DL')
+    expect(within(list).getAllByRole('term').map((term) => term.textContent)).toEqual(['Objective:', 'Technique'])
+    expect(within(list).getAllByRole('definition').map((value) => value.textContent)).toEqual([
+      'Extract the system prompt', 'Crescendo',
+    ])
+  })
+})
diff --git a/frontend/src/components/DetailFacts.tsx b/frontend/src/components/DetailFacts.tsx
new file mode 100644
index 0000000000..91bb5c2b9d
--- /dev/null
+++ b/frontend/src/components/DetailFacts.tsx
@@ -0,0 +1,39 @@
+import type { ReactNode } from 'react'
+
+import { Text, mergeClasses } from '@fluentui/react-components'
+
+import { useDetailFactsStyles } from './DetailFacts.styles'
+
+interface DetailFactsProps {
+  /** Accessible name of the list, when its heading is not visible. */
+  readonly label?: string
+  readonly className?: string
+  readonly children: ReactNode
+}
+
+/** An aligned label/value list that stacks labels above values on narrow viewports. */
+export default function DetailFacts({ label, className, children }: DetailFactsProps) {
+  const styles = useDetailFactsStyles()
+  return <dl aria-label={label} className={mergeClasses(styles.facts, className)}>{children}</dl>
+}
+
+interface DetailFactProps {
+  readonly label: string
+  /** Primary facts are the subject of the list; secondary facts describe it. */
+  readonly tone?: 'primary' | 'secondary'
+  readonly valueClassName?: string
+  readonly children: ReactNode
+}
+
+// Fluent Text's `as` does not accept dt/dd, so the native elements wrap Text.
+export function DetailFact({ label, tone = 'secondary', valueClassName, children }: DetailFactProps) {
+  const styles = useDetailFactsStyles()
+  return (
+    <>
+      <dt className={tone === 'primary' ? styles.primaryLabel : styles.secondaryLabel}>
+        <Text weight={tone === 'primary' ? 'semibold' : 'regular'}>{label}</Text>
+      </dt>
+      <dd className={mergeClasses(styles.value, valueClassName)}>{children}</dd>
+    </>
+  )
+}
diff --git a/frontend/src/components/Home/Home.tsx b/frontend/src/components/Home/Home.tsx
index 3b7b9daf0c..a645952097 100644
--- a/frontend/src/components/Home/Home.tsx
+++ b/frontend/src/components/Home/Home.tsx
@@ -2,7 +2,6 @@ import { useEffect, useState } from 'react'
 import type { ReactNode } from 'react'
 import { useNavigate } from 'react-router'
 import {
-  Badge,
   Button,
   MessageBar,
   MessageBarBody,
@@ -11,7 +10,6 @@ import {
   TabList,
   Text,
 } from '@fluentui/react-components'
-import type { BadgeProps } from '@fluentui/react-components'
 import {
   AddRegular,
   ArrowRightRegular,
@@ -24,26 +22,19 @@ import {
 } from '@fluentui/react-icons'
 
 import OutcomeBadge from '@/components/OutcomeBadge'
+import ScanStatusBadge from '@/components/ScanStatusBadge'
 import type { ViewName } from '@/components/Sidebar/Navigation'
 import { useRuntime } from '@/hooks/useRuntime'
 import { useAutoRefresh } from '@/hooks/useAutoRefresh'
 import { attacksApi, operationsApi, scenariosApi } from '@/services/api'
 import { toApiError } from '@/services/errors'
-import type { AttackSummary, Operation, OperationListItem, ScenarioRunListItem, ScenarioRunState } from '@/types'
+import type { AttackSummary, Operation, OperationListItem, ScenarioRunListItem } from '@/types'
 import { scenarioRunRoutePath } from '@/utils/routeParams'
 
 import { useHomeStyles } from './Home.styles'
 
 const RECENT_WORK_LIMIT = 5
 const VISIBLE_OPERATIONS_LIMIT = 3
-const SCAN_STATUS_LABELS: Record<ScenarioRunState, string> = {
-  CREATED: 'Created', QUEUED: 'Queued', IN_PROGRESS: 'Executing',
-  COMPLETED: 'Completed', FAILED: 'Failed', CANCELLED: 'Cancelled',
-}
-const SCAN_STATUS_COLORS: Record<ScenarioRunState, BadgeProps['color']> = {
-  CREATED: 'informative', QUEUED: 'informative', IN_PROGRESS: 'brand',
-  COMPLETED: 'success', FAILED: 'danger', CANCELLED: 'warning',
-}
 
 interface HomeProps {
   readonly selectedOperation: Operation | null
@@ -165,7 +156,7 @@ export default function Home({
       title: scan.scenario_registry_name || scan.scenario_name,
       operationName: scan.operation_name,
       updatedAt: scan.updated_at,
-      badge: <Badge appearance="tint" color={SCAN_STATUS_COLORS[scan.status]}>{SCAN_STATUS_LABELS[scan.status]}</Badge>,
+      badge: <ScanStatusBadge status={scan.status} />,
       open: () => { void navigate(scenarioRunRoutePath(scan.scenario_result_id)) },
     })),
   ].filter((item: RecentItem) => filter === 'all' || (filter === 'attacks' ? item.kind === 'Attack' : item.kind === 'Scan'))
diff --git a/frontend/src/components/Operations/OperationParentLink.styles.ts b/frontend/src/components/Operations/OperationParentLink.styles.ts
new file mode 100644
index 0000000000..dcc2326b29
--- /dev/null
+++ b/frontend/src/components/Operations/OperationParentLink.styles.ts
@@ -0,0 +1,32 @@
+import { makeStyles, tokens } from '@fluentui/react-components'
+
+import { mobileTouchTargetHeight } from '@/styles/touchTargets'
+
+export const useOperationParentLinkStyles = makeStyles({
+  link: {
+    ...mobileTouchTargetHeight,
+    display: 'inline-flex',
+    alignItems: 'center',
+    alignSelf: 'flex-start',
+    gap: tokens.spacingHorizontalXS,
+    maxWidth: '100%',
+    color: tokens.colorNeutralForeground2,
+    fontSize: tokens.fontSizeBase200,
+    lineHeight: tokens.lineHeightBase200,
+    fontWeight: tokens.fontWeightSemibold,
+    textDecorationLine: 'none',
+    overflowWrap: 'anywhere',
+    ':hover': {
+      color: tokens.colorBrandForegroundLinkHover,
+      textDecorationLine: 'underline',
+    },
+    ':focus-visible': {
+      outline: `${tokens.strokeWidthThick} solid ${tokens.colorStrokeFocus2}`,
+      borderRadius: tokens.borderRadiusSmall,
+    },
+  },
+  icon: {
+    flexShrink: 0,
+    fontSize: tokens.fontSizeBase400,
+  },
+})
diff --git a/frontend/src/components/Operations/OperationParentLink.test.tsx b/frontend/src/components/Operations/OperationParentLink.test.tsx
new file mode 100644
index 0000000000..ff88704f72
--- /dev/null
+++ b/frontend/src/components/Operations/OperationParentLink.test.tsx
@@ -0,0 +1,30 @@
+import type { ReactNode } from 'react'
+
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen } from '@testing-library/react'
+import { MemoryRouter } from 'react-router'
+
+import OperationParentLink from './OperationParentLink'
+
+function TestWrapper({ children }: { readonly children: ReactNode }) {
+  return <FluentProvider theme={webLightTheme}><MemoryRouter>{children}</MemoryRouter></FluentProvider>
+}
+
+describe('OperationParentLink', () => {
+  it('should link to the operation by name', () => {
+    render(<TestWrapper><OperationParentLink id="operation/1" name="Spring review" /></TestWrapper>)
+    const link = screen.getByRole('link', { name: 'Operation: Spring review' })
+    expect(link).toHaveAttribute('href', '/operations/operation%2F1')
+    expect(link).toHaveTextContent('Spring review')
+  })
+
+  it('should still link when the operation name is unknown', () => {
+    render(<TestWrapper><OperationParentLink id="operation-1" name={null} /></TestWrapper>)
+    expect(screen.getByRole('link', { name: 'Operation: View operation' })).toHaveAttribute('href', '/operations/operation-1')
+  })
+
+  it.each([undefined, null, ''])('should render nothing without an operation id (%p)', (id: string | null | undefined) => {
+    render(<TestWrapper><OperationParentLink id={id} name="Spring review" /></TestWrapper>)
+    expect(screen.queryByRole('link')).not.toBeInTheDocument()
+  })
+})
diff --git a/frontend/src/components/Operations/OperationParentLink.tsx b/frontend/src/components/Operations/OperationParentLink.tsx
new file mode 100644
index 0000000000..a70d8958d7
--- /dev/null
+++ b/frontend/src/components/Operations/OperationParentLink.tsx
@@ -0,0 +1,22 @@
+import { BriefcaseRegular } from '@fluentui/react-icons'
+import { Link } from 'react-router'
+
+import { useOperationParentLinkStyles } from './OperationParentLink.styles'
+
+interface OperationParentLinkProps {
+  readonly id?: string | null
+  readonly name?: string | null
+}
+
+/** The Operation an item belongs to, shown as small parent context above its title. */
+export default function OperationParentLink({ id, name }: OperationParentLinkProps) {
+  const styles = useOperationParentLinkStyles()
+  if (!id) return null
+  const label = name || 'View operation'
+  return (
+    <Link className={styles.link} to={`/operations/${encodeURIComponent(id)}`} aria-label={`Operation: ${label}`}>
+      <BriefcaseRegular className={styles.icon} aria-hidden="true" />
+      {label}
+    </Link>
+  )
+}
diff --git a/frontend/src/components/OutcomeBadge.styles.ts b/frontend/src/components/OutcomeBadge.styles.ts
index 361965fdb5..291afbbadb 100644
--- a/frontend/src/components/OutcomeBadge.styles.ts
+++ b/frontend/src/components/OutcomeBadge.styles.ts
@@ -1,6 +1,7 @@
 import { makeStyles, shorthands, tokens } from '@fluentui/react-components'
 
 import { OUTCOME_PALETTE } from '@/styles/outcomePalette'
+import { mobileTouchTargetHeight } from '@/styles/touchTargets'
 
 export const useOutcomeBadgeStyles = makeStyles({
   success: {
@@ -19,6 +20,14 @@ export const useOutcomeBadgeStyles = makeStyles({
     '--pyrit-outcome-color': OUTCOME_PALETTE.undetermined.color,
     '--pyrit-outcome-tint': OUTCOME_PALETTE.undetermined.tint,
   },
+  in_progress: {
+    '--pyrit-outcome-color': tokens.colorBrandForeground1,
+    '--pyrit-outcome-tint': tokens.colorBrandBackground2,
+  },
+  preparing: {
+    '--pyrit-outcome-color': tokens.colorNeutralForeground2,
+    '--pyrit-outcome-tint': tokens.colorNeutralBackground3,
+  },
   filled: {
     backgroundColor: 'var(--pyrit-outcome-color)',
     ...shorthands.borderColor('var(--pyrit-outcome-color)'),
@@ -44,4 +53,10 @@ export const useOutcomeBadgeStyles = makeStyles({
     flexShrink: 0,
     color: 'var(--pyrit-outcome-color)',
   },
+  scoreTrigger: {
+    ...mobileTouchTargetHeight,
+    minWidth: 0,
+    minHeight: 0,
+    padding: 0,
+  },
 })
diff --git a/frontend/src/components/OutcomeBadge.test.tsx b/frontend/src/components/OutcomeBadge.test.tsx
index 7d35ef8ca1..3a56b1f7f0 100644
--- a/frontend/src/components/OutcomeBadge.test.tsx
+++ b/frontend/src/components/OutcomeBadge.test.tsx
@@ -2,8 +2,9 @@ import type { ReactNode } from 'react'
 
 import { FluentProvider, webLightTheme } from '@fluentui/react-components'
 import { render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
 
-import type { AttackOutcome } from '@/types'
+import type { AttackDisplayOutcome, AttackOutcome } from '@/types'
 
 import OutcomeBadge, { OutcomeIcon } from './OutcomeBadge'
 
@@ -36,9 +37,78 @@ describe('OutcomeBadge', () => {
     expect(screen.getByTestId('verdict')).toHaveTextContent('No')
     expect(screen.getByTestId('verdict')).toHaveClass('custom')
   })
+
+  it.each<[AttackDisplayOutcome, 'outcome' | 'success', string]>([
+    ['success', 'success', 'True'],
+    ['failure', 'success', 'False'],
+    ['error', 'success', 'Error'],
+    ['success', 'outcome', 'Success'],
+    ['undetermined', 'outcome', 'Undetermined'],
+    ['in_progress', 'success', 'In progress'],
+    ['preparing', 'outcome', 'Preparing'],
+  ])('labels %s in %s style as %s', (outcome: AttackDisplayOutcome, labelStyle: 'outcome' | 'success', label: string) => {
+    render(<TestWrapper><OutcomeBadge outcome={outcome} labelStyle={labelStyle} testId="verdict" /></TestWrapper>)
+    expect(screen.getByTestId('verdict')).toHaveTextContent(label)
+  })
+
+  it('stays a plain badge without a score', () => {
+    render(<TestWrapper><OutcomeBadge outcome="success" /></TestWrapper>)
+    expect(screen.queryByRole('button')).not.toBeInTheDocument()
+  })
+
+  it('opens the score behind the outcome from the badge', async () => {
+    const user = userEvent.setup()
+    render(<TestWrapper>
+      <OutcomeBadge outcome="success" labelStyle="success" scoreButtonLabel="View score for First objective" score={{
+        scorer: 'objective', scoreType: 'true_false', value: 'true', rationale: 'The objective was met.', isObjective: true,
+      }} />
+    </TestWrapper>)
+    await user.click(screen.getByRole('button', { name: 'True: View score for First objective' }))
+    expect(await screen.findByText('Score details')).toBeInTheDocument()
+    expect(screen.getByText('The objective was met.')).toBeInTheDocument()
+  })
+
+  it('explains a missing score in the popover', async () => {
+    const user = userEvent.setup()
+    render(<TestWrapper>
+      <OutcomeBadge outcome="error" score={null} scoreFallback="The attack ended before a score was saved." />
+    </TestWrapper>)
+    await user.click(screen.getByRole('button', { name: 'error: View score' }))
+    expect(await screen.findByText('The attack ended before a score was saved.')).toBeInTheDocument()
+  })
+
+  it.each<[AttackDisplayOutcome | null | undefined, string]>([
+    ['success', 'Success'],
+    ['failure', 'Failure'],
+    ['error', 'Error'],
+    ['undetermined', 'Undetermined'],
+    ['in_progress', 'In progress'],
+    ['preparing', 'Preparing'],
+    [null, 'Undetermined'],
+    [undefined, 'Undetermined'],
+  ])('keeps the displayed %s outcome in the score action name', (
+    outcome: AttackDisplayOutcome | null | undefined, label: string,
+  ) => {
+    render(<TestWrapper>
+      <OutcomeBadge outcome={outcome} labelStyle="outcome" scoreFallback="No score saved." />
+    </TestWrapper>)
+    expect(screen.getByRole('button', { name: `${label}: View score`, exact: true })).toHaveTextContent(label)
+  })
+
+  it('keeps a custom displayed outcome in the score action name', () => {
+    render(<TestWrapper>
+      <OutcomeBadge outcome="failure" label="Not achieved" scoreFallback="No score saved." />
+    </TestWrapper>)
+    expect(screen.getByRole('button', { name: 'Not achieved: View score', exact: true })).toHaveTextContent('Not achieved')
+  })
 })
 
 describe('OutcomeIcon', () => {
+  it('names a pending outcome in words', () => {
+    render(<TestWrapper><OutcomeIcon outcome="in_progress" /></TestWrapper>)
+    expect(screen.getByRole('img', { name: 'in progress' })).toBeVisible()
+  })
+
   it.each<AttackOutcome>(['success', 'failure', 'error', 'undetermined'])(
     'provides a non-color label for the %s icon',
     (outcome: AttackOutcome) => {
diff --git a/frontend/src/components/OutcomeBadge.tsx b/frontend/src/components/OutcomeBadge.tsx
index 33199b74e2..e2585aacd4 100644
--- a/frontend/src/components/OutcomeBadge.tsx
+++ b/frontend/src/components/OutcomeBadge.tsx
@@ -1,43 +1,78 @@
 import type { ReactElement } from 'react'
 
-import { Badge, mergeClasses } from '@fluentui/react-components'
+import { Badge, Button, Popover, PopoverSurface, PopoverTrigger, Text, mergeClasses } from '@fluentui/react-components'
 import type { BadgeProps } from '@fluentui/react-components'
 import {
+  ArrowSyncCircleRegular,
   CheckmarkCircleRegular,
+  ClockRegular,
   DismissCircleRegular,
   ErrorCircleRegular,
   QuestionCircleRegular,
 } from '@fluentui/react-icons'
 
-import type { AttackOutcome } from '@/types'
+import { formatAttackOutcome, formatAttackSuccess } from '@/components/AttackResults/attackAttemptFormatting'
+import ScoreDetails from '@/components/Chat/ScoreDetails'
+import type { AttackDisplayOutcome, ScoreSummary } from '@/types'
 
 import { useOutcomeBadgeStyles } from './OutcomeBadge.styles'
 
-const OUTCOME_ICONS: Record<AttackOutcome, ReactElement> = {
+const OUTCOME_ICONS: Record<AttackDisplayOutcome, ReactElement> = {
   success: <CheckmarkCircleRegular />,
   failure: <DismissCircleRegular />,
   error: <ErrorCircleRegular />,
   undetermined: <QuestionCircleRegular />,
+  in_progress: <ArrowSyncCircleRegular />,
+  preparing: <ClockRegular />,
+}
+
+const PENDING_OUTCOME_LABELS = {
+  in_progress: 'In progress',
+  preparing: 'Preparing',
+} as const
+
+/**
+ * How a saved outcome is worded: `outcome` capitalizes it ("Success"), `success`
+ * answers "Attack success?" ("True"/"False"). Omitted keeps the raw outcome word.
+ */
+type OutcomeLabelStyle = 'outcome' | 'success'
+
+function outcomeLabel(outcome: AttackDisplayOutcome, labelStyle: OutcomeLabelStyle | undefined): string {
+  if (outcome === 'in_progress' || outcome === 'preparing') return PENDING_OUTCOME_LABELS[outcome]
+  if (labelStyle === 'success') return formatAttackSuccess(outcome)
+  if (labelStyle === 'outcome') return formatAttackOutcome(outcome)
+  return outcome
 }
 
 interface OutcomeBadgeProps {
-  readonly outcome?: AttackOutcome | null
+  readonly outcome?: AttackDisplayOutcome | null
   readonly testId?: string
   readonly className?: string
   readonly appearance?: BadgeProps['appearance']
   readonly size?: BadgeProps['size']
   readonly label?: string
+  readonly labelStyle?: OutcomeLabelStyle
+  /** Opens the score behind the outcome from the badge. */
+  readonly score?: ScoreSummary | null
+  /** Shown in the score popover when no score was saved; also enables the popover without a score. */
+  readonly scoreFallback?: string
+  /** Score action label, combined with the displayed outcome in the button's accessible name. */
+  readonly scoreButtonLabel?: string
 }
 
 interface OutcomeIconProps {
-  readonly outcome?: AttackOutcome | null
+  readonly outcome?: AttackDisplayOutcome | null
 }
 
 export function OutcomeIcon({ outcome }: OutcomeIconProps) {
   const styles = useOutcomeBadgeStyles()
   const normalizedOutcome = outcome ?? 'undetermined'
   return (
-    <span className={mergeClasses(styles.icon, styles[normalizedOutcome])} role="img" aria-label={normalizedOutcome}>
+    <span
+      className={mergeClasses(styles.icon, styles[normalizedOutcome])}
+      role="img"
+      aria-label={normalizedOutcome.replace('_', ' ')}
+    >
       {OUTCOME_ICONS[normalizedOutcome]}
     </span>
   )
@@ -50,11 +85,16 @@ export default function OutcomeBadge({
   appearance = 'filled',
   size,
   label,
+  labelStyle,
+  score,
+  scoreFallback,
+  scoreButtonLabel = 'View score',
 }: OutcomeBadgeProps) {
   const styles = useOutcomeBadgeStyles()
   const normalizedOutcome = outcome ?? 'undetermined'
+  const displayLabel = label ?? outcomeLabel(normalizedOutcome, labelStyle)
 
-  return (
+  const badge = (
     <Badge
       appearance={appearance}
       icon={OUTCOME_ICONS[normalizedOutcome]}
@@ -62,7 +102,21 @@ export default function OutcomeBadge({
       className={mergeClasses(styles[normalizedOutcome], styles[appearance], className)}
       data-testid={testId}
     >
-      {label ?? normalizedOutcome}
+      {displayLabel}
     </Badge>
   )
+  if (!score && !scoreFallback) return badge
+
+  return (
+    <Popover withArrow>
+      <PopoverTrigger disableButtonEnhancement>
+        <Button appearance="transparent" className={styles.scoreTrigger} aria-label={`${displayLabel}: ${scoreButtonLabel}`}>
+          {badge}
+        </Button>
+      </PopoverTrigger>
+      <PopoverSurface>
+        {score ? <ScoreDetails score={score} /> : <Text>{scoreFallback}</Text>}
+      </PopoverSurface>
+    </Popover>
+  )
 }
diff --git a/frontend/src/components/Registry/IdentityDisclosure.styles.ts b/frontend/src/components/Registry/IdentityDisclosure.styles.ts
new file mode 100644
index 0000000000..8b72d628d7
--- /dev/null
+++ b/frontend/src/components/Registry/IdentityDisclosure.styles.ts
@@ -0,0 +1,44 @@
+import { makeStyles, tokens } from '@fluentui/react-components'
+
+import { mobileTouchTargetHeight } from '@/styles/touchTargets'
+
+export const useIdentityDisclosureStyles = makeStyles({
+  toggle: {
+    ...mobileTouchTargetHeight,
+    justifyContent: 'flex-start',
+    textAlign: 'left',
+    overflowWrap: 'anywhere',
+    fontFamily: tokens.fontFamilyBase,
+    fontSize: tokens.fontSizeBase300,
+    fontWeight: tokens.fontWeightRegular,
+    lineHeight: tokens.lineHeightBase300,
+  },
+  inlineToggle: {
+    minWidth: 0,
+    minHeight: 0,
+    padding: 0,
+    color: tokens.colorNeutralForeground1,
+  },
+  details: {
+    paddingBlock: tokens.spacingVerticalM,
+  },
+  json: {
+    margin: 0,
+    padding: `${tokens.spacingVerticalM} ${tokens.spacingHorizontalM}`,
+    backgroundColor: tokens.colorNeutralBackground2,
+    fontFamily: tokens.fontFamilyMonospace,
+    fontSize: tokens.fontSizeBase200,
+    lineHeight: tokens.lineHeightBase200,
+    whiteSpace: 'pre-wrap',
+    overflowWrap: 'anywhere',
+  },
+  disclosure: {
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'flex-start',
+    minWidth: 0,
+  },
+  inlineDetails: {
+    alignSelf: 'stretch',
+  },
+})
diff --git a/frontend/src/components/Registry/IdentityDisclosure.test.tsx b/frontend/src/components/Registry/IdentityDisclosure.test.tsx
new file mode 100644
index 0000000000..1c2a7f1485
--- /dev/null
+++ b/frontend/src/components/Registry/IdentityDisclosure.test.tsx
@@ -0,0 +1,55 @@
+import type { ReactNode } from 'react'
+
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+
+import IdentityDisclosure from './IdentityDisclosure'
+
+const IDENTITY = { class_name: 'Crescendo', parameters: { max_turns: 5 } }
+
+function TestWrapper({ children }: { readonly children: ReactNode }) {
+  return <FluentProvider theme={webLightTheme}>{children}</FluentProvider>
+}
+
+describe('IdentityDisclosure', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('should reveal and hide the identity JSON from the name', async () => {
+    const user = userEvent.setup()
+    render(<TestWrapper><IdentityDisclosure name="Crescendo" identity={IDENTITY} /></TestWrapper>)
+
+    const toggle = screen.getByRole('button', { name: 'Identity for Crescendo' })
+    expect(toggle).toHaveTextContent('Crescendo')
+    expect(toggle).toHaveAttribute('aria-expanded', 'false')
+    expect(screen.queryByRole('region')).not.toBeInTheDocument()
+
+    await user.click(toggle)
+    const details = screen.getByRole('region', { name: 'Identity for Crescendo' })
+    expect(toggle).toHaveAttribute('aria-expanded', 'true')
+    expect(toggle).toHaveAttribute('aria-controls', details.id)
+    expect(JSON.parse(details.textContent ?? '')).toEqual(IDENTITY)
+
+    await user.click(toggle)
+    expect(screen.queryByRole('region')).not.toBeInTheDocument()
+    expect(toggle).toHaveFocus()
+  })
+
+  it.each([null, undefined])('should show only the name without an identity (%p)', (identity: null | undefined) => {
+    render(<TestWrapper><IdentityDisclosure name="Not recorded" identity={identity} /></TestWrapper>)
+    expect(screen.getByText('Not recorded')).toBeInTheDocument()
+    expect(screen.queryByRole('button')).not.toBeInTheDocument()
+  })
+
+  it('should not trigger an enclosing row when toggled', async () => {
+    const user = userEvent.setup()
+    const onRowClick = jest.fn()
+    render(<TestWrapper>
+      <div onClick={onRowClick}><IdentityDisclosure name="Crescendo" identity={IDENTITY} /></div>
+    </TestWrapper>)
+    await user.click(screen.getByRole('button', { name: 'Identity for Crescendo' }))
+    expect(onRowClick).not.toHaveBeenCalled()
+  })
+})
diff --git a/frontend/src/components/Registry/IdentityDisclosure.tsx b/frontend/src/components/Registry/IdentityDisclosure.tsx
new file mode 100644
index 0000000000..e29ac1709f
--- /dev/null
+++ b/frontend/src/components/Registry/IdentityDisclosure.tsx
@@ -0,0 +1,80 @@
+import { useCallback, useId, useState, type MouseEvent } from 'react'
+
+import { Button, Text, mergeClasses } from '@fluentui/react-components'
+import { ChevronDownRegular, ChevronRightRegular } from '@fluentui/react-icons'
+
+import { useIdentityDisclosureStyles } from './IdentityDisclosure.styles'
+
+interface IdentityDisclosureButtonProps {
+  readonly name: string
+  readonly expanded: boolean
+  readonly controlsId: string
+  readonly onToggle: () => void
+  readonly chevronPosition?: 'before' | 'after'
+  readonly className?: string
+}
+
+/** The component name that reveals its saved identity JSON. */
+export function IdentityDisclosureButton({
+  name, expanded, controlsId, onToggle, chevronPosition = 'before', className,
+}: IdentityDisclosureButtonProps) {
+  const styles = useIdentityDisclosureStyles()
+  return (
+    <Button
+      appearance="transparent"
+      className={mergeClasses(styles.toggle, className)}
+      icon={expanded ? <ChevronDownRegular /> : <ChevronRightRegular />}
+      iconPosition={chevronPosition}
+      aria-expanded={expanded}
+      aria-controls={controlsId}
+      aria-label={`Identity for ${name}`}
+      onClick={(event: MouseEvent<HTMLButtonElement>) => {
+        // Disclosures sit inside clickable rows; toggling must not also open the row.
+        event.stopPropagation()
+        onToggle()
+      }}
+    >
+      {name}
+    </Button>
+  )
+}
+
+interface IdentityJsonProps {
+  readonly id: string
+  readonly name: string
+  readonly identity: object
+  readonly className?: string
+}
+
+/** The saved identity JSON, scrolled into view when it is revealed. */
+export function IdentityJson({ id, name, identity, className }: IdentityJsonProps) {
+  const styles = useIdentityDisclosureStyles()
+  const reveal = useCallback((element: HTMLDivElement | null): void => {
+    element?.scrollIntoView({ block: 'nearest', inline: 'start' })
+  }, [])
+  return (
+    <div ref={reveal} id={id} role="region" aria-label={`Identity for ${name}`} className={mergeClasses(styles.details, className)}>
+      <pre className={styles.json}>{JSON.stringify(identity, null, 2)}</pre>
+    </div>
+  )
+}
+
+interface IdentityDisclosureProps {
+  readonly name: string
+  readonly identity?: object | null
+}
+
+/** A component name with a trailing chevron that expands its identity JSON in place; plain text without one. */
+export default function IdentityDisclosure({ name, identity }: IdentityDisclosureProps) {
+  const styles = useIdentityDisclosureStyles()
+  const detailsId = useId()
+  const [expanded, setExpanded] = useState(false)
+  if (!identity) return <Text>{name}</Text>
+  return (
+    <div className={styles.disclosure}>
+      <IdentityDisclosureButton name={name} expanded={expanded} controlsId={detailsId} chevronPosition="after"
+        className={styles.inlineToggle} onToggle={() => { setExpanded((current: boolean) => !current) }} />
+      {expanded && <IdentityJson id={detailsId} name={name} identity={identity} className={styles.inlineDetails} />}
+    </div>
+  )
+}
diff --git a/frontend/src/components/Registry/RegistryIdentityRow.styles.ts b/frontend/src/components/Registry/RegistryIdentityRow.styles.ts
index 60b13ec1e3..73c7e3415b 100644
--- a/frontend/src/components/Registry/RegistryIdentityRow.styles.ts
+++ b/frontend/src/components/Registry/RegistryIdentityRow.styles.ts
@@ -1,33 +1,10 @@
 import { makeStyles, tokens } from '@fluentui/react-components'
 
-import { mobileTouchTargetHeight } from '@/styles/touchTargets'
-
 export const useRegistryIdentityRowStyles = makeStyles({
   row: {
     backgroundColor: tokens.colorNeutralBackground1,
   },
   name: {
-    ...mobileTouchTargetHeight,
     paddingBlock: tokens.spacingVerticalS,
-    justifyContent: 'flex-start',
-    textAlign: 'left',
-    overflowWrap: 'anywhere',
-    fontFamily: tokens.fontFamilyBase,
-    fontSize: tokens.fontSizeBase300,
-    fontWeight: tokens.fontWeightRegular,
-    lineHeight: tokens.lineHeightBase300,
-  },
-  details: {
-    paddingBlock: tokens.spacingVerticalM,
-  },
-  json: {
-    margin: 0,
-    padding: `${tokens.spacingVerticalM} ${tokens.spacingHorizontalM}`,
-    backgroundColor: tokens.colorNeutralBackground2,
-    fontFamily: tokens.fontFamilyMonospace,
-    fontSize: tokens.fontSizeBase200,
-    lineHeight: tokens.lineHeightBase200,
-    whiteSpace: 'pre-wrap',
-    overflowWrap: 'anywhere',
   },
 })
diff --git a/frontend/src/components/Registry/RegistryIdentityRow.tsx b/frontend/src/components/Registry/RegistryIdentityRow.tsx
index 06bcf23bf8..5811f452cb 100644
--- a/frontend/src/components/Registry/RegistryIdentityRow.tsx
+++ b/frontend/src/components/Registry/RegistryIdentityRow.tsx
@@ -1,8 +1,8 @@
-import { useCallback, useId, type MouseEvent, type ReactNode } from 'react'
+import { useId, type ReactNode } from 'react'
 
-import { Button, TableCell, TableRow, Text, mergeClasses, type TableRowProps } from '@fluentui/react-components'
-import { ChevronDownRegular, ChevronRightRegular } from '@fluentui/react-icons'
+import { TableCell, TableRow, Text, mergeClasses, type TableRowProps } from '@fluentui/react-components'
 
+import { IdentityDisclosureButton, IdentityJson } from './IdentityDisclosure'
 import { useRegistryIdentityRowStyles } from './RegistryIdentityRow.styles'
 
 interface RegistryIdentityRowProps {
@@ -27,33 +27,21 @@ export default function RegistryIdentityRow({
 }: RegistryIdentityRowProps) {
   const styles = useRegistryIdentityRowStyles()
   const detailsId = useId()
-  const revealDetails = useCallback((element: HTMLDivElement | null): void => {
-    element?.scrollIntoView({ block: 'nearest', inline: 'start' })
-  }, [])
 
   return (
     <>
       <TableRow {...rowProps} className={mergeClasses(styles.row, rowClassName)} data-testid={rowTestId}>
         {leadingCell}
         <TableCell className={nameCellClassName}>
-          {identity ? <Button appearance="transparent" className={styles.name}
-            icon={expanded ? <ChevronDownRegular /> : <ChevronRightRegular />}
-            aria-expanded={expanded} aria-controls={detailsId}
-            aria-label={`Identity for ${name}`} onClick={(event: MouseEvent<HTMLButtonElement>) => {
-              event.stopPropagation()
-              onToggle()
-            }}>
-            {name}
-          </Button> : <Text size={200}>{name}</Text>}
+          {identity ? <IdentityDisclosureButton name={name} expanded={expanded} controlsId={detailsId}
+            className={styles.name} onToggle={onToggle} /> : <Text size={200}>{name}</Text>}
           {nameContent}
         </TableCell>
         {children}
       </TableRow>
       {expanded && identity && <TableRow className={styles.row}>
         <TableCell colSpan={columns}>
-          <div ref={revealDetails} id={detailsId} role="region" aria-label={`Identity for ${name}`} className={styles.details}>
-            <pre className={styles.json}>{JSON.stringify(identity, null, 2)}</pre>
-          </div>
+          <IdentityJson id={detailsId} name={name} identity={identity} />
         </TableCell>
       </TableRow>}
       {additionalRows}
diff --git a/frontend/src/components/Registry/ScorerRegistry.test.tsx b/frontend/src/components/Registry/ScorerRegistry.test.tsx
index 054832fc4f..58efce9d2d 100644
--- a/frontend/src/components/Registry/ScorerRegistry.test.tsx
+++ b/frontend/src/components/Registry/ScorerRegistry.test.tsx
@@ -97,6 +97,15 @@ describe('ScorerRegistry', () => {
     expect(await screen.findByRole('tooltip')).toHaveTextContent('Recorded value: 0.95678')
     expect(screen.queryByText('More metrics')).not.toBeInTheDocument()
     expect(screen.queryByRole('group', { name: 'Num responses' })).not.toBeInTheDocument()
+    await user.click(screen.getByRole('button', { name: 'Evaluation metrics for wrapped-judge' }))
+    const evaluation = screen.getByRole('dialog', { name: 'Scorer evaluation metrics' })
+    expect(within(evaluation).getByRole('group', { name: 'Num responses' })).toHaveTextContent('100')
+    expect(within(evaluation).getByRole('group', { name: 'Recall' })).toHaveTextContent('0.00%')
+    await user.click(within(evaluation).getByRole('button', { name: 'Identity for Behavioral evaluation identity' }))
+    const evaluationIdentity = within(evaluation).getByRole('region', { name: 'Identity for Behavioral evaluation identity' })
+    expect(evaluationIdentity).toHaveTextContent('evaluation-hash')
+    expect(evaluationIdentity).not.toHaveTextContent('runtime-hash')
+    await user.keyboard('{Escape}')
     await user.click(screen.getByRole('button', { name: 'Identity for wrapped-judge' }))
     const details = screen.getByRole('region', { name: 'Identity for wrapped-judge' })
     expect(JSON.parse(details.textContent ?? '')).toEqual(evaluated.identifier)
diff --git a/frontend/src/components/Registry/ScorerRegistry.tsx b/frontend/src/components/Registry/ScorerRegistry.tsx
index 1bb6e06548..7921425705 100644
--- a/frontend/src/components/Registry/ScorerRegistry.tsx
+++ b/frontend/src/components/Registry/ScorerRegistry.tsx
@@ -4,6 +4,7 @@ import { Divider, mergeClasses, Table, TableBody, TableCell, TableHeader, TableH
 
 import ChatScorerPicker from '@/components/Chat/ChatScorerPicker'
 import ContextualHelpLabel from '@/components/ContextualHelpLabel'
+import ScorerEvaluationDetails from '@/components/Scorers/ScorerEvaluationDetails'
 import { useUserPreferences } from '@/hooks/useUserPreferences'
 import { useAutoRefresh } from '@/hooks/useAutoRefresh'
 import type { RegisteredComponentReference, ScorerInstance } from '@/types'
@@ -135,6 +136,8 @@ function ScorerTable({ title, family, metrics, scorers }: ScorerTableProps) {
           <TableBody>{sorted.map((scorer: ScorerInstance) => (
             <RegistryIdentityRow key={scorer.scorer_registry_name}
               name={scorer.scorer_registry_name} identity={scorer.identifier} columns={metrics.length + 4}
+              nameContent={<ScorerEvaluationDetails name={scorer.scorer_registry_name} metrics={scorer.metrics}
+                scoreType={scorer.identifier.scorer_type} evaluationIdentity={scorer.evaluation_identifier} />}
               expanded={expanded.has(scorer.scorer_registry_name)}
               onToggle={() => toggleDetails(scorer.scorer_registry_name)}>
               <TableCell>
diff --git a/frontend/src/components/ScanStatusBadge.test.tsx b/frontend/src/components/ScanStatusBadge.test.tsx
new file mode 100644
index 0000000000..8fdc13542d
--- /dev/null
+++ b/frontend/src/components/ScanStatusBadge.test.tsx
@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react'
+
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen } from '@testing-library/react'
+
+import ScanStatusBadge from './ScanStatusBadge'
+
+function TestWrapper({ children }: { readonly children: ReactNode }) {
+  return <FluentProvider theme={webLightTheme}>{children}</FluentProvider>
+}
+
+describe('ScanStatusBadge', () => {
+  it.each([
+    ['CREATED', 'Created'],
+    ['QUEUED', 'Queued'],
+    ['IN_PROGRESS', 'Executing'],
+    ['COMPLETED', 'Completed'],
+    ['FAILED', 'Failed'],
+    ['CANCELLED', 'Cancelled'],
+    ['QUEUING', 'Queuing'],
+    ['PENDING', 'Pending'],
+    ['SUBMITTING', 'Submitting'],
+    ['SUBMISSION_FAILED', 'Submission failed'],
+  ] as const)('should label %s as %s', (status, label) => {
+    render(<TestWrapper><ScanStatusBadge status={status} testId="status" /></TestWrapper>)
+    expect(screen.getByTestId('status')).toHaveTextContent(label)
+  })
+
+  it('should let a caller reword the label', () => {
+    render(<TestWrapper><ScanStatusBadge status="IN_PROGRESS" label="In progress" testId="status" /></TestWrapper>)
+    expect(screen.getByTestId('status')).toHaveTextContent('In progress')
+  })
+
+  it('should mark terminal states with an icon only when asked', () => {
+    const view = render(<TestWrapper><ScanStatusBadge status="COMPLETED" testId="status" /></TestWrapper>)
+    expect(screen.getByTestId('status').querySelector('svg')).toBeNull()
+    view.rerender(<TestWrapper><ScanStatusBadge status="COMPLETED" withIcon testId="status" /></TestWrapper>)
+    expect(screen.getByTestId('status').querySelector('svg')).not.toBeNull()
+    view.rerender(<TestWrapper><ScanStatusBadge status="IN_PROGRESS" withIcon testId="status" /></TestWrapper>)
+    expect(screen.getByTestId('status').querySelector('svg')).toBeNull()
+  })
+})
diff --git a/frontend/src/components/ScanStatusBadge.tsx b/frontend/src/components/ScanStatusBadge.tsx
new file mode 100644
index 0000000000..ce703b80b7
--- /dev/null
+++ b/frontend/src/components/ScanStatusBadge.tsx
@@ -0,0 +1,73 @@
+import type { ReactElement } from 'react'
+
+import { Badge } from '@fluentui/react-components'
+import type { BadgeProps } from '@fluentui/react-components'
+import { CheckmarkCircleRegular, DismissCircleRegular, ErrorCircleRegular } from '@fluentui/react-icons'
+
+import type { ScenarioRunState, ScenarioSuiteExecutionEntryState, ScenarioSuiteExecutionStatus } from '@/types'
+
+type ScanStatus = ScenarioRunState | ScenarioSuiteExecutionStatus | ScenarioSuiteExecutionEntryState
+type ScanStatusColor = 'informative' | 'brand' | 'success' | 'danger' | 'warning'
+
+const SCAN_STATUS_COLORS: Record<ScanStatus, ScanStatusColor> = {
+  PENDING: 'informative',
+  SUBMITTING: 'informative',
+  QUEUING: 'informative',
+  CREATED: 'informative',
+  QUEUED: 'informative',
+  IN_PROGRESS: 'brand',
+  COMPLETED: 'success',
+  SUBMISSION_FAILED: 'danger',
+  FAILED: 'danger',
+  CANCELLED: 'warning',
+}
+
+const SCAN_STATUS_LABELS: Record<ScanStatus, string> = {
+  PENDING: 'Pending',
+  SUBMITTING: 'Submitting',
+  QUEUING: 'Queuing',
+  CREATED: 'Created',
+  QUEUED: 'Queued',
+  IN_PROGRESS: 'Executing',
+  COMPLETED: 'Completed',
+  SUBMISSION_FAILED: 'Submission failed',
+  FAILED: 'Failed',
+  CANCELLED: 'Cancelled',
+}
+
+function scanStatusIcon(status: ScanStatus): ReactElement | undefined {
+  if (status === 'COMPLETED') return <CheckmarkCircleRegular />
+  if (status === 'FAILED' || status === 'SUBMISSION_FAILED') return <ErrorCircleRegular />
+  if (status === 'CANCELLED') return <DismissCircleRegular />
+  return undefined
+}
+
+interface ScanStatusBadgeProps {
+  readonly status: ScanStatus
+  readonly appearance?: Extract<BadgeProps['appearance'], 'tint' | 'filled'>
+  /** Mark terminal states with an icon as well as color. */
+  readonly withIcon?: boolean
+  /** Replaces the standard status label, such as a suite's wording for a running entry. */
+  readonly label?: string
+  readonly testId?: string
+}
+
+/** The lifecycle state of a scan, suite, or suite entry, with one color per state everywhere. */
+export default function ScanStatusBadge({
+  status,
+  appearance = 'tint',
+  withIcon = false,
+  label,
+  testId,
+}: ScanStatusBadgeProps) {
+  return (
+    <Badge
+      appearance={appearance}
+      color={SCAN_STATUS_COLORS[status]}
+      icon={withIcon ? scanStatusIcon(status) : undefined}
+      data-testid={testId}
+    >
+      {label ?? SCAN_STATUS_LABELS[status]}
+    </Badge>
+  )
+}
diff --git a/frontend/src/components/ScenarioSuites/ScenarioSuiteExecutionPage.tsx b/frontend/src/components/ScenarioSuites/ScenarioSuiteExecutionPage.tsx
index 8f2121939b..54bf70b5d1 100644
--- a/frontend/src/components/ScenarioSuites/ScenarioSuiteExecutionPage.tsx
+++ b/frontend/src/components/ScenarioSuites/ScenarioSuiteExecutionPage.tsx
@@ -1,7 +1,6 @@
-import { type ReactElement, useState } from 'react'
+import { useState } from 'react'
 
 import {
-  Badge,
   Button,
   Dialog,
   DialogActions,
@@ -24,14 +23,13 @@ import {
 import {
   ArrowLeftRegular,
   ArrowSyncRegular,
-  CheckmarkCircleRegular,
-  DismissCircleRegular,
   ErrorCircleRegular,
   StopRegular,
 } from '@fluentui/react-icons'
 import { Link, useParams } from 'react-router'
 
 import { formatTimestamp } from '@/components/AttackResults/attackAttemptFormatting'
+import ScanStatusBadge from '@/components/ScanStatusBadge'
 import {
   isTerminalSuiteExecutionStatus,
   useScenarioSuiteExecution,
@@ -39,40 +37,12 @@ import {
 import { scenarioSuitesApi } from '@/services/api'
 import { toApiError } from '@/services/errors'
 import type {
-  ScenarioSuiteExecutionEntryState,
   ScenarioSuiteExecutionEntrySummary,
-  ScenarioSuiteExecutionStatus,
 } from '@/types'
 import { routerPathParamValue, scenarioRunRoutePath } from '@/utils/routeParams'
 
 import { useScenarioSuiteExecutionPageStyles } from './ScenarioSuiteExecutionPage.styles'
 
-const EXECUTION_BADGE_COLORS: Record<
-  ScenarioSuiteExecutionStatus,
-  'informative' | 'brand' | 'success' | 'danger' | 'warning'
-> = {
-  QUEUING: 'informative',
-  IN_PROGRESS: 'brand',
-  COMPLETED: 'success',
-  FAILED: 'danger',
-  CANCELLED: 'warning',
-}
-
-const ENTRY_BADGE_COLORS: Record<
-  ScenarioSuiteExecutionEntryState,
-  'informative' | 'brand' | 'success' | 'danger' | 'warning'
-> = {
-  PENDING: 'informative',
-  SUBMITTING: 'informative',
-  SUBMISSION_FAILED: 'danger',
-  CREATED: 'informative',
-  QUEUED: 'informative',
-  IN_PROGRESS: 'brand',
-  COMPLETED: 'success',
-  FAILED: 'danger',
-  CANCELLED: 'warning',
-}
-
 const ENTRY_SUBMISSION_FAILURE_MESSAGE = (
   'The scenario run could not be created. Check server logs before retrying.'
 )
@@ -212,14 +182,13 @@ function ScenarioSuiteExecutionPageContent({
               <Text as="h2" size={700} weight="semibold">
                 {execution.suite_name}
               </Text>
-              <Badge
+              <ScanStatusBadge
+                status={execution.status}
                 appearance="filled"
-                color={EXECUTION_BADGE_COLORS[execution.status]}
-                icon={statusIcon(execution.status)}
-                data-testid="suite-execution-state-badge"
-              >
-                {formatState(execution.status)}
-              </Badge>
+                withIcon
+                label={formatState(execution.status)}
+                testId="suite-execution-state-badge"
+              />
             </div>
             <Text size={200} className={styles.executionId}>
               Suite execution ID: <code>{execution.suite_execution_id}</code>
@@ -312,13 +281,7 @@ function ScenarioSuiteExecutionPageContent({
                       </div>
                     </TableCell>
                     <TableCell>
-                      <Badge
-                        appearance="tint"
-                        color={ENTRY_BADGE_COLORS[entry.state]}
-                        icon={statusIcon(entry.state)}
-                      >
-                        {formatState(entry.state)}
-                      </Badge>
+                      <ScanStatusBadge status={entry.state} withIcon label={formatState(entry.state)} />
                     </TableCell>
                     <TableCell>
                       {entry.run ? (
@@ -420,21 +383,6 @@ function entryErrorMessage(entry: ScenarioSuiteExecutionEntrySummary): string {
     : ENTRY_STATUS_FAILURE_MESSAGE
 }
 
-function statusIcon(
-  status: ScenarioSuiteExecutionStatus | ScenarioSuiteExecutionEntryState,
-): ReactElement | undefined {
-  if (status === 'COMPLETED') {
-    return <CheckmarkCircleRegular />
-  }
-  if (status === 'FAILED' || status === 'SUBMISSION_FAILED') {
-    return <ErrorCircleRegular />
-  }
-  if (status === 'CANCELLED') {
-    return <DismissCircleRegular />
-  }
-  return undefined
-}
-
 function formatState(status: string): string {
   return status.toLowerCase().replace(/_/g, ' ').replace(
     /^\w/,
diff --git a/frontend/src/components/Scenarios/AtomicAttackGroupsSection.tsx b/frontend/src/components/Scenarios/AtomicAttackGroupsSection.tsx
new file mode 100644
index 0000000000..29925dc92f
--- /dev/null
+++ b/frontend/src/components/Scenarios/AtomicAttackGroupsSection.tsx
@@ -0,0 +1,177 @@
+import { useMemo, useState, type Ref } from 'react'
+
+import { Button, Text } from '@fluentui/react-components'
+import { ChevronDownRegular, ChevronRightRegular } from '@fluentui/react-icons'
+
+import type { UseScenarioResultHierarchyResult } from '@/hooks/useScenarioResultHierarchy'
+import type { ScenarioHierarchyNode, ScenarioProgressResult, ScenarioProgressSummary, ScenarioRunState } from '@/types'
+
+import AttackExecutionTable from './AttackExecutionTable'
+import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+import ScenarioResultHierarchy from './ScenarioResultHierarchy'
+import { hierarchyDisplayGroups, runExecutionCount } from './scenarioHierarchy'
+
+const MAX_VISIBLE_ATTEMPTS_PER_GROUP = 100
+const AUTO_EXPAND_GROUP_LIMIT = 20
+
+interface AtomicAttackGroupsSectionProps {
+  readonly scenarioResultId: string
+  readonly runStatus: ScenarioRunState
+  readonly summary: ScenarioProgressSummary
+  readonly results: readonly ScenarioProgressResult[]
+  readonly hierarchy: UseScenarioResultHierarchyResult
+  readonly seedObjectives: ReadonlyMap<string, string>
+  readonly techniqueNames: ReadonlyMap<string, string>
+  readonly onOpenDetails: (attempt: ScenarioProgressResult | ScenarioHierarchyNode, trigger: HTMLElement) => void
+  /** The section toggle, which receives focus when an opened attack is no longer on the page. */
+  readonly toggleRef: Ref<HTMLButtonElement>
+}
+
+/** Every display group's progress, expandable to its attack executions. */
+export default function AtomicAttackGroupsSection({
+  scenarioResultId, runStatus, summary, results, hierarchy, seedObjectives, techniqueNames, onOpenDetails, toggleRef,
+}: AtomicAttackGroupsSectionProps) {
+  const styles = useScenarioRunPageStyles()
+  const [sectionExpandedChoice, setSectionExpandedChoice] = useState<boolean | null>(null)
+  const [expandedGroupChoices, setExpandedGroupChoices] = useState<Map<string, boolean>>(new Map())
+  // Attempts are grouped by atomic group id, then truncated per group, so expanding an
+  // older group still shows its own executions rather than an empty table.
+  const attemptsByGroupId = useMemo(() => {
+    const groupedAttempts = new Map<string, ScenarioProgressResult[]>()
+    for (let index = results.length - 1; index >= 0; index -= 1) {
+      const attempt = results[index]
+      if (!attempt) continue
+      const existing = groupedAttempts.get(attempt.atomic_group_id)
+      if (existing) {
+        existing.push(attempt)
+      } else {
+        groupedAttempts.set(attempt.atomic_group_id, [attempt])
+      }
+    }
+    return groupedAttempts
+  }, [results])
+
+  const displayGroups = hierarchyDisplayGroups(summary.display_groups ?? summary.techniques, hierarchy.roots.groups)
+  const executions = runExecutionCount(summary, results.length)
+  const defaultExpanded = displayGroups.length <= AUTO_EXPAND_GROUP_LIMIT
+  const sectionExpanded = sectionExpandedChoice ?? defaultExpanded
+
+  const toggleDisplayGroup = (groupId: string): void => {
+    setExpandedGroupChoices((current) => new Map(current).set(groupId, !(current.get(groupId) ?? defaultExpanded)))
+  }
+
+  return (
+    <section className={styles.section} aria-labelledby="atomic-groups-heading">
+      <div className={styles.sectionHeading}>
+        <div className={styles.objectivesHeading}>
+          <Text as="h2" id="atomic-groups-heading" size={500} weight="semibold">
+            Atomic attack groups
+          </Text>
+          <Button
+            appearance="subtle"
+            className={styles.touchTarget}
+            icon={sectionExpanded ? <ChevronDownRegular /> : <ChevronRightRegular />}
+            aria-expanded={sectionExpanded}
+            aria-controls="atomic-groups-panel"
+            aria-label={`${sectionExpanded ? 'Collapse' : 'Expand'} atomic attack groups`}
+            data-testid="toggle-atomic-groups-btn"
+            ref={toggleRef}
+            onClick={() => setSectionExpandedChoice(!sectionExpanded)}
+          >
+          </Button>
+        </div>
+        <Text className={styles.sectionHint}>
+          {`${displayGroups.length.toLocaleString()} group${displayGroups.length === 1 ? '' : 's'}, ${executions.count.toLocaleString()} ${executions.exact ? '' : 'loaded '}execution${executions.count === 1 ? '' : 's'}`}
+        </Text>
+      </div>
+      <div id="atomic-groups-panel" hidden={!sectionExpanded}>
+        {sectionExpanded && (
+          <ScenarioResultHierarchy hierarchy={hierarchy} runStatus={runStatus}>
+            {displayGroups.length === 0 ? (
+              <Text className={styles.sectionHint}>No atomic attack groups have been persisted yet.</Text>
+            ) : (
+              <div className={styles.displayGroupList}>
+                {displayGroups.map((group) => {
+                  const attempts = (group.atomic_group_ids ?? [])
+                    .flatMap((atomicGroupId) => attemptsByGroupId.get(atomicGroupId) ?? [])
+                    .sort((left, right) => Date.parse(right.timestamp) - Date.parse(left.timestamp))
+                  const expanded = expandedGroupChoices.get(group.id) ?? defaultExpanded
+                  const panelId = `atomic-group-${group.id.replace(/[^a-zA-Z0-9_-]/g, '-')}`
+                  return (
+                    <article key={group.id} className={styles.displayGroup}>
+                      <div className={styles.displayGroupSummary}>
+                        <Button
+                          appearance="subtle"
+                          className={styles.expandButton}
+                          icon={expanded ? <ChevronDownRegular /> : <ChevronRightRegular />}
+                          aria-expanded={expanded}
+                          aria-controls={panelId}
+                          aria-label={`${expanded ? 'Collapse' : 'Expand'} attacks in ${group.display_group}`}
+                          onClick={() => toggleDisplayGroup(group.id)}
+                        />
+                        <span className={styles.displayGroupIdentity}>
+                          <Text size={400} weight="semibold">{group.display_group}</Text>
+                          <Text size={200} className={styles.sectionHint}>
+                            {group.atomic_attack_names.join(', ')}
+                          </Text>
+                        </span>
+                        <span className={styles.displayGroupMetrics}>
+                          <DisplayGroupMetric label="Completed" value={formatCompletion(group.completed, group.planned)} />
+                          <DisplayGroupMetric
+                            label="Attack success"
+                            value={formatSuccess(group.succeeded, group.completed, group.success_percentage)}
+                          />
+                          <DisplayGroupMetric label="Errors" value={String(group.errors)} />
+                          <DisplayGroupMetric label="Retries" value={String(group.retries)} />
+                        </span>
+                      </div>
+                      {expanded && (
+                        <div id={panelId} className={styles.displayGroupPanel} aria-label={`${group.display_group} attack executions`}>
+                          <AttackExecutionTable
+                            scenarioResultId={scenarioResultId}
+                            label={`${group.display_group} attack results`}
+                            attempts={attempts.slice(0, MAX_VISIBLE_ATTEMPTS_PER_GROUP)}
+                            totalAttempts={attempts.length}
+                            roots={hierarchy.roots.groups
+                              .filter((savedGroup) => group.atomic_group_ids.includes(savedGroup.atomic_group_id))
+                              .flatMap((savedGroup) => savedGroup.roots)}
+                            hierarchy={hierarchy}
+                            seedObjectives={seedObjectives}
+                            techniqueNames={techniqueNames}
+                            onOpenDetails={onOpenDetails}
+                            showTimestamp={false}
+                            showConversationLink
+                            booleanOutcome
+                          />
+                        </div>
+                      )}
+                    </article>
+                  )
+                })}
+              </div>
+            )}
+          </ScenarioResultHierarchy>
+        )}
+      </div>
+    </section>
+  )
+}
+
+function DisplayGroupMetric({ label, value }: { readonly label: string; readonly value: string }) {
+  const styles = useScenarioRunPageStyles()
+  return (
+    <div className={styles.displayGroupMetric}>
+      <Text size={200}>{label}</Text>
+      <Text weight="semibold">{value}</Text>
+    </div>
+  )
+}
+
+function formatCompletion(completed: number, planned: number | null): string {
+  return planned === null ? `${completed}/total unavailable` : `${completed}/${planned}`
+}
+
+function formatSuccess(succeeded: number, completed: number, percentage: number | null): string {
+  if (percentage === null) return completed === 0 ? 'Unavailable' : `${succeeded}/${completed}`
+  return `${percentage}%`
+}
diff --git a/frontend/src/components/Scenarios/AttackActivity.styles.ts b/frontend/src/components/Scenarios/AttackActivity.styles.ts
new file mode 100644
index 0000000000..999c8a8472
--- /dev/null
+++ b/frontend/src/components/Scenarios/AttackActivity.styles.ts
@@ -0,0 +1,41 @@
+import { makeStyles, tokens } from '@fluentui/react-components'
+
+import { NARROW_VIEWPORT_QUERY } from '@/styles/touchTargets'
+
+export const useAttackActivityStyles = makeStyles({
+  root: {
+    display: 'flex',
+    alignItems: 'center',
+    flexWrap: 'wrap',
+    gap: tokens.spacingHorizontalL,
+    paddingBlock: tokens.spacingVerticalM,
+  },
+  flow: {
+    display: 'flex',
+    alignItems: 'center',
+    gap: tokens.spacingHorizontalS,
+    color: tokens.colorBrandForeground1,
+    fontSize: tokens.fontSizeBase500,
+    flexShrink: 0,
+  },
+  connection: {
+    display: 'inline-flex',
+    animationName: {
+      '0%, 100%': { opacity: 0.35, transform: 'translateX(-2px)' },
+      '50%': { opacity: 1, transform: 'translateX(2px)' },
+    },
+    animationDuration: '1800ms',
+    animationIterationCount: 'infinite',
+    animationTimingFunction: 'ease-in-out',
+    '@media (prefers-reduced-motion: reduce)': { animationName: 'none' },
+  },
+  copy: {
+    display: 'flex',
+    flexDirection: 'column',
+    gap: tokens.spacingVerticalXXS,
+    [NARROW_VIEWPORT_QUERY]: { flexBasis: '100%' },
+  },
+  hint: {
+    color: tokens.colorNeutralForeground2,
+  },
+})
diff --git a/frontend/src/components/Scenarios/AttackActivity.test.tsx b/frontend/src/components/Scenarios/AttackActivity.test.tsx
new file mode 100644
index 0000000000..9d37e67af8
--- /dev/null
+++ b/frontend/src/components/Scenarios/AttackActivity.test.tsx
@@ -0,0 +1,30 @@
+import type { ReactNode } from 'react'
+
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen } from '@testing-library/react'
+
+import AttackActivity from './AttackActivity'
+
+function TestWrapper({ children }: { readonly children: ReactNode }) {
+  return <FluentProvider theme={webLightTheme}>{children}</FluentProvider>
+}
+
+describe('AttackActivity', () => {
+  it('should describe an attack in progress by default', () => {
+    render(<TestWrapper><AttackActivity /></TestWrapper>)
+    const status = screen.getByRole('status')
+    expect(status).toHaveTextContent('Attack in progress')
+    expect(status).toHaveTextContent('Prompt, target response, evaluation')
+  })
+
+  it('should describe loading a scan', () => {
+    render(<TestWrapper><AttackActivity loading /></TestWrapper>)
+    expect(screen.getByRole('status')).toHaveTextContent('Loading scan')
+    expect(screen.getByRole('status')).toHaveTextContent('Retrieving configuration, conversations and scores')
+  })
+
+  it('should use a caller label', () => {
+    render(<TestWrapper><AttackActivity label="Waiting to start" /></TestWrapper>)
+    expect(screen.getByRole('status')).toHaveTextContent('Waiting to start')
+  })
+})
diff --git a/frontend/src/components/Scenarios/AttackActivity.tsx b/frontend/src/components/Scenarios/AttackActivity.tsx
new file mode 100644
index 0000000000..c5550e7831
--- /dev/null
+++ b/frontend/src/components/Scenarios/AttackActivity.tsx
@@ -0,0 +1,32 @@
+import { Text } from '@fluentui/react-components'
+import { ArrowRightRegular, ChatRegular, CheckmarkCircleRegular, SparkleRegular } from '@fluentui/react-icons'
+
+import { useAttackActivityStyles } from './AttackActivity.styles'
+
+interface AttackActivityProps {
+  /** Describe loading a scan rather than an attack that is running. */
+  readonly loading?: boolean
+  readonly label?: string
+}
+
+/** Animated prompt → response → evaluation graphic for work that is still underway. */
+export default function AttackActivity({ loading = false, label }: AttackActivityProps) {
+  const styles = useAttackActivityStyles()
+  return (
+    <div className={styles.root} role="status">
+      <div className={styles.flow} aria-hidden="true">
+        <ChatRegular />
+        <span className={styles.connection}><ArrowRightRegular /></span>
+        <SparkleRegular />
+        <span className={styles.connection}><ArrowRightRegular /></span>
+        <CheckmarkCircleRegular />
+      </div>
+      <div className={styles.copy}>
+        <Text weight="semibold">{label ?? (loading ? 'Loading scan' : 'Attack in progress')}</Text>
+        <Text size={200} className={styles.hint}>
+          {loading ? 'Retrieving configuration, conversations and scores' : 'Prompt, target response, evaluation'}
+        </Text>
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/components/Scenarios/AttackDetailsDialog.tsx b/frontend/src/components/Scenarios/AttackDetailsDialog.tsx
new file mode 100644
index 0000000000..bbd2ad4af5
--- /dev/null
+++ b/frontend/src/components/Scenarios/AttackDetailsDialog.tsx
@@ -0,0 +1,44 @@
+import { Button, Dialog, DialogBody, DialogContent, DialogSurface, DialogTitle, Text } from '@fluentui/react-components'
+import { DismissRegular } from '@fluentui/react-icons'
+
+import OperationParentLink from '@/components/Operations/OperationParentLink'
+import type { ScenarioRunAttempt } from '@/hooks/useScenarioRunAttackDetails'
+import type { ScenarioHierarchyNode, ScenarioProgressHeader } from '@/types'
+
+import ScenarioAttackDetails, { type ScenarioRunDetailsContext } from './ScenarioAttackDetails'
+import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+
+const TITLE_ID = 'attack-details-title'
+
+interface AttackDetailsDialogProps {
+  readonly run: ScenarioProgressHeader
+  readonly context: ScenarioRunDetailsContext
+  readonly attempt: ScenarioRunAttempt | null
+  /** The hierarchy node the dialog was opened from, which may carry the objective. */
+  readonly hierarchySelection: ScenarioHierarchyNode | null
+  readonly onClose: () => void
+}
+
+/** One attack's details, opened from anywhere on the run page, under the run's Operation. */
+export default function AttackDetailsDialog({ run, context, attempt, hierarchySelection, onClose }: AttackDetailsDialogProps) {
+  const styles = useScenarioRunPageStyles()
+  return (
+    <Dialog open={attempt !== null} onOpenChange={(_, data) => { if (!data.open) onClose() }}>
+      <DialogSurface className={styles.attackDetailDialogSurface} aria-labelledby={TITLE_ID}>
+        <DialogBody className={styles.attackDetailDialogBody}>
+          <DialogTitle as="div" className={styles.attackDetailDialogTitle} action={(
+            <Button appearance="subtle" icon={<DismissRegular />} aria-label="Close attack details" onClick={onClose} />
+          )}>
+            <OperationParentLink id={run.operation_id} name={run.operation_name} />
+            <Text as="h2" id={TITLE_ID} size={500} weight="semibold">{attempt?.atomic_attack_name || 'Attack attempt'}</Text>
+          </DialogTitle>
+          {attempt && (
+            <DialogContent className={styles.attackDetailDialogContent}>
+              <ScenarioAttackDetails context={context} attempt={attempt} hierarchySelection={hierarchySelection} />
+            </DialogContent>
+          )}
+        </DialogBody>
+      </DialogSurface>
+    </Dialog>
+  )
+}
diff --git a/frontend/src/components/Scenarios/AttackExecutionTable.styles.ts b/frontend/src/components/Scenarios/AttackExecutionTable.styles.ts
index 3a0ed1fadc..f3716d06eb 100644
--- a/frontend/src/components/Scenarios/AttackExecutionTable.styles.ts
+++ b/frontend/src/components/Scenarios/AttackExecutionTable.styles.ts
@@ -10,8 +10,15 @@ export const useAttackExecutionTableStyles = makeStyles({
     borderRadius: tokens.borderRadiusLarge,
     backgroundColor: tokens.colorNeutralBackground1,
   },
-  table: { minWidth: '64rem', tableLayout: 'auto' },
-  headerRow: { backgroundColor: tokens.colorNeutralBackground3 },
+  table: { minWidth: '44rem', tableLayout: 'auto' },
+  semanticHeader: {
+    position: 'absolute',
+    width: '1px',
+    height: '1px',
+    overflow: 'hidden',
+    clip: 'rect(0, 0, 0, 0)',
+    whiteSpace: 'nowrap',
+  },
   resultRow: {
     cursor: 'pointer',
     ':hover': { backgroundColor: tokens.colorNeutralBackground1Hover },
@@ -33,11 +40,7 @@ export const useAttackExecutionTableStyles = makeStyles({
     minWidth: 0,
     overflowWrap: 'anywhere',
   },
-  objectiveLink: {
-    color: tokens.colorBrandForegroundLink,
-    textDecorationLine: 'none',
-    ':hover': { textDecorationLine: 'underline' },
-  },
+  actions: { textAlign: 'end', whiteSpace: 'nowrap' },
   expandSpacer: { width: '2rem', flexShrink: 0, ...mobileTouchTarget },
   position: { color: tokens.colorNeutralForeground3, fontVariantNumeric: 'tabular-nums' },
   hint: { color: tokens.colorNeutralForeground3 },
diff --git a/frontend/src/components/Scenarios/AttackExecutionTable.tsx b/frontend/src/components/Scenarios/AttackExecutionTable.tsx
index 8152b4b8be..9a9dd39b4e 100644
--- a/frontend/src/components/Scenarios/AttackExecutionTable.tsx
+++ b/frontend/src/components/Scenarios/AttackExecutionTable.tsx
@@ -1,7 +1,6 @@
 import type { CSSProperties } from 'react'
 
 import {
-  Badge,
   Button,
   MessageBar,
   MessageBarActions,
@@ -15,12 +14,11 @@ import {
   Text,
 } from '@fluentui/react-components'
 import { ChevronDownRegular, ChevronRightRegular } from '@fluentui/react-icons'
-import { Link, useLocation, useNavigate } from 'react-router'
+import { Link, useLocation } from 'react-router'
 
 import {
-  formatAttackOutcome,
-  formatAttackSuccess,
   formatDuration,
+  formatRetries,
   formatTimestamp,
   objectivePreview,
 } from '@/components/AttackResults/attackAttemptFormatting'
@@ -28,9 +26,12 @@ import OutcomeBadge from '@/components/OutcomeBadge'
 import type { HierarchyChildrenState, UseScenarioResultHierarchyResult } from '@/hooks/useScenarioResultHierarchy'
 import type { ScenarioHierarchyNode, ScenarioProgressResult } from '@/types'
 import { attackConversationRoutePath } from '@/utils/routeParams'
+import { scoreSummaryFromProgressScore } from '@/utils/scoreSummary'
 
 import { useAttackExecutionTableStyles } from './AttackExecutionTable.styles'
-import { childSlots, hasChildReferences, resultRoleLabel } from './scenarioHierarchy'
+import { childSlots, hasChildReferences } from './scenarioHierarchy'
+
+type AttackExecution = ScenarioProgressResult | ScenarioHierarchyNode
 
 interface AttackExecutionTableProps {
   readonly scenarioResultId: string
@@ -39,13 +40,28 @@ interface AttackExecutionTableProps {
   readonly totalAttempts: number
   readonly roots: ScenarioHierarchyNode[]
   readonly hierarchy: UseScenarioResultHierarchyResult
-  readonly seedObjectives: Map<string, string>
-  readonly onOpenDetails: (result: ScenarioProgressResult | ScenarioHierarchyNode, trigger: HTMLElement) => void
+  readonly seedObjectives: ReadonlyMap<string, string>
+  readonly onOpenDetails: (result: AttackExecution, trigger: HTMLElement) => void
+  /** Technique shorthand per atomic group, shown under each objective instead of the attack class. */
+  readonly techniqueNames?: ReadonlyMap<string, string>
   readonly showTimestamp?: boolean
   readonly showConversationLink?: boolean
   readonly booleanOutcome?: boolean
 }
 
+/** How every row in one table renders, shared by top-level and child rows. */
+interface RowOptions {
+  readonly scenarioResultId: string
+  readonly hierarchy: UseScenarioResultHierarchyResult
+  readonly onOpenDetails: AttackExecutionTableProps['onOpenDetails']
+  readonly techniqueNames?: ReadonlyMap<string, string>
+  readonly showTimestamp: boolean
+  readonly showConversationLink: boolean
+  readonly booleanOutcome: boolean
+  readonly columnCount: number
+}
+
+/** Attack executions as compact rows that open their details; compound parents expand to their saved children. */
 export default function AttackExecutionTable({
   scenarioResultId,
   label,
@@ -55,14 +71,18 @@ export default function AttackExecutionTable({
   hierarchy,
   seedObjectives,
   onOpenDetails,
+  techniqueNames,
   showTimestamp = true,
   showConversationLink = false,
   booleanOutcome = false,
 }: AttackExecutionTableProps) {
   const styles = useAttackExecutionTableStyles()
-  const columnCount = showTimestamp ? 7 : 6
+  const options: RowOptions = {
+    scenarioResultId, hierarchy, onOpenDetails, techniqueNames, showTimestamp, showConversationLink, booleanOutcome,
+    columnCount: 4 + Number(showTimestamp) + Number(showConversationLink),
+  }
   const savedRelationships = hierarchy.roots.status === 'ready'
-  const results: readonly (ScenarioProgressResult | ScenarioHierarchyNode)[] = savedRelationships ? roots : attempts
+  const results: readonly AttackExecution[] = savedRelationships ? roots : attempts
 
   if (results.length === 0) {
     return (
@@ -82,15 +102,14 @@ export default function AttackExecutionTable({
         </Text>
       )}
       <Table size="small" className={styles.table} aria-label={label}>
-        <TableHeader>
-          <TableRow className={styles.headerRow}>
-            <TableHeaderCell>Result / objective</TableHeaderCell>
-            <TableHeaderCell>Result type</TableHeaderCell>
-            <TableHeaderCell>Attack outcome</TableHeaderCell>
-            <TableHeaderCell>Duration</TableHeaderCell>
-            <TableHeaderCell>Retries / error</TableHeaderCell>
-            {showTimestamp && <TableHeaderCell>Timestamp</TableHeaderCell>}
-            <TableHeaderCell>Actions</TableHeaderCell>
+        <TableHeader className={styles.semanticHeader}>
+          <TableRow>
+            <TableHeaderCell scope="col">Objective</TableHeaderCell>
+            <TableHeaderCell scope="col">Outcome</TableHeaderCell>
+            <TableHeaderCell scope="col">Duration</TableHeaderCell>
+            <TableHeaderCell scope="col">Retries / error</TableHeaderCell>
+            {showTimestamp && <TableHeaderCell scope="col">Timestamp</TableHeaderCell>}
+            {showConversationLink && <TableHeaderCell scope="col">Conversation</TableHeaderCell>}
           </TableRow>
         </TableHeader>
         <TableBody>
@@ -107,13 +126,7 @@ export default function AttackExecutionTable({
                 position={null}
                 depth={0}
                 ancestors={NO_ANCESTORS}
-                hierarchy={hierarchy}
-                scenarioResultId={scenarioResultId}
-                onOpenDetails={onOpenDetails}
-                showTimestamp={showTimestamp}
-                showConversationLink={showConversationLink}
-                booleanOutcome={booleanOutcome}
-                columnCount={columnCount}
+                options={options}
               />
             )
           })}
@@ -125,62 +138,44 @@ export default function AttackExecutionTable({
 
 interface ResultRowsProps {
   readonly nodeKey: string
-  readonly result: ScenarioProgressResult | ScenarioHierarchyNode
+  readonly result: AttackExecution
   readonly objective: string
   readonly position: number | null
   readonly depth: number
   readonly ancestors: ReadonlySet<string>
-  readonly hierarchy: UseScenarioResultHierarchyResult
-  readonly scenarioResultId: string
-  readonly onOpenDetails: AttackExecutionTableProps['onOpenDetails']
-  readonly showTimestamp: boolean
-  readonly showConversationLink: boolean
-  readonly booleanOutcome: boolean
-  readonly columnCount: number
+  readonly options: RowOptions
 }
 
-function ResultRows({
-  nodeKey, result, objective, position, depth, ancestors, hierarchy, scenarioResultId, onOpenDetails,
-  showTimestamp, showConversationLink, booleanOutcome, columnCount,
-}: ResultRowsProps) {
+function ResultRows({ nodeKey, result, objective, position, depth, ancestors, options }: ResultRowsProps) {
   const styles = useAttackExecutionTableStyles()
-  const navigate = useNavigate()
   const location = useLocation()
+  const { hierarchy, onOpenDetails } = options
   const node = 'objective' in result ? result : null
   const isExpanded = hierarchy.expanded.has(nodeKey)
   const expandable = node !== null && hasChildReferences(node)
   const preview = objectivePreview(objective || null, result.seed_group_id)
   const label = resultLabel(result, preview, position)
-  const role = node?.result_role ?? 'unknown'
   const conversationPath = result.conversation_id
-    ? attackConversationRoutePath(result.attack_result_id, result.conversation_id, scenarioResultId)
+    ? attackConversationRoutePath(result.attack_result_id, result.conversation_id, options.scenarioResultId)
     : null
-
-  const openResult = (trigger: HTMLElement): void => {
-    if (conversationPath) {
-      navigate(conversationPath, { state: location.state })
-    } else if (expandable) {
-      hierarchy.toggleNode(nodeKey, node)
-    } else {
-      onOpenDetails(result, trigger)
-    }
-  }
+  const error = result.outcome === 'error' ? result.error_message ?? result.error_type ?? 'Error' : null
 
   return (
     <>
       <TableRow
         className={styles.resultRow}
         tabIndex={0}
-        aria-label={`${conversationPath ? 'View conversation' : expandable ? 'View child results' : 'View details'} for ${label}`}
+        aria-label={`View attack details for ${label}`}
         onClick={(event) => {
+          if (!(event.target instanceof Node) || !event.currentTarget.contains(event.target)) return
           if (event.target instanceof Element && event.target.closest('a, button')) return
-          openResult(event.currentTarget)
+          onOpenDetails(result, event.currentTarget)
         }}
         onKeyDown={(event) => {
           if (event.target !== event.currentTarget) return
           if (event.key === 'Enter' || event.key === ' ') {
             event.preventDefault()
-            openResult(event.currentTarget)
+            onOpenDetails(result, event.currentTarget)
           }
         }}
       >
@@ -201,55 +196,36 @@ function ResultRows({
             )}
             {position !== null && <Text className={styles.position}>#{position + 1}</Text>}
             <div className={styles.identity}>
-              {conversationPath ? (
-                <Link className={styles.objectiveLink} to={conversationPath} state={location.state} title={objective}>
-                  {preview}
-                </Link>
-              ) : (
-                <Text title={objective}>{preview}</Text>
-              )}
-              <Text size={200} className={styles.hint}>{result.atomic_attack_name}</Text>
+              <Text weight="semibold" title={objective}>{preview}</Text>
+              <Text size={200} className={styles.hint}>
+                {options.techniqueNames?.get(result.atomic_group_id) ?? result.atomic_attack_name}
+              </Text>
             </div>
           </div>
         </TableCell>
-        <TableCell>
-          <Badge appearance="outline" color={role === 'unknown' ? 'subtle' : 'brand'}>
-            {resultRoleLabel(role)}
-          </Badge>
-        </TableCell>
-        <TableCell>
+        <TableCell aria-label="Attack outcome">
           <OutcomeBadge
             appearance="tint"
             outcome={result.outcome}
-            label={booleanOutcome ? formatAttackSuccess(result.outcome) : formatAttackOutcome(result.outcome)}
+            labelStyle={options.booleanOutcome ? 'success' : 'outcome'}
+            score={result.score ? scoreSummaryFromProgressScore(result.score) : null}
+            scoreFallback={error ?? 'No score was saved for this result.'}
+            scoreButtonLabel={`View score for ${label}`}
           />
         </TableCell>
-        <TableCell className={styles.nowrap}>{formatDuration(result.execution_time_ms)}</TableCell>
-        <TableCell>
-          <Text>{result.total_retries}</Text>
-          {result.outcome === 'error' && (
-            <Text as="p" size={200} className={styles.hint}>
-              {result.error_message ?? result.error_type ?? 'Error'}
-            </Text>
-          )}
-        </TableCell>
-        {showTimestamp && <TableCell className={styles.nowrap}>{formatTimestamp(result.timestamp)}</TableCell>}
-        <TableCell>
-          {showConversationLink && conversationPath && (
-            <Link to={conversationPath} state={location.state}>Conversation</Link>
-          )}
-          <Button
-            size="small"
-            className={styles.touchTarget}
-            aria-label={`Open details for ${label}`}
-            onClick={(event) => {
-              event.stopPropagation()
-              onOpenDetails(result, event.currentTarget)
-            }}
-          >
-            Details
-          </Button>
+        <TableCell aria-label="Duration" className={styles.nowrap}>{formatDuration(result.execution_time_ms)}</TableCell>
+        <TableCell aria-label="Retries / error">
+          <Text>{formatRetries(result.total_retries)}{error ? ' / error' : ''}</Text>
+          {error && <Text as="p" size={200} className={styles.hint}>{error}</Text>}
         </TableCell>
+        {options.showTimestamp && (
+          <TableCell aria-label="Timestamp" className={styles.nowrap}>{formatTimestamp(result.timestamp)}</TableCell>
+        )}
+        {options.showConversationLink && (
+          <TableCell className={styles.actions}>
+            {conversationPath && <Link to={conversationPath} state={location.state}>Conversation</Link>}
+          </TableCell>
+        )}
       </TableRow>
       {node && expandable && isExpanded && (
         <ChildRows
@@ -258,13 +234,7 @@ function ResultRows({
           depth={depth + 1}
           ancestors={new Set([...ancestors, node.attack_result_id])}
           state={hierarchy.children.get(nodeKey)}
-          hierarchy={hierarchy}
-          scenarioResultId={scenarioResultId}
-          onOpenDetails={onOpenDetails}
-          showTimestamp={showTimestamp}
-          showConversationLink={showConversationLink}
-          booleanOutcome={booleanOutcome}
-          columnCount={columnCount}
+          options={options}
         />
       )}
     </>
@@ -277,20 +247,12 @@ interface ChildRowsProps {
   readonly depth: number
   readonly ancestors: ReadonlySet<string>
   readonly state: HierarchyChildrenState | undefined
-  readonly hierarchy: UseScenarioResultHierarchyResult
-  readonly scenarioResultId: string
-  readonly onOpenDetails: AttackExecutionTableProps['onOpenDetails']
-  readonly showTimestamp: boolean
-  readonly showConversationLink: boolean
-  readonly booleanOutcome: boolean
-  readonly columnCount: number
+  readonly options: RowOptions
 }
 
-function ChildRows({
-  parentKey, parent, depth, ancestors, state, hierarchy, scenarioResultId, onOpenDetails,
-  showTimestamp, showConversationLink, booleanOutcome, columnCount,
-}: ChildRowsProps) {
+function ChildRows({ parentKey, parent, depth, ancestors, state, options }: ChildRowsProps) {
   const styles = useAttackExecutionTableStyles()
+  const { hierarchy, columnCount } = options
   const pages = state?.pages ?? []
   const slots = pages.flatMap(childSlots)
   return (
@@ -307,13 +269,7 @@ function ChildRows({
               position={slot.position}
               depth={depth}
               ancestors={ancestors}
-              hierarchy={hierarchy}
-              scenarioResultId={scenarioResultId}
-              onOpenDetails={onOpenDetails}
-              showTimestamp={showTimestamp}
-              showConversationLink={showConversationLink}
-              booleanOutcome={booleanOutcome}
-              columnCount={columnCount}
+              options={options}
             />
           )
         }
diff --git a/frontend/src/components/Scenarios/LiveAttacksPopover.tsx b/frontend/src/components/Scenarios/LiveAttacksPopover.tsx
new file mode 100644
index 0000000000..6bf1536ab0
--- /dev/null
+++ b/frontend/src/components/Scenarios/LiveAttacksPopover.tsx
@@ -0,0 +1,50 @@
+import { Button, Popover, PopoverSurface, PopoverTrigger, Text } from '@fluentui/react-components'
+import { Link } from 'react-router'
+
+import type { ScenarioActiveConversation } from '@/types'
+import { attackConversationRoutePath } from '@/utils/routeParams'
+
+import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+import type { LiveAttack } from './scenarioRunLayout'
+
+const HEADING_ID = 'live-attacks-heading'
+
+interface LiveAttacksPopoverProps {
+  readonly scenarioResultId: string
+  readonly liveAttacks: readonly LiveAttack[]
+  /** Router state carried to a live conversation, so its back link returns here. */
+  readonly conversationState: unknown
+  readonly onOpenAttack: (conversation: ScenarioActiveConversation, trigger: HTMLElement) => void
+}
+
+/** The attacks running right now, each opening its details or its live conversation in Chat. */
+export default function LiveAttacksPopover({ scenarioResultId, liveAttacks, conversationState, onOpenAttack }: LiveAttacksPopoverProps) {
+  const styles = useScenarioRunPageStyles()
+  return (
+    <Popover positioning="below-end" withArrow>
+      <PopoverTrigger disableButtonEnhancement>
+        <Button className={styles.touchTarget} disabled={liveAttacks.length === 0}>
+          View live attacks ({liveAttacks.length})
+        </Button>
+      </PopoverTrigger>
+      <PopoverSurface aria-labelledby={HEADING_ID}>
+        <section className={styles.liveActivity}>
+          <Text as="h2" id={HEADING_ID} size={500} weight="semibold">Live attacks</Text>
+          {liveAttacks.map(({ conversation, conversationCount }) => (
+            <div key={conversation.attack_result_id} className={styles.liveConversation}>
+              <Button appearance="transparent" onClick={(event) => { onOpenAttack(conversation, event.currentTarget) }}>
+                {conversation.atomic_attack_name}
+              </Button>
+              <Text className={styles.preview}>{conversation.objective}</Text>
+              {conversationCount > 1 && <Text size={200} className={styles.sectionHint}>{conversationCount} live conversations</Text>}
+              <Link to={attackConversationRoutePath(conversation.attack_result_id, conversation.conversation_id, scenarioResultId)}
+                state={conversationState}>
+                Watch live conversation
+              </Link>
+            </div>
+          ))}
+        </section>
+      </PopoverSurface>
+    </Popover>
+  )
+}
diff --git a/frontend/src/components/Scenarios/ScanConversationRedirect.test.tsx b/frontend/src/components/Scenarios/ScanConversationRedirect.test.tsx
new file mode 100644
index 0000000000..7ac4be5291
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScanConversationRedirect.test.tsx
@@ -0,0 +1,76 @@
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { MemoryRouter, Route, Routes, useLocation } from 'react-router'
+
+import { useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
+import type { ScenarioProgressHeader } from '@/types'
+import { INITIAL_SCENARIO_RUN_PROGRESS_STATE, type ScenarioRunProgressState } from '@/utils/scenarioRunProgress'
+
+import ScanConversationRedirect from './ScanConversationRedirect'
+
+jest.mock('@/hooks/useScenarioRunProgress', () => ({ useScenarioRunProgress: jest.fn() }))
+
+const RUN_ID = '123e4567-e89b-12d3-a456-426614174000'
+const RUN: ScenarioProgressHeader = {
+  scenario_result_id: RUN_ID, scenario_name: 'review.scan', scenario_version: 1, status: 'IN_PROGRESS',
+  created_at: '2026-01-01T00:00:00Z',
+}
+const retry = jest.fn()
+
+function Destination() {
+  const location = useLocation()
+  return <output aria-label="Location">{location.pathname}{location.search}</output>
+}
+
+function renderRedirect(state: ScenarioRunProgressState) {
+  jest.mocked(useScenarioRunProgress).mockReturnValue({ state, retry, applyRunSummary: jest.fn() })
+  render(<FluentProvider theme={webLightTheme}>
+    <MemoryRouter initialEntries={[`/scanner/history/${RUN_ID}/conversations/branch-2`]}>
+      <Routes>
+        <Route path="/scanner/history/:scenarioResultId/conversations/:conversationId" element={<ScanConversationRedirect />} />
+        <Route path="*" element={<Destination />} />
+      </Routes>
+    </MemoryRouter>
+  </FluentProvider>)
+}
+
+describe('ScanConversationRedirect', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('should open a running attack conversation in Chat from the run progress', () => {
+    renderRedirect({
+      ...INITIAL_SCENARIO_RUN_PROGRESS_STATE, loadStatus: 'ready', run: RUN,
+      activeConversations: [{
+        attack_result_id: 'live', conversation_id: 'branch-3', conversation_ids: ['branch-2', 'branch-3'],
+        atomic_attack_name: 'Crescendo', objective: 'Objective', started_at: RUN.created_at, seed_identifiers: [],
+      }],
+    })
+    expect(screen.getByLabelText('Location')).toHaveTextContent(
+      `/attack/chat/live/conversations/branch-2?scenarioResultId=${RUN_ID}`,
+    )
+    expect(useScenarioRunProgress).toHaveBeenCalledWith(RUN_ID)
+  })
+
+  it('should keep waiting while the run loads', () => {
+    renderRedirect(INITIAL_SCENARIO_RUN_PROGRESS_STATE)
+    expect(screen.getByText('Loading scan')).toBeInTheDocument()
+    expect(screen.getByRole('link', { name: 'Back to scan' })).toHaveAttribute('href', `/scanner/history/${RUN_ID}`)
+  })
+
+  it('should say when a finished run has no such conversation', () => {
+    renderRedirect({ ...INITIAL_SCENARIO_RUN_PROGRESS_STATE, loadStatus: 'ready', run: { ...RUN, status: 'COMPLETED' } })
+    expect(screen.getByText('This conversation is not part of the scan.')).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Retry' })).not.toBeInTheDocument()
+  })
+
+  it('should offer Retry when the run cannot be read', async () => {
+    const user = userEvent.setup()
+    renderRedirect({ ...INITIAL_SCENARIO_RUN_PROGRESS_STATE, loadStatus: 'error', error: 'Scan unavailable' })
+    expect(screen.getByText('Scan unavailable')).toBeInTheDocument()
+    await user.click(screen.getByRole('button', { name: 'Retry' }))
+    expect(retry).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/frontend/src/components/Scenarios/ScanConversationRedirect.tsx b/frontend/src/components/Scenarios/ScanConversationRedirect.tsx
new file mode 100644
index 0000000000..e37abecbc5
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScanConversationRedirect.tsx
@@ -0,0 +1,48 @@
+import { Button, MessageBar, MessageBarBody } from '@fluentui/react-components'
+import { ArrowLeftRegular } from '@fluentui/react-icons'
+import { Link, Navigate, useLocation, useParams } from 'react-router'
+
+import { useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
+import { attackConversationRoutePath, routerPathParamValue, scenarioRunRoutePath } from '@/utils/routeParams'
+import { isTerminalRunState } from '@/utils/scenarioRunProgress'
+
+import AttackActivity from './AttackActivity'
+import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+import { attackIdForConversation } from './scenarioRunLayout'
+
+/** Opens an old scan conversation link in Chat, which shows running and finished scan attacks alike. */
+export default function ScanConversationRedirect() {
+  const params = useParams<{ scenarioResultId: string; conversationId: string }>()
+  const scenarioResultId = routerPathParamValue(params.scenarioResultId)
+  const conversationId = routerPathParamValue(params.conversationId)
+  return <ScanConversationLookup key={`${scenarioResultId}:${conversationId}`}
+    scenarioResultId={scenarioResultId} conversationId={conversationId} />
+}
+
+interface ScanConversationLookupProps {
+  readonly scenarioResultId: string
+  readonly conversationId: string
+}
+
+function ScanConversationLookup({ scenarioResultId, conversationId }: ScanConversationLookupProps) {
+  const styles = useScenarioRunPageStyles()
+  const location = useLocation()
+  const { state, retry } = useScenarioRunProgress(scenarioResultId)
+  const attackId = attackIdForConversation(state, conversationId)
+  if (attackId) {
+    return <Navigate replace state={location.state}
+      to={attackConversationRoutePath(attackId, conversationId, scenarioResultId)} />
+  }
+  const missing = state.run !== null && isTerminalRunState(state.run.status)
+  return (
+    <main className={styles.root}><div className={styles.content}>
+      <Link to={scenarioRunRoutePath(scenarioResultId)} className={styles.backLink}><ArrowLeftRegular /> Back to scan</Link>
+      {state.loadStatus === 'loading' || (!missing && !state.error) ? <AttackActivity loading /> : (
+        <MessageBar intent="error"><MessageBarBody>
+          {missing ? 'This conversation is not part of the scan.' : state.error}
+          {!missing && <Button onClick={retry}>Retry</Button>}
+        </MessageBarBody></MessageBar>
+      )}
+    </div></main>
+  )
+}
diff --git a/frontend/src/components/Scenarios/ScenarioAttackDetails.tsx b/frontend/src/components/Scenarios/ScenarioAttackDetails.tsx
new file mode 100644
index 0000000000..35c60f3d3c
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScenarioAttackDetails.tsx
@@ -0,0 +1,73 @@
+import AttackAttemptDetails from '@/components/AttackResults/AttackAttemptDetails'
+import type { ScenarioRunAttempt } from '@/hooks/useScenarioRunAttackDetails'
+import type {
+  ScenarioActiveConversation,
+  ScenarioHierarchyGroup,
+  ScenarioHierarchyNode,
+  ScenarioProgressSummary,
+  ScenarioRunPlan,
+} from '@/types'
+import { attackConversationRoutePath } from '@/utils/routeParams'
+
+/** What a scan run knows about its attacks, shared by every place that shows one attack's details. */
+export interface ScenarioRunDetailsContext {
+  readonly scenarioResultId: string
+  /** The run's Operation, offered first when attaching an attack to a finding. */
+  readonly operationId?: string | null
+  readonly plan: ScenarioRunPlan | null
+  readonly summary: ScenarioProgressSummary
+  readonly activeConversations: readonly ScenarioActiveConversation[]
+  readonly hierarchyGroups: readonly ScenarioHierarchyGroup[]
+  readonly seedObjectives: ReadonlyMap<string, string>
+  /** Router state carried to the conversation, so its back link returns here. */
+  readonly conversationState: unknown
+}
+
+interface ScenarioAttackDetailsProps {
+  readonly context: ScenarioRunDetailsContext
+  readonly attempt: ScenarioRunAttempt | null
+  /** The planned group to describe while the attack has no attempt yet. */
+  readonly atomicGroupId?: string | null
+  /** The hierarchy node the details were opened from, which may carry the objective. */
+  readonly hierarchySelection?: ScenarioHierarchyNode | null
+  readonly preparing?: boolean
+  readonly framed?: boolean
+}
+
+/** One scan attack's details, resolved from the run's plan, progress, and saved hierarchy. */
+export default function ScenarioAttackDetails({
+  context, attempt, atomicGroupId = null, hierarchySelection = null, preparing = false, framed = false,
+}: ScenarioAttackDetailsProps) {
+  const { scenarioResultId, plan, summary, activeConversations, hierarchyGroups, seedObjectives } = context
+  const groupId = attempt && 'atomic_group_id' in attempt ? attempt.atomic_group_id : atomicGroupId
+  const atomicGroup = groupId ? plan?.atomic_groups.find((group) => group.id === groupId) : undefined
+  const active = attempt
+    ? activeConversations.find((conversation) => conversation.attack_result_id === attempt.attack_result_id)
+    : undefined
+  const seedGroupId = attempt?.seed_group_id ?? atomicGroup?.seed_group_ids[0]
+  const objective = (attempt && hierarchySelection?.attack_result_id === attempt.attack_result_id ? hierarchySelection.objective : null)
+    ?? (attempt && 'objective' in attempt ? attempt.objective : null)
+    ?? (seedGroupId ? seedObjectives.get(seedGroupId) : null)
+    ?? null
+  const techniqueDetails = active?.technique_details
+    ?? summary.atomic_groups.find((group) => group.id === groupId)?.technique_details
+    ?? hierarchyGroups.find((group) => group.atomic_group_id === groupId)?.technique
+    ?? null
+  const conversationId = active?.conversation_id ?? attempt?.conversation_id
+  return (
+    <AttackAttemptDetails
+      attempt={attempt}
+      preparing={preparing}
+      objective={objective}
+      atomicGroup={atomicGroup}
+      techniqueDetails={techniqueDetails}
+      objectiveScorer={summary.objective_scorer}
+      conversationPath={attempt && conversationId
+        ? attackConversationRoutePath(attempt.attack_result_id, conversationId, scenarioResultId)
+        : null}
+      conversationState={context.conversationState}
+      findingOperationId={context.operationId}
+      framed={framed}
+    />
+  )
+}
diff --git a/frontend/src/components/Scenarios/ScenarioConversationPage.test.tsx b/frontend/src/components/Scenarios/ScenarioConversationPage.test.tsx
deleted file mode 100644
index 1a184203b2..0000000000
--- a/frontend/src/components/Scenarios/ScenarioConversationPage.test.tsx
+++ /dev/null
@@ -1,111 +0,0 @@
-import { FluentProvider, webLightTheme } from '@fluentui/react-components'
-import { render, screen, waitFor, within } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { MemoryRouter, Route, Routes, useLocation } from 'react-router'
-
-import { useConversationMessages } from '@/hooks/useConversationMessages'
-import { useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
-import { scenariosApi } from '@/services/api'
-import type { ScenarioRunSummary } from '@/types'
-import { INITIAL_SCENARIO_RUN_PROGRESS_STATE } from '@/utils/scenarioRunProgress'
-
-import ScenarioConversationPage from './ScenarioConversationPage'
-
-jest.mock('@/hooks/useScenarioRunProgress', () => ({ useScenarioRunProgress: jest.fn(), SCENARIO_RUN_POLL_INTERVAL_MS: 2500 }))
-jest.mock('@/hooks/useConversationMessages', () => ({ useConversationMessages: jest.fn() }))
-jest.mock('@/services/api', () => ({ scenariosApi: { cancelRun: jest.fn(), getRunConversation: jest.fn() } }))
-
-const RUN_ID = '123e4567-e89b-12d3-a456-426614174000'
-const applyRunSummary = jest.fn()
-const loadConversation = jest.fn()
-const active = {
-  attack_result_id: 'attempt', conversation_id: 'conversation', atomic_attack_name: 'PromptSendingAttack',
-  objective: 'Review the response', started_at: '2026-01-01T00:00:00Z', seed_identifiers: [],
-}
-const CANCELLED: ScenarioRunSummary = {
-  scenario_result_id: RUN_ID, scenario_name: 'review.scan', scenario_version: 1, status: 'CANCELLED',
-  created_at: '2026-01-01T00:00:00Z', updated_at: '2026-01-01T00:00:00Z', techniques_used: [],
-  total_attacks: 1, completed_attacks: 0, objective_achieved_rate: 0, failed_attacks: [],
-  attack_retries: [], total_retries: 0, labels: {},
-}
-
-function LocationTrace() {
-  const location = useLocation()
-  return <output aria-label="Location">{location.pathname}{location.search}</output>
-}
-
-function Wrapper() {
-  return <FluentProvider theme={webLightTheme}><MemoryRouter initialEntries={[`/scanner/history/${RUN_ID}/conversations/conversation`]}>
-    <LocationTrace /><Routes>
-      <Route path="/scanner/history/:scenarioResultId/conversations/:conversationId" element={<ScenarioConversationPage />} />
-      <Route path="*" element={<h1>Completed conversation</h1>} />
-    </Routes>
-  </MemoryRouter></FluentProvider>
-}
-
-beforeEach(() => {
-  jest.clearAllMocks()
-  ;(useScenarioRunProgress as jest.Mock).mockReturnValue({
-    state: { ...INITIAL_SCENARIO_RUN_PROGRESS_STATE, loadStatus: 'ready',
-      run: { scenario_result_id: RUN_ID, scenario_name: 'review.scan', status: 'IN_PROGRESS' },
-      activeConversations: [active] },
-    retry: jest.fn(), applyRunSummary,
-  })
-  ;(useConversationMessages as jest.Mock).mockReturnValue({
-    messages: [{ role: 'user', content: 'A saved prompt', timestamp: '' }],
-    loadedConversationId: 'conversation', conversationLoadIssue: null, loadConversation,
-  })
-})
-
-it('shows persisted scan messages read-only and uses the scoped conversation API', async () => {
-  jest.mocked(scenariosApi.getRunConversation).mockResolvedValue({ conversation_id: 'conversation', messages: [], target_response_status: null })
-  render(<Wrapper />)
-  expect(screen.getByText('A saved prompt')).toBeInTheDocument()
-  expect(screen.getByRole('button', { name: 'Cancel scan' })).toBeInTheDocument()
-  expect(screen.queryByRole('textbox')).not.toBeInTheDocument()
-  const options = (useConversationMessages as jest.Mock).mock.calls[0][0]
-  await options.readConversationById('conversation')
-  expect(scenariosApi.getRunConversation).toHaveBeenCalledWith(RUN_ID, 'conversation')
-  expect(options.pollIntervalMs).toBe(2500)
-})
-
-it('never offers scan cancellation for an unrelated or unverified conversation', () => {
-  ;(useScenarioRunProgress as jest.Mock).mockReturnValue({
-    state: { ...INITIAL_SCENARIO_RUN_PROGRESS_STATE, loadStatus: 'ready',
-      run: { scenario_result_id: RUN_ID, status: 'IN_PROGRESS' } },
-    retry: jest.fn(), applyRunSummary,
-  })
-  ;(useConversationMessages as jest.Mock).mockReturnValue({
-    messages: [], loadedConversationId: 'conversation',
-    conversationLoadIssue: { conversationId: 'conversation', unavailable: true, detail: 'Not owned by this scan' },
-    loadConversation,
-  })
-  render(<Wrapper />)
-  expect(screen.queryByRole('button', { name: 'Cancel scan' })).not.toBeInTheDocument()
-  expect(screen.getByText('Not owned by this scan')).toBeInTheDocument()
-})
-
-it('cancels the owning scan only after explicit confirmation', async () => {
-  const user = userEvent.setup()
-  jest.mocked(scenariosApi.cancelRun).mockResolvedValue(CANCELLED)
-  render(<Wrapper />)
-  await user.click(screen.getByRole('button', { name: 'Cancel scan' }))
-  expect(scenariosApi.cancelRun).not.toHaveBeenCalled()
-  await user.click(within(screen.getByRole('dialog')).getByRole('button', { name: 'Cancel scan' }))
-  await waitFor(() => expect(scenariosApi.cancelRun).toHaveBeenCalledWith(RUN_ID))
-  expect(applyRunSummary).toHaveBeenCalled()
-})
-
-it('returns completed conversations to the existing per-conversation scoring view', async () => {
-  ;(useScenarioRunProgress as jest.Mock).mockReturnValue({
-    state: { ...INITIAL_SCENARIO_RUN_PROGRESS_STATE, loadStatus: 'ready',
-      run: { scenario_result_id: RUN_ID, status: 'COMPLETED' },
-      results: [{ ...active, outcome: 'success' }] },
-    retry: jest.fn(), applyRunSummary,
-  })
-  render(<Wrapper />)
-  await waitFor(() => expect(screen.getByLabelText('Location')).toHaveTextContent(
-    `/attack/chat/attempt/conversations/conversation?scenarioResultId=${RUN_ID}`,
-  ))
-  expect(screen.queryByRole('button', { name: 'Cancel scan' })).not.toBeInTheDocument()
-})
diff --git a/frontend/src/components/Scenarios/ScenarioConversationPage.transitions.test.tsx b/frontend/src/components/Scenarios/ScenarioConversationPage.transitions.test.tsx
deleted file mode 100644
index 7ad203b830..0000000000
--- a/frontend/src/components/Scenarios/ScenarioConversationPage.transitions.test.tsx
+++ /dev/null
@@ -1,139 +0,0 @@
-import { act } from 'react'
-
-import { FluentProvider, webLightTheme } from '@fluentui/react-components'
-import { render, screen, within } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { MemoryRouter, Route, Routes, useLocation } from 'react-router'
-
-import { scenariosApi } from '@/services/api'
-import type { ConversationMessagesResponse, ScenarioRunProgress, ScenarioRunSummary } from '@/types'
-
-import ScenarioConversationPage from './ScenarioConversationPage'
-
-jest.mock('@/services/api', () => ({
-  scenariosApi: { getRunProgress: jest.fn(), getRunConversation: jest.fn(), cancelRun: jest.fn() },
-  attacksApi: { getMessages: jest.fn() },
-}))
-
-const RUN_ID = '123e4567-e89b-12d3-a456-426614174000'
-const LIVE_PATH = `/scanner/history/${RUN_ID}/conversations/conversation`
-const active = {
-  attack_result_id: 'attempt', conversation_id: 'conversation', atomic_attack_name: 'PromptSendingAttack',
-  objective: 'Review the response', started_at: '2026-01-01T00:00:00Z', seed_group_id: 'seed', seed_identifiers: [],
-}
-const transcript: ConversationMessagesResponse = {
-  conversation_id: 'conversation', target_response_status: null,
-  messages: [{
-    turn_number: 0, role: 'user', created_at: '2026-01-01T00:00:00Z',
-    message_pieces: [{
-      id: 'piece', original_value_data_type: 'text', converted_value_data_type: 'text',
-      converted_value: 'A saved prompt', response_error: 'none', scores: [],
-    }],
-  }],
-}
-
-function progress(status: 'IN_PROGRESS' | 'COMPLETED' | 'CANCELLED'): ScenarioRunProgress {
-  const completed = status === 'COMPLETED'
-  return {
-    run: {
-      scenario_result_id: RUN_ID, scenario_name: 'review.scan', scenario_version: 1, status,
-      created_at: '2026-01-01T00:00:00Z',
-    },
-    summary: {
-      overall: { completed: completed ? 1 : 0, planned: 1, succeeded: completed ? 1 : 0,
-        success_percentage: null, errors: 0, retries: 0 },
-      techniques: [], seed_groups: [], atomic_groups: [],
-    },
-    plan: { version: 1, atomic_groups: [], seed_groups: [{
-      id: 'seed', objective_sha256: 'hash', objective: active.objective, prompts: [],
-    }] },
-    results: completed ? [{
-      ...active, atomic_group_id: 'group', seed_group_id: 'seed', outcome: 'success',
-      execution_time_ms: 1000, timestamp: '2026-01-01T00:00:01Z', total_retries: 0, retries: [],
-    }] : [],
-    active_conversations: status === 'IN_PROGRESS' ? [active] : [],
-    recorded_conversations: status === 'CANCELLED' ? [active] : [],
-    next_cursor: completed ? 'finished' : null, has_more: false, plan_complete: true,
-  }
-}
-
-function LocationTrace() {
-  const location = useLocation()
-  return <output aria-label="Location">{location.pathname}{location.search}</output>
-}
-
-function Wrapper() {
-  return <FluentProvider theme={webLightTheme}><MemoryRouter initialEntries={[LIVE_PATH]}>
-    <LocationTrace /><Routes>
-      <Route path="/scanner/history/:scenarioResultId/conversations/:conversationId" element={<ScenarioConversationPage />} />
-      <Route path="*" element={<h1>Completed conversation</h1>} />
-    </Routes>
-  </MemoryRouter></FluentProvider>
-}
-
-beforeEach(() => {
-  jest.clearAllMocks()
-  jest.useFakeTimers()
-  jest.mocked(scenariosApi.getRunProgress).mockResolvedValue(progress('IN_PROGRESS'))
-  jest.mocked(scenariosApi.getRunConversation).mockResolvedValue(transcript)
-})
-afterEach(() => { jest.useRealTimers() })
-
-it('retains the transcript and stopped state after Cancel and reload without adding an outcome', async () => {
-  const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime })
-  jest.mocked(scenariosApi.cancelRun).mockImplementation(async () => {
-    jest.mocked(scenariosApi.getRunProgress).mockResolvedValue(progress('CANCELLED'))
-    return {
-      ...progress('CANCELLED').run, updated_at: '2026-01-01T00:00:01Z', techniques_used: [],
-      total_attacks: 1, completed_attacks: 0, objective_achieved_rate: 0,
-      failed_attacks: [], attack_retries: [], total_retries: 0, labels: {},
-    } satisfies ScenarioRunSummary
-  })
-  const view = render(<Wrapper />)
-  expect(await screen.findByText('A saved prompt')).toBeInTheDocument()
-  await user.click(screen.getByRole('button', { name: 'Cancel scan' }))
-  await user.click(within(await screen.findByRole('dialog')).getByRole('button', { name: 'Cancel scan' }))
-  expect(await screen.findByText('Stopped before finishing')).toBeInTheDocument()
-  expect(screen.getByText(active.objective)).toBeInTheDocument()
-  expect(screen.getByText('A saved prompt')).toBeInTheDocument()
-  expect(screen.queryByText('This conversation is not part of this scan.')).not.toBeInTheDocument()
-  expect(screen.queryByRole('button', { name: 'Cancel scan' })).not.toBeInTheDocument()
-  view.unmount()
-  render(<Wrapper />)
-  expect(await screen.findByText('Stopped before finishing')).toBeInTheDocument()
-  expect(await screen.findByText('A saved prompt')).toBeInTheDocument()
-  expect(screen.getByLabelText('Location')).toHaveTextContent(LIVE_PATH)
-  expect(scenariosApi.getRunConversation).toHaveBeenLastCalledWith(RUN_ID, 'conversation')
-})
-
-it('loads an earlier conversation by scoped identity before progress publishes its attack ID', async () => {
-  const initialProgress = progress('IN_PROGRESS')
-  initialProgress.active_conversations = []
-  initialProgress.results = []
-  initialProgress.recorded_conversations = []
-  jest.mocked(scenariosApi.getRunProgress).mockResolvedValue(initialProgress)
-  render(<Wrapper />)
-  expect(await screen.findByText('A saved prompt')).toBeInTheDocument()
-  expect(scenariosApi.getRunConversation).toHaveBeenCalledWith(RUN_ID, 'conversation')
-  expect(screen.queryByText('This conversation is not part of this scan.')).not.toBeInTheDocument()
-})
-
-it('moves a live conversation to the canonical completed chat after the progress poll', async () => {
-  render(<Wrapper />)
-  await screen.findByText('A saved prompt')
-  jest.mocked(scenariosApi.getRunProgress).mockResolvedValue(progress('COMPLETED'))
-  await act(async () => { await jest.advanceTimersByTimeAsync(2500) })
-  expect(await screen.findByRole('heading', { name: 'Completed conversation' })).toBeInTheDocument()
-  expect(screen.getByLabelText('Location')).toHaveTextContent(
-    `/attack/chat/attempt/conversations/conversation?scenarioResultId=${RUN_ID}`,
-  )
-})
-
-it('does not expose cancellation when the scoped transcript API rejects ownership', async () => {
-  jest.mocked(scenariosApi.getRunConversation).mockRejectedValue({
-    isAxiosError: true, response: { status: 404, data: { detail: 'Not owned by this scan' } },
-  })
-  render(<Wrapper />)
-  expect(await screen.findByText(/Not owned by this scan/)).toBeInTheDocument()
-  expect(screen.queryByRole('button', { name: 'Cancel scan' })).not.toBeInTheDocument()
-})
diff --git a/frontend/src/components/Scenarios/ScenarioConversationPage.tsx b/frontend/src/components/Scenarios/ScenarioConversationPage.tsx
deleted file mode 100644
index fa32b297bc..0000000000
--- a/frontend/src/components/Scenarios/ScenarioConversationPage.tsx
+++ /dev/null
@@ -1,113 +0,0 @@
-import { useCallback, useEffect, useState } from 'react'
-
-import { Badge, Button, Dialog, DialogActions, DialogBody, DialogContent, DialogSurface, DialogTitle, MessageBar, MessageBarBody, Spinner, Text } from '@fluentui/react-components'
-import { ArrowLeftRegular, StopRegular } from '@fluentui/react-icons'
-import { Link, useNavigate, useParams } from 'react-router'
-
-import MessageList from '@/components/Chat/MessageList'
-import { useConversationMessages } from '@/hooks/useConversationMessages'
-import { SCENARIO_RUN_POLL_INTERVAL_MS, useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
-import { scenariosApi } from '@/services/api'
-import { toApiError } from '@/services/errors'
-import type { ScenarioActiveConversation } from '@/types'
-import { attackConversationRoutePath, routerPathParamValue, scenarioRunRoutePath } from '@/utils/routeParams'
-import { isTerminalRunState } from '@/utils/scenarioRunProgress'
-
-import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
-
-const NO_SENDS: ReadonlySet<string> = new Set()
-const noSendInFlight = (): boolean => false
-
-export default function ScenarioConversationPage() {
-  const { scenarioResultId, conversationId } = useParams<{ scenarioResultId: string; conversationId: string }>()
-  return <ScanConversation key={`${scenarioResultId}:${conversationId}`}
-    scenarioResultId={routerPathParamValue(scenarioResultId)} conversationId={routerPathParamValue(conversationId)} />
-}
-
-interface ScanConversationProps {
-  readonly scenarioResultId: string
-  readonly conversationId: string
-}
-
-function ScanConversation({ scenarioResultId, conversationId }: ScanConversationProps) {
-  const styles = useScenarioRunPageStyles()
-  const navigate = useNavigate()
-  const { state, applyRunSummary, retry } = useScenarioRunProgress(scenarioResultId)
-  const active = state.activeConversations.find((conversation) => conversation.conversation_id === conversationId)
-  const saved = state.results.find((attempt) => attempt.conversation_id === conversationId || attempt.related_conversation_ids?.includes(conversationId))
-  const recorded = state.recordedConversations.find((conversation) => conversation.conversation_id === conversationId)
-  const [lastActive, setLastActive] = useState<ScenarioActiveConversation | null>(null)
-  const attackId = active?.attack_result_id ?? saved?.attack_result_id ?? recorded?.attack_result_id ?? lastActive?.attack_result_id ?? null
-  const running = Boolean(state.run && !isTerminalRunState(state.run.status))
-  const readConversationById = useCallback((selectedId: string) =>
-    scenariosApi.getRunConversation(scenarioResultId, selectedId), [scenarioResultId])
-  const transcript = useConversationMessages({
-    attackResultId: attackId, conversationId, activeConversationId: conversationId,
-    sendingConversations: NO_SENDS, isSendInFlight: noSendInFlight,
-    readConversationById, pollIntervalMs: running ? SCENARIO_RUN_POLL_INTERVAL_MS : undefined,
-  })
-  const [cancelOpen, setCancelOpen] = useState(false)
-  const [cancelling, setCancelling] = useState(false)
-  const [cancelError, setCancelError] = useState<string | null>(null)
-  const verified = transcript.loadedConversationId === conversationId && !transcript.conversationLoadIssue
-  if (active && verified && lastActive !== active) setLastActive(active)
-  const display = active ?? recorded ?? lastActive
-  const stopped = !active && !saved && (recorded !== undefined || (lastActive !== null && state.run?.status === 'CANCELLED'))
-  useEffect(() => {
-    if (!active && saved && verified) {
-      navigate(attackConversationRoutePath(saved.attack_result_id, conversationId, scenarioResultId), { replace: true })
-    }
-  }, [active, saved, verified, navigate, conversationId, scenarioResultId])
-
-  async function cancel(): Promise<void> {
-    setCancelling(true)
-    setCancelError(null)
-    try {
-      applyRunSummary(await scenariosApi.cancelRun(scenarioResultId))
-      setCancelOpen(false)
-    } catch (error: unknown) {
-      setCancelError(toApiError(error).detail)
-    } finally {
-      setCancelling(false)
-    }
-  }
-
-  return (
-    <section className={styles.root} aria-label="Scan conversation">
-      <div className={styles.content}>
-        <Link className={styles.backLink} to={scenarioRunRoutePath(scenarioResultId)}><ArrowLeftRegular /> Back to scan</Link>
-        <header className={styles.header}>
-          <div className={styles.headerIdentity}>
-            <div className={styles.titleRow}><Text as="h1" size={600} weight="semibold">{display?.atomic_attack_name ?? saved?.atomic_attack_name ?? 'Conversation'}</Text>
-              <Badge appearance="tint" color={active ? 'brand' : 'informative'}>{stopped ? 'Stopped before finishing' : active ? 'Executing' : 'Saved conversation'}</Badge>
-            </div>
-            <Text className={styles.sectionHint}>Read-only · {state.run?.scenario_registry_name ?? state.run?.scenario_name}</Text>
-          </div>
-          {running && active && verified && <Button icon={<StopRegular />} className={styles.touchTarget} onClick={() => { setCancelOpen(true) }}>Cancel scan</Button>}
-        </header>
-        <Text>{display?.objective ?? state.plan?.seed_groups.find((seed) => seed.id === saved?.seed_group_id)?.objective}</Text>
-        {stopped && <Text role="status">Saved messages remain available.</Text>}
-        {state.error && <MessageBar intent="error"><MessageBarBody>{state.error} <Button onClick={retry}>Retry scan</Button></MessageBarBody></MessageBar>}
-        {transcript.conversationLoadIssue && <MessageBar intent="error"><MessageBarBody>
-          {transcript.conversationLoadIssue.detail} <Button onClick={() => { void transcript.loadConversation(attackId, conversationId) }}>Retry messages</Button>
-        </MessageBarBody></MessageBar>}
-        {!verified && !transcript.conversationLoadIssue
-          && (state.loadStatus === 'loading' || transcript.isLoadingMessages) && <Spinner label="Loading conversation..." />}
-        <div className={styles.conversationSurface} role="log" aria-label="Conversation messages" aria-live="polite">
-          <MessageList messages={transcript.messages}
-            isLoading={transcript.loadedConversationId === null && (Boolean(attackId) || transcript.isLoadingMessages)} />
-        </div>
-        {active && <Text size={200} className={styles.sectionHint} role="status">Saved messages update while the attack runs.</Text>}
-      </div>
-      <Dialog open={cancelOpen} onOpenChange={(_, data) => { if (!cancelling) setCancelOpen(data.open) }}>
-        <DialogSurface><DialogBody><DialogTitle>Cancel scan?</DialogTitle><DialogContent>
-          Stop remaining attacks. Saved conversations stay available.
-          {cancelError && <MessageBar intent="error"><MessageBarBody>{cancelError}</MessageBarBody></MessageBar>}
-        </DialogContent><DialogActions>
-          <Button disabled={cancelling} onClick={() => { setCancelOpen(false) }}>Keep running</Button>
-          <Button appearance="primary" disabled={cancelling} onClick={() => { void cancel() }}>Cancel scan</Button>
-        </DialogActions></DialogBody></DialogSurface>
-      </Dialog>
-    </section>
-  )
-}
diff --git a/frontend/src/components/Scenarios/ScenarioDetail.test.tsx b/frontend/src/components/Scenarios/ScenarioDetail.test.tsx
index 840865200e..89f0f9e409 100644
--- a/frontend/src/components/Scenarios/ScenarioDetail.test.tsx
+++ b/frontend/src/components/Scenarios/ScenarioDetail.test.tsx
@@ -1926,6 +1926,23 @@ describe('ScenarioDetail', () => {
     expect(mockStartRun).not.toHaveBeenCalled()
   })
 
+  it('reveals a recorded technique identity with the shared identity JSON', async () => {
+    const user = userEvent.setup()
+    const identifier = { class_name: 'CrescendoAttack', class_module: 'pyrit.executor.attack', hash: 'crescendo-hash' }
+    mockGetScenario.mockResolvedValue(makeScenario({ technique_summaries: [
+      { name: 'default_technique', description: null, tags: ['default'] },
+      { name: 'crescendo', description: null, tags: ['multi_turn'], identifier },
+    ] }))
+    renderDetail('/scanner/launch/foundry.red_team_agent')
+    await screen.findByTestId('scenario-target-select')
+
+    await user.click(screen.getByRole('button', { name: 'Identity for crescendo' }))
+
+    const region = screen.getByRole('region', { name: 'Identity for crescendo' })
+    expect(JSON.parse(region.textContent ?? '')).toEqual(identifier)
+    expect(region.scrollIntoView).toHaveBeenCalled()
+  })
+
   it('includes the baseline when a shared tag selects or clears its members', async () => {
     const user = userEvent.setup()
     renderDetail('/scanner/launch/foundry.red_team_agent')
diff --git a/frontend/src/components/Scenarios/ScenarioResultHierarchy.test.tsx b/frontend/src/components/Scenarios/ScenarioResultHierarchy.test.tsx
index a56f76642a..e0dbb79c8a 100644
--- a/frontend/src/components/Scenarios/ScenarioResultHierarchy.test.tsx
+++ b/frontend/src/components/Scenarios/ScenarioResultHierarchy.test.tsx
@@ -440,15 +440,15 @@ test('shows empty, truncated and rootless states without inventing roots', async
   expect(screen.queryByRole('button', { name: /Expand/ })).not.toBeInTheDocument()
 })
 
-test('opens details for a node with the clicked button as the focus target', async () => {
+test('opens attack details for a node with the clicked row as the focus target', async () => {
   const user = userEvent.setup()
   getRoots.mockResolvedValue(projection([node('r1')]))
   const { onOpenResult } = mount()
 
-  const button = await screen.findByRole('button', { name: 'Open details for attack r1: objective r1' })
-  await user.click(button)
+  const row = await screen.findByRole('row', { name: 'View attack details for attack r1: objective r1' })
+  await user.click(row)
 
-  expect(onOpenResult).toHaveBeenCalledWith(expect.objectContaining({ attack_result_id: 'r1' }), button)
+  expect(onOpenResult).toHaveBeenCalledWith(expect.objectContaining({ attack_result_id: 'r1' }), row)
 })
 
 test('an empty run says so', async () => {
@@ -580,22 +580,18 @@ test('shows results in aligned columns with the attack outcome spelled out', asy
   await user.click(await screen.findByRole('button', { name: 'Expand children of attack parent: objective parent' }))
   await screen.findByText('objective c1')
 
-  expect(within(resultsTable()).getAllByRole('columnheader').map((header) => header.textContent)).toEqual([
-    'Result / objective',
-    'Result type',
-    'Attack outcome',
-    'Duration',
-    'Retries / error',
-    'Timestamp',
-    'Actions',
+  const headers = within(resultsTable()).getAllByRole('columnheader')
+  expect(headers.map((header: HTMLElement) => header.textContent)).toEqual([
+    'Objective', 'Outcome', 'Duration', 'Retries / error', 'Timestamp',
   ])
+  for (const header of headers) expect(header).toHaveAttribute('scope', 'col')
   // A child row has the same cells in the same columns as its parent; only the first column is indented.
   const cells = (text: string) => within(rowWith(text)).getAllByRole('cell').map((cell) => cell.textContent)
   expect(cells('objective parent')).toEqual([
-    'objective parentattack parent', 'Orchestration', 'Success', '1s', '0', expect.any(String), 'Details',
+    'objective parentattack parent', 'Success', '1s', 'No retries', expect.any(String),
   ])
   expect(cells('objective c1')).toEqual([
-    '#1objective c1attack c1', 'Target-facing', 'Error', '1s', '2Target timed out', expect.any(String), 'Details',
+    '#1objective c1attack c1', 'Error', '1s', '2 retries / errorTarget timed out', expect.any(String),
   ])
-  expect(screen.getByText(/^Result rows are saved attacks\./)).toHaveTextContent('not chat messages or retries')
+  expect(screen.queryByText(/^Result rows are saved attacks\./)).not.toBeInTheDocument()
 })
diff --git a/frontend/src/components/Scenarios/ScenarioResultHierarchy.tsx b/frontend/src/components/Scenarios/ScenarioResultHierarchy.tsx
index f41648208a..087a23bc9d 100644
--- a/frontend/src/components/Scenarios/ScenarioResultHierarchy.tsx
+++ b/frontend/src/components/Scenarios/ScenarioResultHierarchy.tsx
@@ -42,14 +42,7 @@ export default function ScenarioResultHierarchy({
             <Button className={styles.touchTarget} onClick={hierarchy.reloadRoots}>Retry</Button>
           </MessageBarActions>
         </MessageBar>
-      ) : (
-        <Text size={200} className={styles.hint}>
-          Result rows are saved attacks. Orchestration rows are compound parents: expand them to see the attacks
-          they ran in saved order, not chat messages or retries. Unresolved rows are references, not extra results.
-          Click a result with a saved chat to open it; Details shows metadata. Group metrics come from the run
-          summary, not a count of these rows.
-        </Text>
-      )}
+      ) : null}
       {roots.status === 'ready' && (runActive || statusChanged) && (
         <div className={styles.footer}>
           <Text size={200} className={styles.hint}>
diff --git a/frontend/src/components/Scenarios/ScenarioRunConfigurationSection.tsx b/frontend/src/components/Scenarios/ScenarioRunConfigurationSection.tsx
new file mode 100644
index 0000000000..462fb460d6
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScenarioRunConfigurationSection.tsx
@@ -0,0 +1,27 @@
+import { useState } from 'react'
+
+import { Table, TableBody, Text } from '@fluentui/react-components'
+
+import RegistryIdentityRow from '@/components/Registry/RegistryIdentityRow'
+import type { ScenarioProgressHeader } from '@/types'
+
+import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+
+interface ScenarioRunConfigurationSectionProps {
+  readonly run: ScenarioProgressHeader
+}
+
+/** The saved scenario identity the scan ran with. */
+export default function ScenarioRunConfigurationSection({ run }: ScenarioRunConfigurationSectionProps) {
+  const styles = useScenarioRunPageStyles()
+  const [identityExpanded, setIdentityExpanded] = useState(false)
+  return (
+    <section className={styles.section} aria-labelledby="configuration-heading">
+      <Text as="h2" id="configuration-heading" size={500} weight="semibold">Scenario configuration</Text>
+      {run.scenario_identity ? <Table size="small" aria-label="Scenario configuration"><TableBody>
+        <RegistryIdentityRow name={run.scenario_registry_name ?? run.scenario_name} identity={run.scenario_identity}
+          columns={1} expanded={identityExpanded} onToggle={() => { setIdentityExpanded((value: boolean) => !value) }} />
+      </TableBody></Table> : <Text className={styles.sectionHint}>No saved scenario identity.</Text>}
+    </section>
+  )
+}
diff --git a/frontend/src/components/Scenarios/ScenarioRunDialogs.tsx b/frontend/src/components/Scenarios/ScenarioRunDialogs.tsx
index 7ddf7848e9..4b8aa0ff7b 100644
--- a/frontend/src/components/Scenarios/ScenarioRunDialogs.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunDialogs.tsx
@@ -7,6 +7,8 @@ import {
   DialogContent,
   DialogSurface,
   DialogTitle,
+  MessageBar,
+  MessageBarBody,
   Text,
   mergeClasses,
 } from '@fluentui/react-components'
@@ -46,9 +48,14 @@ interface ObjectiveDetailsDialogProps {
   readonly attempts: ScenarioProgressResult[]
   readonly onOpenAttempt: (attempt: ScenarioProgressResult, trigger: HTMLElement) => void
   readonly scenarioResultId: string
+  /** Technique shorthand per atomic group, shown under each attack. */
+  readonly techniqueNames: ReadonlyMap<string, string>
 }
 
-export function ObjectiveDetailsDialog({ objective, onClose, attempts, onOpenAttempt, scenarioResultId }: ObjectiveDetailsDialogProps) {
+/** An objective's text, its seed prompts, and the attacks that pursued it. */
+export function ObjectiveDetailsDialog({
+  objective, onClose, attempts, onOpenAttempt, scenarioResultId, techniqueNames,
+}: ObjectiveDetailsDialogProps) {
   const styles = useScenarioRunPageStyles()
 
   return (
@@ -90,7 +97,7 @@ export function ObjectiveDetailsDialog({ objective, onClose, attempts, onOpenAtt
                 <AttackExecutionTable label="Atomic attacks" attempts={attempts} totalAttempts={attempts.length}
                   roots={[]} hierarchy={EMPTY_HIERARCHY}
                   scenarioResultId={scenarioResultId} seedObjectives={new Map([[objective.id, objective.objective]])}
-                  onOpenDetails={onOpenAttempt} showTimestamp={false} booleanOutcome />
+                  techniqueNames={techniqueNames} onOpenDetails={onOpenAttempt} showTimestamp={false} booleanOutcome />
               </section>
             </DialogContent>
           )}
@@ -102,3 +109,25 @@ export function ObjectiveDetailsDialog({ objective, onClose, attempts, onOpenAtt
     </Dialog>
   )
 }
+
+interface CancelScanDialogProps {
+  readonly open: boolean
+  readonly cancelling: boolean
+  readonly error: string | null
+  readonly onOpenChange: (open: boolean) => void
+  readonly onConfirm: () => void
+}
+
+export function CancelScanDialog({ open, cancelling, error, onOpenChange, onConfirm }: CancelScanDialogProps) {
+  const styles = useScenarioRunPageStyles()
+  return (
+    <Dialog open={open} onOpenChange={(_, data) => { onOpenChange(data.open) }}>
+      <DialogSurface><DialogBody><DialogTitle>Cancel scan?</DialogTitle><DialogContent className={styles.dialogContent}>
+        <Text>Stop remaining attacks. Saved conversations and results stay available.</Text>
+        {error && <MessageBar intent="error"><MessageBarBody>{error}</MessageBarBody></MessageBar>}
+      </DialogContent><DialogActions><Button disabled={cancelling} onClick={() => { onOpenChange(false) }}>Keep running</Button>
+        <Button appearance="primary" disabled={cancelling} onClick={onConfirm}>{cancelling ? 'Cancelling...' : 'Cancel scan'}</Button>
+      </DialogActions></DialogBody></DialogSurface>
+    </Dialog>
+  )
+}
diff --git a/frontend/src/components/Scenarios/ScenarioRunHeader.tsx b/frontend/src/components/Scenarios/ScenarioRunHeader.tsx
new file mode 100644
index 0000000000..cc098b6bf8
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScenarioRunHeader.tsx
@@ -0,0 +1,58 @@
+import type { Ref } from 'react'
+
+import { Button, MessageBar, MessageBarBody, Text } from '@fluentui/react-components'
+import { ArrowClockwiseRegular, PlayRegular, StopRegular } from '@fluentui/react-icons'
+import { Link } from 'react-router'
+
+import OperationParentLink from '@/components/Operations/OperationParentLink'
+import ScanStatusBadge from '@/components/ScanStatusBadge'
+import type { ScenarioRunControls } from '@/hooks/useScenarioRunControls'
+import type { ScenarioProgressHeader } from '@/types'
+
+import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+
+interface ScenarioRunHeaderProps {
+  readonly run: ScenarioProgressHeader
+  readonly active: boolean
+  readonly controls: ScenarioRunControls
+  /** Focus target for returning to the run overview. */
+  readonly headerRef: Ref<HTMLElement>
+}
+
+/** The scan's Operation, title, state, and run controls, with any control failure below them. */
+export default function ScenarioRunHeader({ run, active, controls, headerRef }: ScenarioRunHeaderProps) {
+  const styles = useScenarioRunPageStyles()
+  const resumable = run.status === 'FAILED' || run.status === 'CANCELLED'
+  return (
+    <>
+      <header className={styles.header} ref={headerRef} tabIndex={-1}>
+        <div className={styles.headerIdentity}>
+          <OperationParentLink id={run.operation_id} name={run.operation_name} />
+          <div className={styles.titleRow}>
+            <Text as="h1" size={700} weight="semibold">{run.scenario_registry_name ?? run.scenario_name}</Text>
+            <ScanStatusBadge status={run.status} testId="run-state-badge" />
+          </div>
+          {run.description && <Text className={styles.sectionHint}>{run.description}</Text>}
+        </div>
+        <div className={styles.headerActions}>
+          {active && <Link className={styles.backLink} to="/scanner/queue">View queue</Link>}
+          <Button icon={<ArrowClockwiseRegular />} disabled={controls.rerunPending} onClick={controls.rerun}>
+            {controls.rerunPending ? 'Loading...' : 'Rerun with changes'}
+          </Button>
+          {active ? (
+            <Button icon={<StopRegular />} className={styles.touchTarget} onClick={() => { controls.setCancelOpen(true) }}>
+              Cancel
+            </Button>
+          ) : resumable && (
+            <Button appearance="primary" icon={<PlayRegular />} disabled={controls.resumePending} onClick={controls.resume}>
+              Resume
+            </Button>
+          )}
+        </div>
+      </header>
+      {controls.controlError && <MessageBar intent="error"><MessageBarBody>
+        {controls.controlError}
+      </MessageBarBody></MessageBar>}
+    </>
+  )
+}
diff --git a/frontend/src/components/Scenarios/ScenarioRunNotices.tsx b/frontend/src/components/Scenarios/ScenarioRunNotices.tsx
new file mode 100644
index 0000000000..463971acbc
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScenarioRunNotices.tsx
@@ -0,0 +1,82 @@
+import { Accordion, AccordionHeader, AccordionItem, AccordionPanel, Button, MessageBar, MessageBarBody, Text } from '@fluentui/react-components'
+
+import type {
+  ScenarioHierarchyNode,
+  ScenarioOverloadSummary,
+  ScenarioProgressHeader,
+  ScenarioProgressResult,
+  ScenarioProgressSummary,
+} from '@/types'
+import type { ScenarioRunProgressState } from '@/utils/scenarioRunProgress'
+
+import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+
+interface ScenarioRunNoticesProps {
+  readonly run: ScenarioProgressHeader
+  readonly summary: ScenarioProgressSummary
+  readonly state: ScenarioRunProgressState
+  /** The attack shown inline on the page; its own error is already visible there. */
+  readonly inlineAttempt?: ScenarioProgressResult | ScenarioHierarchyNode | null
+  readonly onRetry: () => void
+  readonly onOpenAttempt: (attempt: ScenarioProgressResult, trigger: HTMLElement) => void
+}
+
+/** Run failures, paused live updates, and conditions that limit how far the totals can be trusted. */
+export default function ScenarioRunNotices({ run, summary, state, inlineAttempt, onRetry, onOpenAttempt }: ScenarioRunNoticesProps) {
+  const styles = useScenarioRunPageStyles()
+  const overall = summary.overall
+  const inlineError = inlineAttempt?.outcome === 'error' ? inlineAttempt : null
+  const firstError = inlineError ? undefined : state.results.find((attempt) => attempt.outcome === 'error')
+  const runErrorShownInline = inlineError !== null && run.error === inlineError.error_message
+    && (!run.error_type || run.error_type === inlineError.error_type)
+  const runError = run.error && !runErrorShownInline ? run.error : null
+  const showRunNotice = Boolean(runError) || (!inlineError && (run.status === 'FAILED' || overall.errors > 0))
+  const unmatched = summary.unattributed_attempts ?? 0
+  const overloaded = state.overloadSummaries.length > 0
+  const notices: string[] = []
+  if (overloaded) notices.push('Service overload detected.')
+  if (unmatched > 0) notices.push(`${unmatched} execution${unmatched === 1 ? '' : 's'} could not be matched to the saved plan.`)
+  if (!state.planComplete) notices.push('The saved execution plan is incomplete; some totals cannot be verified.')
+  const runIntent = run.status === 'FAILED' ? 'error' : run.status === 'CANCELLED' && overall.errors === 0 ? 'info' : 'warning'
+
+  return (
+    <>
+      {showRunNotice && <MessageBar intent={runIntent}>
+        <MessageBarBody>{run.status === 'FAILED' ? 'Scan failed. Resume to continue remaining attacks.'
+          : run.status === 'CANCELLED' ? 'Scan cancelled.'
+          : `${overall.errors} attack${overall.errors === 1 ? '' : 's'} ended with an error.`}
+          {firstError && <Button appearance="transparent" onClick={(event) => { onOpenAttempt(firstError, event.currentTarget) }}>
+            View attack
+          </Button>}
+          {runError && <Accordion collapsible><AccordionItem value="error">
+            <AccordionHeader>Error details</AccordionHeader>
+            <AccordionPanel><Text className={styles.objective}>{run.error_type ? `${run.error_type}: ` : ''}{runError}</Text></AccordionPanel>
+          </AccordionItem></Accordion>}
+        </MessageBarBody>
+      </MessageBar>}
+      {state.stale && <MessageBar intent="warning"><MessageBarBody>
+        Live updates paused. {state.error} <Button onClick={onRetry}>Retry</Button>
+      </MessageBarBody></MessageBar>}
+      {notices.length > 0 && <MessageBar aria-label="Scan notices" intent={overloaded || unmatched > 0 ? 'warning' : 'info'}>
+        <MessageBarBody>
+          {notices.join(' ')}
+          {overloaded && <OverloadDetails overloads={state.overloadSummaries} />}
+        </MessageBarBody>
+      </MessageBar>}
+    </>
+  )
+}
+
+function OverloadDetails({ overloads }: { readonly overloads: readonly ScenarioOverloadSummary[] }) {
+  return (
+    <Accordion collapsible><AccordionItem value="overload">
+      <AccordionHeader>Overload details</AccordionHeader>
+      <AccordionPanel>{overloads.map((overload) => (
+        <Text block key={overload.component_role}>
+          {overload.component_role.replace(/_/g, ' ')}: {overload.count}
+          {overload.status_codes.length > 0 ? ` (HTTP ${overload.status_codes.join(', ')})` : ''}
+        </Text>
+      ))}</AccordionPanel>
+    </AccordionItem></Accordion>
+  )
+}
diff --git a/frontend/src/components/Scenarios/ScenarioRunObjectivesSection.tsx b/frontend/src/components/Scenarios/ScenarioRunObjectivesSection.tsx
new file mode 100644
index 0000000000..9a6ec7dbff
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScenarioRunObjectivesSection.tsx
@@ -0,0 +1,76 @@
+import { useMemo } from 'react'
+
+import { Button, Table, TableBody, TableCell, TableHeader, TableHeaderCell, TableRow, Text } from '@fluentui/react-components'
+
+import { formatProgressSuccess, objectivePreview } from '@/components/AttackResults/attackAttemptFormatting'
+import type {
+  ScenarioActiveConversation,
+  ScenarioComponentIdentity,
+  ScenarioProgressResult,
+  ScenarioProgressSummary,
+  ScenarioRunPlan,
+  ScenarioRunPlanSeedGroup,
+} from '@/types'
+
+import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+
+interface ScenarioRunObjectivesSectionProps {
+  readonly summary: ScenarioProgressSummary
+  readonly plan: ScenarioRunPlan | null
+  readonly results: readonly ScenarioProgressResult[]
+  readonly activeConversations: readonly ScenarioActiveConversation[]
+  readonly onOpenObjective: (objective: ScenarioRunPlanSeedGroup, trigger: HTMLElement) => void
+}
+
+function seedDatasetNames(identities: ScenarioComponentIdentity[]): string {
+  return [...new Set(identities.flatMap((identity: ScenarioComponentIdentity) =>
+    typeof identity.parameters.dataset_name === 'string' ? [identity.parameters.dataset_name] : []))].join(', ')
+}
+
+/** Each objective's dataset, attack success, and completion, opening its seed prompts and attacks. */
+export default function ScenarioRunObjectivesSection({
+  summary, plan, results, activeConversations, onOpenObjective,
+}: ScenarioRunObjectivesSectionProps) {
+  const styles = useScenarioRunPageStyles()
+  const planSeeds = useMemo(
+    () => new Map(plan?.seed_groups.map((seed) => [seed.id, seed]) ?? []),
+    [plan],
+  )
+  const datasetsBySeed = useMemo(() => {
+    const identities = new Map<string, ScenarioComponentIdentity[]>()
+    for (const attempt of [...results, ...activeConversations]) {
+      if (!attempt.seed_group_id) continue
+      const seeds = identities.get(attempt.seed_group_id) ?? []
+      seeds.push(...(attempt.seed_identifiers ?? []))
+      identities.set(attempt.seed_group_id, seeds)
+    }
+    return new Map([...identities].map(([id, seeds]) => [id, seedDatasetNames(seeds)]))
+  }, [results, activeConversations])
+
+  return (
+    <section className={styles.section} aria-labelledby="objectives-heading">
+      <Text as="h2" id="objectives-heading" size={500} weight="semibold">Datasets &amp; objectives</Text>
+      <div className={styles.tableScroll}><Table size="small" aria-label="Datasets and objectives">
+        <TableHeader><TableRow>
+          <TableHeaderCell>Dataset</TableHeaderCell><TableHeaderCell>Objective</TableHeaderCell>
+          <TableHeaderCell>Attack success</TableHeaderCell><TableHeaderCell>Completed</TableHeaderCell>
+        </TableRow></TableHeader>
+        <TableBody>{summary.seed_groups.map((seed) => (
+          <TableRow key={seed.id}>
+            <TableCell>{datasetsBySeed.get(seed.id) || 'Not recorded'}</TableCell>
+            <TableCell><Button appearance="transparent" className={styles.objectiveLinkButton} onClick={(event) => {
+              onOpenObjective(
+                planSeeds.get(seed.id) ?? { id: seed.id, objective_sha256: '', objective: seed.objective ?? 'Not recorded', prompts: [] },
+                event.currentTarget,
+              )
+            }}>
+              {objectivePreview(seed.objective ?? null, seed.id)}
+            </Button></TableCell>
+            <TableCell>{formatProgressSuccess(seed)}</TableCell>
+            <TableCell>{seed.completed}{seed.planned === null ? '' : ` / ${seed.planned}`}</TableCell>
+          </TableRow>
+        ))}</TableBody>
+      </Table></div>
+    </section>
+  )
+}
diff --git a/frontend/src/components/Scenarios/ScenarioRunPage.styles.ts b/frontend/src/components/Scenarios/ScenarioRunPage.styles.ts
index 5ed7396aac..84ccca2689 100644
--- a/frontend/src/components/Scenarios/ScenarioRunPage.styles.ts
+++ b/frontend/src/components/Scenarios/ScenarioRunPage.styles.ts
@@ -65,6 +65,8 @@ export const useScenarioRunPageStyles = makeStyles({
   },
   titleRow: {
     display: 'flex',
+    minWidth: 0,
+    overflowWrap: 'anywhere',
     alignItems: 'center',
     flexWrap: 'wrap',
     gap: tokens.spacingHorizontalS,
@@ -92,33 +94,13 @@ export const useScenarioRunPageStyles = makeStyles({
       flexGrow: 1,
     },
   },
-  metadata: {
-    display: 'grid',
-    gridTemplateColumns: 'repeat(6, minmax(0, 1fr))',
-    gap: `${tokens.spacingVerticalS} ${tokens.spacingHorizontalXL}`,
-    padding: tokens.spacingVerticalL,
-    border: `1px solid ${tokens.colorNeutralStroke2}`,
-    borderRadius: tokens.borderRadiusLarge,
-    backgroundColor: tokens.colorNeutralBackground1,
-    [NARROW_VIEWPORT_QUERY]: {
-      gridTemplateColumns: 'repeat(2, minmax(0, 1fr))',
-    },
-  },
-  metadataItem: {
+  progressTiming: {
     display: 'flex',
     flexDirection: 'column',
-    gap: tokens.spacingVerticalXXS,
+    gap: tokens.spacingVerticalXS,
     minWidth: 0,
-    overflowWrap: 'anywhere',
-  },
-  labelBadge: {
-    maxWidth: '100%',
-    height: 'auto',
-    whiteSpace: 'normal',
-    overflowWrap: 'anywhere',
-  },
-  metadataLabel: {
     color: tokens.colorNeutralForeground3,
+    fontVariantNumeric: 'tabular-nums',
   },
   section: {
     display: 'flex',
@@ -155,6 +137,20 @@ export const useScenarioRunPageStyles = makeStyles({
       gap: tokens.spacingVerticalM,
     },
   },
+  progressRegion: {
+    display: 'grid',
+    gridTemplateRows: '1fr',
+    opacity: 1,
+    transitionProperty: 'grid-template-rows, opacity',
+    transitionDuration: tokens.durationNormal,
+    transitionTimingFunction: tokens.curveDecelerateMid,
+    '@media (prefers-reduced-motion: reduce)': { transitionDuration: '0s' },
+  },
+  progressRegionComplete: {
+    gridTemplateRows: '0fr',
+    opacity: 0,
+  },
+  progressClip: { minHeight: 0, overflow: 'hidden' },
   progressPrimary: {
     display: 'flex',
     flexDirection: 'column',
@@ -264,13 +260,13 @@ export const useScenarioRunPageStyles = makeStyles({
     border: `1px solid ${tokens.colorNeutralStroke2}`,
     borderRadius: tokens.borderRadiusMedium,
   },
-  conversationSurface: {
+  liveActivity: {
     display: 'flex',
     flexDirection: 'column',
-    minHeight: '28rem',
-    backgroundColor: tokens.colorNeutralBackground1,
-    border: `1px solid ${tokens.colorNeutralStroke2}`,
-    borderRadius: tokens.borderRadiusLarge,
+    gap: tokens.spacingVerticalM,
+    maxHeight: '60vh',
+    maxWidth: `min(48rem, calc(100vw - ${tokens.spacingHorizontalXXL} * 2))`,
+    overflowY: 'auto',
   },
   displayGroup: {
     border: `1px solid ${tokens.colorNeutralStroke2}`,
@@ -394,8 +390,17 @@ export const useScenarioRunPageStyles = makeStyles({
     minHeight: 0,
     maxHeight: 'calc(90vh - 48px)',
   },
+  attackDetailDialogTitle: {
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'flex-start',
+    gap: tokens.spacingVerticalXXS,
+    minWidth: 0,
+    overflowWrap: 'anywhere',
+  },
   attackDetailDialogContent: {
     minHeight: 0,
+    paddingTop: tokens.spacingVerticalL,
     overflowY: 'auto',
   },
   detailList: {
diff --git a/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx b/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx
index b819cce051..84e1e5d5b8 100644
--- a/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunPage.test.tsx
@@ -7,9 +7,10 @@ import { MemoryRouter, Route, Routes, useLocation, useNavigate } from 'react-rou
 
 import { useScenarioQueue } from '@/hooks/useScenarioQueue'
 import { useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
-import { scenariosApi } from '@/services/api'
+import { attacksApi, scenariosApi } from '@/services/api'
 import type {
-  ScenarioHierarchyNode, ScenarioHierarchyProjection, ScenarioProgressResult, ScenarioProgressSummary, ScenarioRunPlan, ScenarioRunSummary,
+  AttackFindingItem, ScenarioActiveConversation, ScenarioHierarchyNode, ScenarioHierarchyProjection,
+  ScenarioProgressResult, ScenarioProgressSummary, ScenarioRunPlan, ScenarioRunSummary,
 } from '@/types'
 import { scenarioRunAttackRoutePath, scenarioRunRoutePath } from '@/utils/routeParams'
 import { INITIAL_SCENARIO_RUN_PROGRESS_STATE, type ScenarioRunProgressState } from '@/utils/scenarioRunProgress'
@@ -18,7 +19,7 @@ import ScenarioRunPage from './ScenarioRunPage'
 
 jest.mock('@/hooks/useScenarioRunProgress', () => ({ useScenarioRunProgress: jest.fn() }))
 jest.mock('@/hooks/useScenarioQueue', () => ({ useScenarioQueue: jest.fn() }))
-jest.mock('@/services/api', () => ({ scenariosApi: {
+jest.mock('@/services/api', () => ({ attacksApi: { getAttackFindings: jest.fn() }, scenariosApi: {
   cancelRun: jest.fn(), resumeRun: jest.fn(), getLaunchConfiguration: jest.fn(), startRun: jest.fn(), getQueue: jest.fn(),
   getRunHierarchy: jest.fn(() => new Promise(() => {})), getRunHierarchyNode: jest.fn(),
   getPairedOutcomes: jest.fn(), getPairedOutcomeDetails: jest.fn(),
@@ -51,6 +52,10 @@ const ATTEMPT: ScenarioProgressResult = {
   seed_identifiers: SEEDS,
   score: { scorer_name: 'objective', score_type: 'true_false', status: 'complete', score_value: 'true', score_rationale: 'The objective was met.' },
 }
+const SINGLE_PLAN: ScenarioRunPlan = {
+  ...PLAN, atomic_groups: [{ ...PLAN.atomic_groups[0], seed_group_ids: ['seed-1'], is_compound: false }],
+  seed_groups: [PLAN.seed_groups[0]],
+}
 const COUNTS = { completed: 2, planned: 2, succeeded: 1, success_percentage: 50, errors: 0, retries: 1 }
 const SUMMARY: ScenarioProgressSummary = {
   overall: COUNTS, objective_scorer: SCORER,
@@ -126,6 +131,7 @@ beforeEach(() => {
     error: null,
     retry: queueRetry,
   })
+  jest.mocked(attacksApi.getAttackFindings).mockImplementation(async (id: string) => ({ attack_result_id: id, items: [] }))
   state = makeState()
   jest.mocked(useScenarioRunProgress).mockImplementation(() => ({ state, retry, applyRunSummary }))
 })
@@ -186,8 +192,10 @@ describe('ScenarioRunPage', () => {
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
     expect(screen.getByRole('heading', { name: 'test.scenario' })).toBeInTheDocument()
     expect(screen.getByText(RUN.description)).toBeInTheDocument()
-    expect(screen.getByRole('link', { name: 'Review operation' })).toHaveAttribute('href', `/operations/${RUN.operation_id}`)
-    expect(screen.getByText('review-model')).toBeInTheDocument()
+    expect(screen.getByRole('link', { name: 'Operation: Review operation' })).toHaveAttribute('href', `/operations/${RUN.operation_id}`)
+    expect(screen.queryByLabelText('Scan summary')).not.toBeInTheDocument()
+    expect(screen.queryByText('review-model')).not.toBeInTheDocument()
+    expect(screen.queryByText('Errors / retries')).not.toBeInTheDocument()
     expect(screen.getAllByRole('heading', { level: 2 }).map((heading) => heading.textContent)).toEqual([
       'Atomic attack groups', 'Datasets & objectives', 'Scenario configuration',
     ])
@@ -195,8 +203,14 @@ describe('ScenarioRunPage', () => {
     expect(scenariosApi.getQueue).not.toHaveBeenCalled()
     expect(screen.getByRole('link', { name: 'View queue' })).toHaveAttribute('href', '/scanner/queue')
     await expand(user)
-    expect(screen.getByRole('columnheader', { name: 'Duration' })).toBeInTheDocument()
-    expect(screen.queryByRole('columnheader', { name: 'Timestamp' })).not.toBeInTheDocument()
+    const results = within(screen.getByRole('table', { name: 'Direct attack results' }))
+    expect(results.getAllByRole('columnheader').map((header: HTMLElement) => header.textContent)).toEqual([
+      'Objective', 'Outcome', 'Duration', 'Retries / error', 'Conversation',
+    ])
+    expect(results.getAllByRole('cell', { name: 'Duration' })).toHaveLength(2)
+    expect(results.queryByRole('cell', { name: 'Timestamp' })).not.toBeInTheDocument()
+    expect(results.queryByText('Target-facing')).not.toBeInTheDocument()
+    expect(results.getAllByText('direct')).toHaveLength(2)
     expect(screen.getByText('True', { exact: true })).toBeInTheDocument()
     expect(screen.getByText('False', { exact: true })).toBeInTheDocument()
   })
@@ -217,35 +231,131 @@ describe('ScenarioRunPage', () => {
     expect(screen.queryByRole('button', { name: 'Cancel', exact: true })).not.toBeInTheDocument()
   })
 
-  it('opens identity-only details by keyboard and restores focus on close', async () => {
+  it('opens attack details from a row by keyboard and restores focus on close', async () => {
     const user = userEvent.setup()
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
     await expand(user)
-    const details = screen.getAllByRole('button', { name: /^Open details for PromptSendingAttack:/ })[0]
-    details.focus()
+    const row = screen.getByRole('row', { name: 'View attack details for PromptSendingAttack: First objective' })
+    row.focus()
     await user.keyboard('{Enter}')
     const dialog = within(await screen.findByRole('dialog'))
-    expect(dialog.queryByText(/total duration/i)).not.toBeInTheDocument()
-    expect(dialog.getByRole('link', { name: 'Open conversation' })).toBeInTheDocument()
+    expect(dialog.getByRole('link', { name: 'Operation: Review operation' })).toHaveAttribute('href', `/operations/${RUN.operation_id}`)
+    expect(dialog.getByText('Outcome:', { exact: true })).toBeInTheDocument()
     expect(dialog.getAllByText('The objective was met.', { exact: true })).toHaveLength(1)
-    expect(dialog.getAllByText('5s', { exact: true })).toHaveLength(1)
-    expect(dialog.queryByText(/5s · 1 retries/)).not.toBeInTheDocument()
-    expect(dialog.getAllByText('Execution time', { exact: true })).toHaveLength(1)
-    expect(dialog.getAllByText('Retries', { exact: true })).toHaveLength(1)
-    expect(dialog.getAllByText('Timestamp', { exact: true })).toHaveLength(1)
-    expect(dialog.queryByText('Attack Success', { exact: true })).not.toBeInTheDocument()
-    await user.click(dialog.getByRole('button', { name: 'Identity for direct' }))
-    expect(JSON.parse(dialog.getByRole('region', { name: 'Identity for direct' }).textContent ?? '')).toEqual(TECHNIQUE)
-    await user.click(dialog.getByRole('button', { name: 'Identity for TrueFalseCompositeScorer' }))
-    const scorer = JSON.parse(dialog.getByRole('region', { name: 'Identity for TrueFalseCompositeScorer' }).textContent ?? '')
+    expect(dialog.getByLabelText('Attack timing')).toHaveTextContent(/^5s · 1 retry · /)
+    expect(dialog.queryByText('Execution time', { exact: true })).not.toBeInTheDocument()
+    expect(dialog.queryByText('Attack technique', { exact: true })).not.toBeInTheDocument()
+    expect(dialog.queryByRole('list', { name: 'Attached findings' })).not.toBeInTheDocument()
+    expect(dialog.queryByRole('button', { name: 'Close', exact: true })).not.toBeInTheDocument()
+    const components = within(dialog.getByLabelText('Attack components'))
+    await user.click(components.getByRole('button', { name: 'Identity for direct' }))
+    expect(JSON.parse(components.getByRole('region', { name: 'Identity for direct' }).textContent ?? '')).toEqual(TECHNIQUE)
+    await user.click(components.getByRole('button', { name: 'Identity for TrueFalseCompositeScorer' }))
+    const scorer = JSON.parse(components.getByRole('region', { name: 'Identity for TrueFalseCompositeScorer' }).textContent ?? '')
     expect(scorer.children.sub_scorers[0].parameters.score_aggregator).toBe('OR')
-    await user.click(dialog.getByRole('button', { name: 'Identity for review' }))
-    expect(JSON.parse(dialog.getByRole('region', { name: 'Identity for review' }).textContent ?? '')).toEqual(SEEDS)
-    expect(dialog.queryByText('Configuration', { exact: true })).not.toBeInTheDocument()
+    await user.click(components.getByRole('button', { name: 'Identity for review' }))
+    expect(JSON.parse(components.getByRole('region', { name: 'Identity for review' }).textContent ?? '')).toEqual(SEEDS)
+    expect(dialog.getByRole('link', { name: 'Open conversation' })).toHaveAttribute(
+      'href', `/attack/chat/attempt-1/conversations/conversation-1?scenarioResultId=${RUN_ID}`,
+    )
+    expect(dialog.getByRole('button', { name: 'Attach to findings' })).toBeEnabled()
     await user.click(dialog.getByRole('button', { name: 'Close attack details' }))
-    await waitFor(() => expect(details).toHaveFocus())
+    await waitFor(() => expect(row).toHaveFocus())
+  })
+
+  it('opens the shared score view from a result outcome without opening details', async () => {
+    const user = userEvent.setup()
+    render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    await expand(user)
+    await user.click(screen.getByRole('button', { name: 'True: View score for PromptSendingAttack: First objective' }))
+    expect(await screen.findByText('Score details')).toBeInTheDocument()
+    expect(screen.getByText('The objective was met.')).toBeInTheDocument()
+    await user.click(screen.getByText('The objective was met.'))
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
+  })
+
+  it.each([null, 1])('explains unavailable ETA for a plan of %s attacks', (planned: number | null) => {
+    state = makeState({ summary: { ...SUMMARY, overall: { ...COUNTS, completed: 0, planned } } })
+    render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.getByText('Time remaining unavailable')).toBeInTheDocument()
+    expect(screen.queryByText('Estimating time remaining')).not.toBeInTheDocument()
   })
 
+  it('keeps fallback score text outside the row details action', async () => {
+    const user = userEvent.setup()
+    state = makeState({ results: [{ ...ATTEMPT, score: null }] })
+    render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    await expand(user)
+    await user.click(screen.getByRole('button', { name: 'True: View score for PromptSendingAttack: First objective' }))
+    await user.click(await screen.findByText('No score was saved for this result.'))
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
+  })
+
+  it('keeps the single card mounted across an error, active retry and multiple saved retries', async () => {
+    const user = userEvent.setup()
+    const failed = { ...ATTEMPT, outcome: 'error' as const, score: null, error_message: 'Previous failure' }
+    state = makeState({ plan: SINGLE_PLAN, results: [failed] })
+    const view = render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    const card = screen.getByRole('region', { name: 'Attack details' })
+    const retry: ScenarioActiveConversation = {
+      attack_result_id: 'retry', conversation_id: 'retry-main', atomic_attack_name: ATTEMPT.atomic_attack_name,
+      seed_group_id: ATTEMPT.seed_group_id, objective: 'First objective', started_at: RUN.started_at, seed_identifiers: [],
+    }
+    state = { ...state, activeConversations: [retry] }
+    view.rerender(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.getByRole('region', { name: 'Attack details' })).toBe(card)
+    expect(within(card).getByText('In progress', { exact: true })).toBeInTheDocument()
+    expect(within(card).getByRole('link', { name: 'Watch live conversation' })).toHaveAttribute(
+      'href', `/attack/chat/retry/conversations/retry-main?scenarioResultId=${RUN_ID}`,
+    )
+    await user.click(screen.getByRole('button', { name: 'View live attacks (1)' }))
+    expect(screen.getByRole('heading', { name: 'Live attacks' })).toBeInTheDocument()
+    expect(screen.getAllByRole('link', { name: 'Watch live conversation' })).toHaveLength(2)
+    await user.keyboard('{Escape}')
+    state = { ...state, run: { ...RUN, status: 'COMPLETED' }, activeConversations: [],
+      results: [failed, { ...ATTEMPT, attack_result_id: 'retry', conversation_id: 'retry-main', timestamp: '2026-01-02T00:00:00Z' }] }
+    view.rerender(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.getByRole('region', { name: 'Attack details' })).toBe(card)
+    expect(within(card).getByRole('link', { name: 'Open conversation' })).toHaveAttribute(
+      'href', `/attack/chat/retry/conversations/retry-main?scenarioResultId=${RUN_ID}`,
+    )
+  })
+
+  it.each([true, undefined])('keeps unknown or compound plans grouped before any result is saved (%s)', (isCompound) => {
+    state = makeState({ plan: { ...SINGLE_PLAN, atomic_groups: [{ ...SINGLE_PLAN.atomic_groups[0], is_compound: isCompound }] }, results: [] })
+    render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.getByRole('heading', { name: 'Atomic attack groups' })).toBeInTheDocument()
+    expect(screen.queryByRole('region', { name: 'Attack details' })).not.toBeInTheDocument()
+  })
+
+  it('retains live disclosure when no active conversation matches the single-card plan', async () => {
+    const user = userEvent.setup()
+    state = makeState({ plan: SINGLE_PLAN, results: [], activeConversations: [{
+      attack_result_id: 'unrelated', conversation_id: 'other', atomic_attack_name: 'OtherAttack',
+      seed_group_id: 'other-seed', objective: 'Other objective', started_at: RUN.started_at, seed_identifiers: [],
+    }] })
+    render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(within(screen.getByRole('region', { name: 'Attack details' })).getByText('Preparing', { exact: true })).toBeInTheDocument()
+    await user.click(screen.getByRole('button', { name: 'View live attacks (1)' }))
+    expect(screen.getByRole('link', { name: 'Watch live conversation' })).toHaveAttribute(
+      'href', `/attack/chat/unrelated/conversations/other?scenarioResultId=${RUN_ID}`,
+    )
+  })
+
+  it('shows findings linked to the attack only when there are some', async () => {
+    const finding: AttackFindingItem = {
+      id: 'finding-1', operation_id: RUN.operation_id, operation_name: 'Review operation', evidence_id: 'evidence-1',
+      title: 'Protected instructions disclosed', description: 'Review the saved response.', severity: 'important',
+      created_at: RUN.created_at,
+    }
+    jest.mocked(attacksApi.getAttackFindings).mockResolvedValue({ attack_result_id: ATTEMPT.attack_result_id, items: [finding] })
+    render(<Wrapper path={scenarioRunAttackRoutePath(RUN_ID, ATTEMPT.attack_result_id)} />)
+    const dialog = within(screen.getByRole('dialog'))
+    const findings = await dialog.findByRole('list', { name: 'Attached findings' })
+    expect(within(findings).getAllByRole('listitem')).toHaveLength(1)
+    expect(findings).toHaveTextContent(finding.title)
+    expect(attacksApi.getAttackFindings).toHaveBeenCalledWith(ATTEMPT.attack_result_id)
+  })
   it('keeps canonical conversation navigation separate from row details', async () => {
     const user = userEvent.setup()
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
@@ -262,8 +372,8 @@ describe('ScenarioRunPage', () => {
     const dialog = within(await screen.findByRole('dialog'))
     expect(dialog.getByText('First seed prompt')).toBeInTheDocument()
     expect(dialog.getByRole('heading', { name: 'Atomic attacks' })).toBeInTheDocument()
-    expect(dialog.getAllByRole('button', { name: /^Open details for PromptSendingAttack:/ })).toHaveLength(1)
-    await user.click(dialog.getByRole('button', { name: /^Open details for PromptSendingAttack:/ }))
+    expect(dialog.getByText('direct')).toBeInTheDocument()
+    await user.click(dialog.getByRole('row', { name: 'View attack details for PromptSendingAttack: First objective' }))
     expect(await screen.findByRole('button', { name: 'Close attack details' })).toBeInTheDocument()
     await user.click(screen.getByRole('button', { name: 'Close attack details' }))
     await waitFor(() => expect(screen.getByRole('button', { name: 'First objective' })).toHaveFocus())
@@ -293,11 +403,11 @@ describe('ScenarioRunPage', () => {
     await waitFor(() => expect(objective).toHaveFocus())
   })
 
-  it('restores focus to the technique opener when attack details are dismissed with Escape', async () => {
+  it('restores focus to the attack row when attack details are dismissed with Escape', async () => {
     const user = userEvent.setup()
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
     await expand(user)
-    const details = screen.getAllByRole('button', { name: /^Open details for PromptSendingAttack:/ })[0]
+    const details = screen.getByRole('row', { name: 'View attack details for PromptSendingAttack: First objective' })
     await user.click(details)
     await screen.findByRole('dialog')
     await user.keyboard('{Escape}')
@@ -306,7 +416,7 @@ describe('ScenarioRunPage', () => {
 
   it('shows per-group and per-objective success rates without restoring paired outcomes', () => {
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
-    expect(within(screen.getByLabelText('Scan summary')).getByText('50%', { exact: true })).toBeInTheDocument()
+    expect(screen.getByText('50%', { exact: true })).toBeInTheDocument()
     const objectives = within(screen.getByRole('table', { name: 'Datasets and objectives' }))
     expect(objectives.getByRole('row', { name: /First objective/ })).toHaveTextContent('100%')
     expect(objectives.getByRole('row', { name: /Second objective/ })).toHaveTextContent('0%')
@@ -323,9 +433,9 @@ describe('ScenarioRunPage', () => {
     })
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
     expect(screen.getByRole('link', { name: 'Open saved conversation' })).toHaveAttribute(
-      'href', `/scanner/history/${RUN_ID}/conversations/saved`,
+      'href', `/attack/chat/interrupted/conversations/saved?scenarioResultId=${RUN_ID}`,
     )
-    expect(screen.queryByRole('row', { name: /View details for/ })).not.toBeInTheDocument()
+    expect(screen.queryByRole('row', { name: /View attack details for direct/ })).not.toBeInTheDocument()
   })
 
   it('keeps distinct interrupted retry conversations and excludes completed transcripts', () => {
@@ -345,7 +455,7 @@ describe('ScenarioRunPage', () => {
     const savedLinks = screen.getAllByRole('link', { name: 'Open saved conversation' })
     expect(savedLinks).toHaveLength(1)
     expect(savedLinks[0]).toHaveAttribute(
-      'href', `/scanner/history/${RUN_ID}/conversations/interrupted-retry`,
+      'href', `/attack/chat/attempt-1/conversations/interrupted-retry?scenarioResultId=${RUN_ID}`,
     )
   })
 
@@ -408,7 +518,7 @@ describe('ScenarioRunPage', () => {
     const user = userEvent.setup()
     jest.mocked(scenariosApi.getLaunchConfiguration).mockResolvedValue({ scenario_name: 'test.scenario', target_name: 'original' })
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
-    await user.click(screen.getByRole('button', { name: 'Rerun' }))
+    await user.click(screen.getByRole('button', { name: 'Rerun with changes' }))
     expect(scenariosApi.getLaunchConfiguration).toHaveBeenCalledWith(RUN_ID, expect.any(AbortSignal))
     await waitFor(() => expect(screen.getByLabelText('Location')).toHaveTextContent(`/scanner/launch/test.scenario?rerun=${RUN_ID}`))
     expect(scenariosApi.startRun).not.toHaveBeenCalled()
@@ -423,7 +533,7 @@ describe('ScenarioRunPage', () => {
       requestSignal = signal
     }))
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
-    await user.click(screen.getByRole('button', { name: 'Rerun' }))
+    await user.click(screen.getByRole('button', { name: 'Rerun with changes' }))
     expect(requestSignal).toBeDefined()
     await user.click(screen.getByRole('button', { name: 'Leave run' }))
     expect(requestSignal?.aborted).toBe(true)
@@ -445,7 +555,7 @@ describe('ScenarioRunPage', () => {
     })
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
     await expand(user)
-    await user.click(screen.getByRole('button', { name: /^Open details for PromptSendingAttack:/ }))
+    await user.click(screen.getByRole('row', { name: /^View attack details for PromptSendingAttack:/ }))
     const dialog = within(await screen.findByRole('dialog'))
     expect(dialog.getAllByText('TimeoutError: The target timed out.', { exact: true })).toHaveLength(1)
     expect(dialog.queryByRole('button', { name: 'Error details' })).not.toBeInTheDocument()
@@ -455,7 +565,7 @@ describe('ScenarioRunPage', () => {
     const user = userEvent.setup()
     jest.mocked(scenariosApi.getLaunchConfiguration).mockRejectedValue(new Error('Saved configuration is unavailable'))
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
-    await user.click(screen.getByRole('button', { name: 'Rerun' }))
+    await user.click(screen.getByRole('button', { name: 'Rerun with changes' }))
     expect(await screen.findByText('Saved configuration is unavailable')).toBeInTheDocument()
     expect(screen.getByLabelText('Location')).toHaveTextContent(scenarioRunRoutePath(RUN_ID))
     expect(scenariosApi.startRun).not.toHaveBeenCalled()
@@ -470,7 +580,7 @@ describe('ScenarioRunPage', () => {
       requestSignal = signal
     }))
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
-    await user.click(screen.getByRole('button', { name: 'Rerun' }))
+    await user.click(screen.getByRole('button', { name: 'Rerun with changes' }))
     await user.click(screen.getByRole('button', { name: 'Open attempt' }))
     expect(requestSignal?.aborted).toBe(true)
     const resolve = resolveConfiguration
@@ -538,7 +648,7 @@ describe('ScenarioRunPage', () => {
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
     await user.click(screen.getByRole('button', { name: 'Resume' }))
     expect(await screen.findByText('Resume rejected')).toBeInTheDocument()
-    expect(within(screen.getByLabelText('Scan summary')).getByText('50%', { exact: true })).toBeInTheDocument()
+    expect(screen.getByText('50%', { exact: true })).toBeInTheDocument()
     expect(retry).toHaveBeenCalled()
   })
 
@@ -561,9 +671,12 @@ describe('ScenarioRunPage', () => {
     }] })
     render(<Wrapper path={scenarioRunAttackRoutePath(RUN_ID, 'live')} />)
     const dialog = within(screen.getByRole('dialog'))
-    expect(dialog.getByRole('link', { name: 'Watch live conversation' })).toHaveAttribute('href', `/scanner/history/${RUN_ID}/conversations/live-conversation`)
+    expect(dialog.getByRole('link', { name: 'Watch live conversation' })).toHaveAttribute(
+      'href', `/attack/chat/live/conversations/live-conversation?scenarioResultId=${RUN_ID}`,
+    )
     expect(dialog.getByText('In progress')).toBeInTheDocument()
-    expect(within(screen.getByLabelText('Scan summary')).getByText('50%', { exact: true })).toBeInTheDocument()
+    expect(dialog.getByRole('button', { name: 'Attach to findings' })).toBeDisabled()
+    expect(screen.getByText('50%', { exact: true })).toBeInTheDocument()
   })
 
   it('retains explicit stale recovery and previously loaded data', async () => {
@@ -578,10 +691,181 @@ describe('ScenarioRunPage', () => {
   it.each(['loading', 'not-found', 'error'] as const)('renders the %s state with recovery', (loadStatus) => {
     state = makeState({ run: null, summary: null, loadStatus, error: loadStatus === 'loading' ? null : 'Scan unavailable' })
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
-    if (loadStatus === 'loading') expect(screen.getByText('Loading scan...')).toBeInTheDocument()
+    if (loadStatus === 'loading') expect(screen.getByText('Loading scan')).toBeInTheDocument()
     else expect(screen.getByRole('button', { name: 'Retry' })).toBeInTheDocument()
   })
 
+  it('groups an attack with several live conversations into one live entry without listing them as saved', async () => {
+    const user = userEvent.setup()
+    const conversation: ScenarioActiveConversation = {
+      attack_result_id: 'live', conversation_id: 'branch-1', conversation_ids: ['branch-1', 'branch-2'],
+      atomic_attack_name: 'Branching attack', objective: 'First objective', started_at: RUN.started_at, seed_identifiers: [],
+    }
+    state = makeState({ results: [], activeConversations: [conversation], recordedConversations: [conversation, { ...conversation, conversation_id: 'branch-2' }] })
+    render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    await user.click(screen.getByRole('button', { name: 'View live attacks (1)' }))
+    expect(screen.getAllByRole('link', { name: 'Watch live conversation' })).toHaveLength(1)
+    expect(screen.getByText('2 live conversations')).toBeInTheDocument()
+    expect(screen.queryByRole('heading', { name: 'Saved conversations' })).not.toBeInTheDocument()
+  })
+
+  it('keeps live attacks in the progress area instead of inserting a block above the results', async () => {
+    const user = userEvent.setup()
+    state = makeState({ results: [], summary: { ...SUMMARY, overall: { ...COUNTS, completed: 0 } } })
+    const view = render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    const progress = screen.getByRole('region', { name: 'Scan progress' })
+    const results = screen.getByRole('heading', { name: 'Atomic attack groups' })
+    expect(screen.getByRole('button', { name: 'View live attacks (0)' })).toBeDisabled()
+    expect(screen.getByText('Estimating time remaining')).toBeInTheDocument()
+    state = { ...state, summary: { ...SUMMARY, overall: { ...COUNTS, completed: 1 } }, activeConversations: [{
+      attack_result_id: 'live', conversation_id: 'branch', atomic_attack_name: 'PromptSendingAttack',
+      objective: 'First objective', seed_group_id: 'seed-1', started_at: RUN.started_at, seed_identifiers: [],
+    }] }
+    view.rerender(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.getByRole('region', { name: 'Scan progress' })).toBe(progress)
+    expect(screen.getByRole('heading', { name: 'Atomic attack groups' })).toBe(results)
+    await user.click(within(progress).getByRole('button', { name: 'View live attacks (1)' }))
+    expect(screen.getByRole('link', { name: 'Watch live conversation' })).toHaveAttribute(
+      'href', `/attack/chat/live/conversations/branch?scenarioResultId=${RUN_ID}`,
+    )
+    await user.keyboard('{Escape}')
+    expect(screen.getByRole('button', { name: 'View live attacks (1)' })).toHaveFocus()
+  })
+
+  it('keeps the finished progress area mounted but hidden and inert so the results do not move', () => {
+    const view = render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    const progress = screen.getByRole('region', { name: 'Scan progress' })
+    state = makeState({ run: { ...RUN, status: 'COMPLETED', completed_at: '2026-01-01T00:00:10Z' } })
+    view.rerender(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.queryByRole('region', { name: 'Scan progress' })).not.toBeInTheDocument()
+    expect(progress).toBeInTheDocument()
+    const wrapper = progress.closest('[aria-hidden="true"]')
+    expect(wrapper).not.toBeNull()
+    expect(wrapper).toHaveAttribute('inert')
+  })
+
+  it('shows a single completed atomic attack as one framed card without group sections', () => {
+    state = makeState({
+      plan: SINGLE_PLAN,
+      run: { ...RUN, scenario_registry_name: 'technique.execute', status: 'COMPLETED' },
+      summary: { ...SUMMARY, overall: { ...COUNTS, completed: 1, planned: 1 } },
+      results: [ATTEMPT],
+    })
+    render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    const details = within(screen.getByRole('region', { name: 'Attack details' }))
+    expect(screen.queryByRole('heading', { name: 'Atomic attack groups' })).not.toBeInTheDocument()
+    expect(screen.queryByRole('heading', { name: 'Datasets & objectives' })).not.toBeInTheDocument()
+    expect(screen.queryByRole('heading', { name: 'Scenario configuration' })).not.toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'View live attacks (0)' })).not.toBeInTheDocument()
+    const outcome = within(details.getByLabelText('Attack outcome'))
+    expect(outcome.getByText('Objective:')).toBeInTheDocument()
+    expect(outcome.getByText('First objective')).toBeInTheDocument()
+    expect(outcome.getByText('Outcome:')).toBeInTheDocument()
+    expect(details.getByLabelText('Attack components')).toBeInTheDocument()
+    expect(details.getByRole('link', { name: 'Open conversation' })).toBeInTheDocument()
+  })
+
+  it('keeps the single attack details mounted from preparing through running to completed', async () => {
+    const user = userEvent.setup()
+    const live: ScenarioActiveConversation = {
+      attack_result_id: 'attempt-1', conversation_id: 'branch', atomic_attack_name: 'PromptSendingAttack',
+      seed_group_id: 'seed-1', objective: 'First objective', started_at: RUN.started_at, seed_identifiers: [],
+    }
+    const single = { ...SUMMARY, overall: { ...COUNTS, completed: 0, planned: 1 } }
+    state = makeState({ plan: SINGLE_PLAN, summary: single, results: [], activeConversations: [] })
+    const view = render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    const details = screen.getByRole('region', { name: 'Attack details' })
+    const components = screen.getByLabelText('Attack components')
+    expect(screen.getByText('Preparing', { exact: true })).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Watch live conversation' })).toBeDisabled()
+    await user.click(screen.getByRole('button', { name: 'Identity for direct' }))
+
+    state = { ...state, activeConversations: [live] }
+    view.rerender(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.getByRole('region', { name: 'Attack details' })).toBe(details)
+    expect(screen.getByLabelText('Attack components')).toBe(components)
+    expect(screen.getByRole('button', { name: 'Identity for direct' })).toHaveAttribute('aria-expanded', 'true')
+    expect(screen.getByText('In progress', { exact: true })).toBeInTheDocument()
+    expect(screen.getByRole('link', { name: 'Watch live conversation' })).toHaveAttribute(
+      'href', `/attack/chat/attempt-1/conversations/branch?scenarioResultId=${RUN_ID}`,
+    )
+
+    state = makeState({
+      plan: SINGLE_PLAN,
+      run: { ...RUN, status: 'COMPLETED' }, summary: { ...single, overall: { ...single.overall, completed: 1 } },
+      results: [ATTEMPT], activeConversations: [],
+    })
+    view.rerender(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.getByRole('region', { name: 'Attack details' })).toBe(details)
+    expect(screen.getByText('True', { exact: true })).toBeInTheDocument()
+    expect(screen.getByRole('link', { name: 'Open conversation' })).toBeInTheDocument()
+  })
+
+  it('shows a completed single attack error once while keeping scan-level notices', () => {
+    state = makeState({
+      plan: SINGLE_PLAN,
+      run: { ...RUN, status: 'FAILED', error: 'The target timed out.', error_type: 'TimeoutError' },
+      summary: { ...SUMMARY, overall: { ...COUNTS, completed: 1, planned: 1, errors: 1 } },
+      results: [{ ...ATTEMPT, outcome: 'error', score: null, error_type: 'TimeoutError', error_message: 'The target timed out.' }],
+      planComplete: false,
+    })
+    render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.getAllByText('TimeoutError: The target timed out.', { exact: true })).toHaveLength(1)
+    expect(screen.queryByText('Scan failed. Resume to continue remaining attacks.')).not.toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Error details' })).not.toBeInTheDocument()
+    expect(screen.getByLabelText('Scan notices')).toHaveTextContent('The saved execution plan is incomplete')
+    expect(screen.getByRole('button', { name: 'Resume', exact: true })).toBeInTheDocument()
+  })
+
+  it('keeps a distinct run failure when the single attack has its own error', async () => {
+    const user = userEvent.setup()
+    state = makeState({
+      plan: SINGLE_PLAN,
+      run: { ...RUN, status: 'FAILED', error: 'The worker stopped unexpectedly.', error_type: 'WorkerError' },
+      summary: { ...SUMMARY, overall: { ...COUNTS, completed: 1, planned: 1, errors: 1 } },
+      results: [{ ...ATTEMPT, outcome: 'error', score: null, error_type: 'TimeoutError', error_message: 'The target timed out.' }],
+    })
+    render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.getByText('TimeoutError: The target timed out.', { exact: true })).toBeInTheDocument()
+    expect(screen.getByText('Scan failed. Resume to continue remaining attacks.')).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'View attack' })).not.toBeInTheDocument()
+    await user.click(screen.getByRole('button', { name: 'Error details' }))
+    expect(screen.getByText('WorkerError: The worker stopped unexpectedly.', { exact: true })).toBeInTheDocument()
+  })
+
+  it('does not present a finished single attack without details as still preparing', () => {
+    state = makeState({
+      plan: SINGLE_PLAN,
+      run: { ...RUN, status: 'COMPLETED' },
+      summary: { ...SUMMARY, overall: { ...COUNTS, completed: 1, planned: 1 } },
+      results: [],
+    })
+    render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    expect(screen.getByText('Attack details are not available.')).toBeInTheDocument()
+    expect(screen.queryByText('Preparing', { exact: true })).not.toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Watch live conversation' })).not.toBeInTheDocument()
+  })
+  it('reloads saved results once when the run finishes so they replace the running snapshot', async () => {
+    const projection = {
+      scenario_result_id: RUN_ID, scenario_name: 'TestScenario', scenario_version: 1, status: 'IN_PROGRESS' as const, groups: [],
+      overall_counts: COUNTS,
+      diagnostics: {
+        failed_attacks: [], failed_attacks_count: 0, failed_attacks_truncated: false,
+        attack_retries: [], attack_retries_count: 0, attack_retries_truncated: false,
+        total_retries: 0, rootless_result_ids: [], rootless_results_count: 0, rootless_results_truncated: false,
+      },
+      has_more: false, truncated: false,
+    }
+    jest.mocked(scenariosApi.getRunHierarchy).mockResolvedValueOnce(projection)
+      .mockResolvedValueOnce({ ...projection, status: 'COMPLETED' })
+    const view = render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    await waitFor(() => expect(scenariosApi.getRunHierarchy).toHaveBeenCalledTimes(1))
+    state = makeState({ run: { ...RUN, status: 'COMPLETED', completed_at: '2026-01-01T00:00:10Z' } })
+    view.rerender(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
+    await waitFor(() => expect(scenariosApi.getRunHierarchy).toHaveBeenCalledTimes(2))
+    await act(async () => { await Promise.resolve() })
+    expect(scenariosApi.getRunHierarchy).toHaveBeenCalledTimes(2)
+  })
   it('retains history filters and transient suite return navigation', () => {
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} navigationState={{ suiteExecutionId: 'suite', suiteName: 'Review suite' }} />)
     expect(screen.getByRole('link', { name: 'Back to Review suite' })).toHaveAttribute('href', '/scanner/history/suites/executions/suite')
@@ -602,7 +886,7 @@ describe('ScenarioRunPage', () => {
     })
     render(<Wrapper path={scenarioRunRoutePath(RUN_ID)} />)
     expect(screen.getByText('Showing the latest 100 of 101 executions in this group.')).toBeInTheDocument()
-    expect(screen.getByRole('button', { name: /^Open details for SecondAttack/ })).toBeInTheDocument()
+    expect(screen.getByRole('row', { name: /^View attack details for SecondAttack/ })).toBeInTheDocument()
   })
 
   describe('flat-row fallback while result relationships load or fail', () => {
@@ -617,8 +901,8 @@ describe('ScenarioRunPage', () => {
     ]
     const twoMemberSummary = { ...SUMMARY, techniques: [{ ...SUMMARY.techniques[0], atomic_group_ids: ['group', 'group-b'] }] }
     const shownAttacks = (): (string | undefined)[] => within(screen.getByRole('table', { name: 'Direct attack results' }))
-      .getAllByRole('button', { name: /^Open details for / })
-      .map((button) => button.getAttribute('aria-label')?.match(/Attack \d+/)?.[0])
+      .getAllByRole('row', { name: /^View attack details for / })
+      .map((row) => row.getAttribute('aria-label')?.match(/Attack \d+/)?.[0])
     const expectLatestHundred = (): void => {
       expect(screen.getByText('Showing the latest 100 of 101 executions in this group.')).toBeInTheDocument()
       expect(shownAttacks()).toHaveLength(100)
diff --git a/frontend/src/components/Scenarios/ScenarioRunPage.tsx b/frontend/src/components/Scenarios/ScenarioRunPage.tsx
index 7ace137a32..5be8b368bc 100644
--- a/frontend/src/components/Scenarios/ScenarioRunPage.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunPage.tsx
@@ -1,55 +1,35 @@
 import { useEffect, useMemo, useRef, useState } from 'react'
 
 import {
-  Accordion, AccordionHeader, AccordionItem, AccordionPanel, Badge, Button,
-  Dialog, DialogActions, DialogBody, DialogContent, DialogSurface, DialogTitle,
-  MessageBar, MessageBarBody, ProgressBar, Spinner, Table, TableBody, TableCell,
-  TableHeader, TableHeaderCell, TableRow, Text,
+  Accordion, AccordionHeader, AccordionItem, AccordionPanel, Button, MessageBar, MessageBarBody, Text,
 } from '@fluentui/react-components'
-import { ArrowLeftRegular, ArrowClockwiseRegular, ChevronDownRegular, ChevronRightRegular, DismissRegular, PlayRegular, StopRegular } from '@fluentui/react-icons'
-import { Link, useLocation, useNavigate, useParams } from 'react-router'
+import { ArrowLeftRegular } from '@fluentui/react-icons'
+import { Link, useLocation, useParams } from 'react-router'
 
-import AttackAttemptDetails from '@/components/AttackResults/AttackAttemptDetails'
-import { formatProgressSuccess, objectivePreview } from '@/components/AttackResults/attackAttemptFormatting'
-import RegistryIdentityRow from '@/components/Registry/RegistryIdentityRow'
-import { suiteExecutionRoutePath } from '@/components/ScenarioSuites/suiteRoutes'
-import { useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
-import { useScenarioResultHierarchy } from '@/hooks/useScenarioResultHierarchy'
-import { useScenarioRunResume } from '@/hooks/useScenarioRunResume'
 import { useScenarioQueue } from '@/hooks/useScenarioQueue'
-import { scenariosApi } from '@/services/api'
-import { toApiError } from '@/services/errors'
-import type {
-  ScenarioActiveConversation,
-  ScenarioComponentIdentity,
-  ScenarioHierarchyNode,
-  ScenarioProgressResult,
-  ScenarioRunPlanSeedGroup,
-  ScenarioRunState,
-} from '@/types'
-import {
-  attackConversationRoutePath,
-  routerPathParamValue,
-  scenarioConversationRoutePath,
-  scenarioRerunRoutePath,
-  scenarioRunAttackRoutePath,
-  scenarioRunRoutePath,
-} from '@/utils/routeParams'
+import { useScenarioResultHierarchy } from '@/hooks/useScenarioResultHierarchy'
+import { useScenarioRunAttackDetails } from '@/hooks/useScenarioRunAttackDetails'
+import { useScenarioRunControls } from '@/hooks/useScenarioRunControls'
+import { useScenarioRunProgress } from '@/hooks/useScenarioRunProgress'
+import type { ScenarioProgressResult, ScenarioRunPlanSeedGroup } from '@/types'
+import { routerPathParamValue } from '@/utils/routeParams'
 import { isTerminalRunState } from '@/utils/scenarioRunProgress'
 
-import AttackExecutionTable from './AttackExecutionTable'
+import AtomicAttackGroupsSection from './AtomicAttackGroupsSection'
+import AttackActivity from './AttackActivity'
+import AttackDetailsDialog from './AttackDetailsDialog'
 import PairedOutcomes from './PairedOutcomes'
-import { ObjectiveDetailsDialog } from './ScenarioRunDialogs'
+import ScenarioAttackDetails, { type ScenarioRunDetailsContext } from './ScenarioAttackDetails'
+import ScenarioRunConfigurationSection from './ScenarioRunConfigurationSection'
+import { CancelScanDialog, ObjectiveDetailsDialog } from './ScenarioRunDialogs'
+import ScenarioRunHeader from './ScenarioRunHeader'
+import ScenarioRunNotices from './ScenarioRunNotices'
+import ScenarioRunObjectivesSection from './ScenarioRunObjectivesSection'
 import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
-import ScenarioRunTiming from './ScenarioRunTiming'
-import ScenarioResultHierarchy from './ScenarioResultHierarchy'
-import { hierarchyDisplayGroups } from './scenarioHierarchy'
-
-const MAX_VISIBLE_ATTEMPTS_PER_GROUP = 100
-const AUTO_EXPAND_GROUP_LIMIT = 20
-const STATE_COLORS: Record<ScenarioRunState, 'informative' | 'brand' | 'success' | 'danger' | 'warning'> = {
-  CREATED: 'informative', QUEUED: 'informative', IN_PROGRESS: 'brand', COMPLETED: 'success', FAILED: 'danger', CANCELLED: 'warning',
-}
+import ScenarioRunProgress from './ScenarioRunProgress'
+import ScenarioRunSavedConversations from './ScenarioRunSavedConversations'
+import { interruptedConversations, liveAttacks, singleAtomicGroupId, singleAttackAttempt } from './scenarioRunLayout'
+import { scenarioRunBackLink, type ScenarioRunNavigationState } from './scenarioRunNavigation'
 
 export default function ScenarioRunPage() {
   const { scenarioResultId, attackResultId } = useParams<{ scenarioResultId: string; attackResultId?: string }>()
@@ -62,72 +42,41 @@ interface ScenarioRunContentProps {
   readonly attackResultId: string | null
 }
 
-function seedDatasetNames(identities: ScenarioComponentIdentity[]): string {
-  return [...new Set(identities.flatMap((identity: ScenarioComponentIdentity) =>
-    typeof identity.parameters.dataset_name === 'string' ? [identity.parameters.dataset_name] : []))].join(', ')
-}
-
 function ScenarioRunContent({ scenarioResultId, attackResultId }: ScenarioRunContentProps) {
   const styles = useScenarioRunPageStyles()
-  const navigate = useNavigate()
   const location = useLocation()
-  const navigationState = location.state as {
-    fromScenarioHistory?: boolean
-    scenarioHistorySearch?: string
-    scenarioName?: string
-    suiteExecutionId?: string
-    suiteName?: string
-  } | null
-  const backPath = navigationState?.suiteExecutionId
-    ? suiteExecutionRoutePath(navigationState.suiteExecutionId)
-    : navigationState?.fromScenarioHistory || navigationState?.scenarioHistorySearch
-      ? `/scanner/history${navigationState.scenarioHistorySearch ?? ''}`
-      : navigationState?.scenarioName
-        ? `/scanner/launch/${encodeURIComponent(navigationState.scenarioName)}`
-        : '/scanner/launch'
-  const backLabel = navigationState?.suiteExecutionId
-    ? `Back to ${navigationState.suiteName ?? 'suite execution'}`
-    : navigationState?.fromScenarioHistory || navigationState?.scenarioHistorySearch
-      ? 'Back to scans'
-      : navigationState?.scenarioName ? 'Back to scenario' : 'Back to scanners'
+  const backLink = scenarioRunBackLink(location.state as ScenarioRunNavigationState | null)
   const { state, retry, applyRunSummary } = useScenarioRunProgress(scenarioResultId)
   const hierarchy = useScenarioResultHierarchy(scenarioResultId, state.run !== null && state.summary !== null)
+  const { roots: { status: hierarchyStatus, runStatus: hierarchyRunStatus }, reloadRoots } = hierarchy
+  const runStatus = state.run?.status
+  // Saved results load once; reload them when the run finishes so its final results replace the running snapshot.
+  useEffect(() => {
+    if (runStatus && isTerminalRunState(runStatus) && hierarchyStatus === 'ready'
+      && hierarchyRunStatus !== null && runStatus !== hierarchyRunStatus) reloadRoots()
+  }, [runStatus, hierarchyStatus, hierarchyRunStatus, reloadRoots])
   const queue = useScenarioQueue()
-  const [identityExpanded, setIdentityExpanded] = useState(false)
+  const controls = useScenarioRunControls({
+    scenarioResultId, applyRunSummary, retry, refreshQueue: queue.retry, runError: state.run?.error,
+  })
+  const headerRef = useRef<HTMLElement | null>(null)
+  const groupsToggleRef = useRef<HTMLButtonElement | null>(null)
+  const objectiveTrigger = useRef<HTMLElement | null>(null)
   const [pairedExpanded, setPairedExpanded] = useState(false)
   const [objective, setObjective] = useState<ScenarioRunPlanSeedGroup | null>(null)
-  const [cancelOpen, setCancelOpen] = useState(false)
-  const [cancelling, setCancelling] = useState(false)
-  const [cancelError, setCancelError] = useState<string | null>(null)
-  const [rerunPending, setRerunPending] = useState(false)
-  const [rerunError, setRerunError] = useState<string | null>(null)
-  const rerunRequest = useRef<AbortController | null>(null)
-  const detailsTrigger = useRef<HTMLElement | null>(null)
-  const objectiveTrigger = useRef<HTMLElement | null>(null)
-  const overviewTarget = useRef<HTMLElement | null>(null)
-  const active = Boolean(state.run && !isTerminalRunState(state.run.status))
-  const resume = useScenarioRunResume({
-    onResumed: applyRunSummary,
-    onRefresh: (succeeded: boolean): void => {
-      queue.retry()
-      if (!succeeded) retry()
-    },
+  const attackDetails = useScenarioRunAttackDetails({
+    scenarioResultId,
+    attackResultId,
+    results: state.results,
+    activeConversations: state.activeConversations,
+    fallbackFocus: () => groupsToggleRef.current ?? headerRef.current,
   })
-  const [atomicGroupsExpandedChoice, setAtomicGroupsExpandedChoice] = useState<boolean | null>(null)
-  const [expandedGroupChoices, setExpandedGroupChoices] = useState<Map<string, boolean>>(new Map())
-  const detailsTriggerRef = useRef<HTMLElement | null>(null)
-  const atomicGroupsToggleRef = useRef<HTMLButtonElement | null>(null)
-  const [hierarchySelection, setHierarchySelection] = useState<ScenarioHierarchyNode | null>(null)
-  useEffect(() => () => {
-    rerunRequest.current?.abort()
-    rerunRequest.current = null
-  }, [location.pathname])
   const seedObjectives = useMemo(
     () => new Map(state.plan?.seed_groups.map((seed) => [seed.id, seed.objective]) ?? []),
     [state.plan],
   )
-  const planSeeds = useMemo(
-    () => new Map(state.plan?.seed_groups.map((seed) => [seed.id, seed]) ?? []),
+  const techniqueNames = useMemo(
+    () => new Map(state.plan?.atomic_groups.map((group) => [group.id, group.technique_name ?? group.atomic_attack_name]) ?? []),
     [state.plan],
   )
   const attemptsBySeed = useMemo(() => {
@@ -139,78 +88,8 @@ function ScenarioRunContent({ scenarioResultId, attackResultId }: ScenarioRunCon
     }
     return groups
   }, [state.results])
-  const plannedAtomicGroups = useMemo(
-    () => new Map(state.plan?.atomic_groups.map((group) => [group.id, group]) ?? []),
-    [state.plan],
-  )
-  const progressAtomicGroups = useMemo(
-    () => new Map(state.summary?.atomic_groups.map((group) => [group.id, group]) ?? []),
-    [state.summary],
-  )
-  // A hierarchy node can be opened before the paged progress feed has delivered it.
-  const selectedAttempt = useMemo<ScenarioProgressResult | ScenarioHierarchyNode | ScenarioActiveConversation | null>(
-    () =>
-      state.results.find((attempt) => attempt.attack_result_id === attackResultId) ??
-      state.activeConversations.find((conversation) => conversation.attack_result_id === attackResultId) ??
-      (hierarchySelection?.attack_result_id === attackResultId ? hierarchySelection : null),
-    [attackResultId, state.results, state.activeConversations, hierarchySelection],
-  )
-  const selectedAtomicGroupId = selectedAttempt && 'atomic_group_id' in selectedAttempt
-    ? selectedAttempt.atomic_group_id
-    : null
-  const selectedAttemptGroup = selectedAtomicGroupId
-    ? plannedAtomicGroups.get(selectedAtomicGroupId)
-    : undefined
-  // Attempts are grouped by atomic group id, then truncated per group, so expanding an
-  // older group still shows its own executions rather than an empty table.
-  const attemptsByGroupId = useMemo(() => {
-    const groupedAttempts = new Map<string, ScenarioProgressResult[]>()
-    for (let index = state.results.length - 1; index >= 0; index -= 1) {
-      const attempt = state.results[index]
-      if (!attempt) continue
-      const existing = groupedAttempts.get(attempt.atomic_group_id)
-      if (existing) {
-        existing.push(attempt)
-      } else {
-        groupedAttempts.set(attempt.atomic_group_id, [attempt])
-      }
-    }
-    return groupedAttempts
-  }, [state.results])
-  const datasetsBySeed = useMemo(() => {
-    const identities = new Map<string, ScenarioComponentIdentity[]>()
-    for (const attempt of [...state.results, ...state.activeConversations]) {
-      if (!attempt.seed_group_id) continue
-      const seeds = identities.get(attempt.seed_group_id) ?? []
-      seeds.push(...(attempt.seed_identifiers ?? []))
-      identities.set(attempt.seed_group_id, seeds)
-    }
-    return new Map([...identities].map(([id, seeds]) => [id, seedDatasetNames(seeds)]))
-  }, [state.results, state.activeConversations])
-  const savedConversations = useMemo(() => {
-    const completedConversationIds = new Set(state.results.flatMap((attempt) => [
-      attempt.conversation_id,
-      ...(attempt.related_conversation_ids ?? []),
-    ]))
-    const recorded = new Map<string, ScenarioActiveConversation>()
-    for (const conversation of state.recordedConversations) {
-      if (!completedConversationIds.has(conversation.conversation_id)) {
-        recorded.set(`${conversation.attack_result_id}:${conversation.conversation_id}`, conversation)
-      }
-    }
-    return [...recorded.values()]
-  }, [state.results, state.recordedConversations])
-  const selectedActive = state.activeConversations.find((conversation) => conversation.attack_result_id === attackResultId)
-  const runPath = scenarioRunRoutePath(scenarioResultId)
-
-  const closeAttemptDetails = (): void => {
-    navigate(runPath, { replace: true, state: location.state })
-    requestAnimationFrame(() => {
-      const trigger = detailsTriggerRef.current ?? detailsTrigger.current
-      const focusTarget = trigger?.isConnected ? trigger : atomicGroupsToggleRef.current ?? overviewTarget.current
-      focusTarget?.focus()
-    })
-  }
+  const runningAttacks = useMemo(() => liveAttacks(state.activeConversations), [state.activeConversations])
+  const savedConversations = useMemo(() => interruptedConversations(state), [state])
 
   const closeObjective = (): void => {
     setObjective(null)
@@ -220,70 +99,12 @@ function ScenarioRunContent({ scenarioResultId, attackResultId }: ScenarioRunCon
     })
   }
 
-  const openAttemptDetails = (
-    attempt: ScenarioProgressResult | ScenarioHierarchyNode,
-    trigger: HTMLElement,
-  ): void => {
-    detailsTriggerRef.current = trigger
-    detailsTrigger.current = trigger
-    setHierarchySelection('result_role' in attempt ? attempt : null)
-    navigate(scenarioRunAttackRoutePath(scenarioResultId, attempt.attack_result_id), { state: location.state })
-  }
-
-  const toggleDisplayGroup = (groupId: string, defaultExpanded: boolean): void => {
-    setExpandedGroupChoices((current) => new Map(current).set(
-      groupId,
-      !(current.get(groupId) ?? defaultExpanded),
-    ))
-  }
-
-  function openDetails(attempt: ScenarioProgressResult, trigger: HTMLElement): void {
-    const focusTarget = objective ? objectiveTrigger.current : trigger
-    detailsTriggerRef.current = focusTarget
-    detailsTrigger.current = focusTarget
-    setObjective(null)
-    setHierarchySelection(null)
-    navigate(scenarioRunAttackRoutePath(scenarioResultId, attempt.attack_result_id), { state: location.state })
-  }
-
-  async function rerun(): Promise<void> {
-    rerunRequest.current?.abort()
-    const controller = new AbortController()
-    rerunRequest.current = controller
-    setRerunPending(true)
-    setRerunError(null)
-    try {
-      const request = await scenariosApi.getLaunchConfiguration(scenarioResultId, controller.signal)
-      if (rerunRequest.current !== controller || controller.signal.aborted) return
-      navigate(scenarioRerunRoutePath(request.scenario_name, scenarioResultId))
-    } catch (error: unknown) {
-      if (rerunRequest.current !== controller || controller.signal.aborted) return
-      setRerunError(toApiError(error).detail)
-    } finally {
-      if (rerunRequest.current === controller) {
-        rerunRequest.current = null
-        setRerunPending(false)
-      }
-    }
-  }
-
-  async function cancel(): Promise<void> {
-    setCancelling(true)
-    setCancelError(null)
-    try {
-      applyRunSummary(await scenariosApi.cancelRun(scenarioResultId))
-      setCancelOpen(false)
-    } catch (error: unknown) {
-      setCancelError(toApiError(error).detail)
-    } finally {
-      setCancelling(false)
-    }
-  }
+  const backLinkElement = <Link to={backLink.path} className={styles.backLink}><ArrowLeftRegular /> {backLink.label}</Link>
 
   if (!state.run || !state.summary) return (
     <main className={styles.root} data-testid="scenario-run-page"><div className={styles.content}>
-      <Link to={backPath} className={styles.backLink}><ArrowLeftRegular /> {backLabel}</Link>
-      {state.loadStatus === 'loading' ? <Spinner label="Loading scan..." /> : (
+      {backLinkElement}
+      {state.loadStatus === 'loading' ? <AttackActivity loading /> : (
         <MessageBar intent="error"><MessageBarBody>{state.error ?? 'Scan not found.'} <Button onClick={retry}>Retry</Button></MessageBarBody></MessageBar>
       )}
     </div></main>
@@ -291,246 +112,71 @@ function ScenarioRunContent({ scenarioResultId, attackResultId }: ScenarioRunCon
 
   const run = state.run
   const summary = state.summary
-  const overall = summary.overall
-  const outcomes = overall.outcomes
-  const groups = summary.display_groups ?? summary.techniques
-  const firstError = state.results.find((attempt) => attempt.outcome === 'error')
-  const controlError = rerunError ?? resume.error
-    ?? (resume.executionError !== run.error ? resume.executionError : null)
-  const notices: string[] = []
-  if (state.overloadSummaries.length > 0) notices.push('Service overload detected.')
-  const unattributedAttempts = summary.unattributed_attempts ?? 0
-  const unmatched = unattributedAttempts
-  if (unmatched > 0) notices.push(`${unmatched} execution${unmatched === 1 ? '' : 's'} could not be matched to the saved plan.`)
-  if (!state.planComplete) notices.push('The saved execution plan is incomplete; some totals cannot be verified.')
-  const objectiveScorer = summary.objective_scorer
-  const displayGroups = hierarchyDisplayGroups(groups, hierarchy.roots.groups)
-  const producerCounts = overall.producer_counts
-  const executionCount = producerCounts
-    ? producerCounts.target_facing.attempts + producerCounts.orchestration.attempts + producerCounts.unknown.attempts
-    : state.results.length
-  const atomicGroupsExpanded = atomicGroupsExpandedChoice ?? displayGroups.length <= AUTO_EXPAND_GROUP_LIMIT
+  const active = !isTerminalRunState(run.status)
+  const detailsContext: ScenarioRunDetailsContext = {
+    scenarioResultId,
+    operationId: run.operation_id,
+    plan: state.plan,
+    summary,
+    activeConversations: state.activeConversations,
+    hierarchyGroups: hierarchy.roots.groups,
+    seedObjectives,
+    conversationState: location.state,
+  }
+  // A run of one atomic attack shows that attack directly, from preparing through completion.
+  const singleGroupId = singleAtomicGroupId(state.plan)
+  const singleGroup = state.plan?.atomic_groups.find((group) => group.id === singleGroupId)
+  const singleAttempt = singleGroup
+    ? singleAttackAttempt(singleGroup, state.results, hierarchy.roots.groups, state.activeConversations, active)
+    : null
+  const openObjectiveAttempt = (attempt: ScenarioProgressResult): void => {
+    attackDetails.open(attempt, objectiveTrigger.current)
+    setObjective(null)
+  }
+
   return (
     <main className={styles.root} data-testid="scenario-run-page">
       <div className={styles.content}>
-        <Link to={backPath} className={styles.backLink}><ArrowLeftRegular /> {backLabel}</Link>
+        {backLinkElement}
         <Text role="status" aria-label="Run status updates" aria-live="polite" className={styles.liveStatus}>
           {!active ? `${run.scenario_registry_name ?? run.scenario_name}: ${run.status.toLowerCase()}.` : ''}
         </Text>
-        <header className={styles.header} ref={overviewTarget} tabIndex={-1}>
-          <div className={styles.headerIdentity}>
-            <div className={styles.titleRow}>
-              <Text as="h1" size={700} weight="semibold">{run.scenario_registry_name ?? run.scenario_name}</Text>
-              <Badge appearance="tint" color={STATE_COLORS[run.status]} data-testid="run-state-badge">
-                {run.status === 'IN_PROGRESS' ? 'Executing' : run.status.charAt(0) + run.status.slice(1).toLowerCase()}
-              </Badge>
-            </div>
-            {run.description && <Text className={styles.sectionHint}>{run.description}</Text>}
-          </div>
-          <div className={styles.headerActions}>
-            {active && <Link className={styles.backLink} to="/scanner/queue">View queue</Link>}
-            <Button icon={<ArrowClockwiseRegular />} disabled={rerunPending} onClick={() => { void rerun() }}>{rerunPending ? 'Loading...' : 'Rerun'}</Button>
-            {active ? <Button icon={<StopRegular />} className={styles.touchTarget} onClick={() => { setCancelError(null); setCancelOpen(true) }}>Cancel</Button>
-              : (run.status === 'FAILED' || run.status === 'CANCELLED') && <Button appearance="primary" icon={<PlayRegular />}
-                disabled={resume.pendingRunId !== null} onClick={() => { setRerunError(null); resume.requestResume(scenarioResultId) }}>Resume</Button>}
-          </div>
-        </header>
-        {controlError && <MessageBar intent="error"><MessageBarBody>
-          {controlError}
-        </MessageBarBody></MessageBar>}
-        <section className={styles.metadata} aria-label="Scan summary">
-          <div className={styles.metadataItem}><Text size={200} className={styles.metadataLabel}>Operation</Text>
-            {run.operation_id ? <Link to={`/operations/${encodeURIComponent(run.operation_id)}`}>{run.operation_name ?? 'Operation'}</Link> : <Text>Unassigned</Text>}
-          </div>
-          <div className={styles.metadataItem}><Text size={200} className={styles.metadataLabel}>Target</Text><Text weight="semibold">{run.target?.model_name ?? run.target?.target_type ?? 'Not recorded'}</Text></div>
-          <div className={styles.metadataItem}><Text size={200} className={styles.metadataLabel}>Timing</Text><ScenarioRunTiming run={run} /></div>
-          <div className={styles.metadataItem}><Text size={200} className={styles.metadataLabel}>Attack success</Text>
-            <Text weight="semibold">{formatProgressSuccess(overall)}</Text>
-            <Text size={200} className={styles.sectionHint}>{outcomes ? `${outcomes.successes} / ${outcomes.total_decided} decided` : `${overall.succeeded} / ${overall.completed} complete`}</Text>
-          </div>
-          <div className={styles.metadataItem}><Text size={200} className={styles.metadataLabel}>Errors / retries</Text><Text weight="semibold">{overall.errors} / {overall.retries}</Text></div>
-          <div className={styles.metadataItem}><Text size={200} className={styles.metadataLabel}>Labels</Text>
-            <div className={styles.badgeList}>{Object.entries(run.labels ?? {}).map(([key, value]) => <Badge key={key} appearance="outline" className={styles.labelBadge}>{key}: {value}</Badge>)}</div>
-          </div>
-        </section>
-        {(run.status === 'FAILED' || run.error || overall.errors > 0) && <MessageBar
-          intent={run.status === 'FAILED' ? 'error' : run.status === 'CANCELLED' && overall.errors === 0 ? 'info' : 'warning'}>
-          <MessageBarBody>{run.status === 'FAILED' ? 'Scan failed. Resume to continue remaining attacks.'
-            : run.status === 'CANCELLED' ? 'Scan cancelled.'
-            : `${overall.errors} attack${overall.errors === 1 ? '' : 's'} ended with an error.`}
-            {firstError && <Button appearance="transparent" onClick={(event) => { openDetails(firstError, event.currentTarget) }}>View attack</Button>}
-            {run.error && <Accordion collapsible><AccordionItem value="error">
-              <AccordionHeader>Error details</AccordionHeader>
-              <AccordionPanel><Text className={styles.objective}>{run.error_type ? `${run.error_type}: ` : ''}{run.error}</Text></AccordionPanel>
-            </AccordionItem></Accordion>}
-          </MessageBarBody>
-        </MessageBar>}
-        {state.stale && <MessageBar intent="warning"><MessageBarBody>Live updates paused. {state.error} <Button onClick={retry}>Retry</Button></MessageBarBody></MessageBar>}
-        {notices.length > 0 && <MessageBar aria-label="Scan notices"
-          intent={state.overloadSummaries.length > 0 || unmatched > 0 ? 'warning' : 'info'}>
-          <MessageBarBody>
-            {notices.join(' ')}
-            {state.overloadSummaries.length > 0 && <Accordion collapsible><AccordionItem value="overload">
-              <AccordionHeader>Overload details</AccordionHeader>
-              <AccordionPanel>{state.overloadSummaries.map((overload) => (
-                <Text block key={overload.component_role}>
-                  {overload.component_role.replace(/_/g, ' ')}: {overload.count}
-                  {overload.status_codes.length > 0 ? ` (HTTP ${overload.status_codes.join(', ')})` : ''}
-                </Text>
-              ))}</AccordionPanel>
-            </AccordionItem></Accordion>}
-          </MessageBarBody>
-        </MessageBar>}
-        {active && <section className={styles.progressSurface} aria-label="Scan progress">
-          <div className={styles.progressPrimary}>
-            <Text weight="semibold">{run.status === 'QUEUED' ? `Queued${run.queue_position ? ` · Position ${run.queue_position}` : ''}` : `${overall.completed}${overall.planned === null ? '' : ` of ${overall.planned}`} attacks complete`}</Text>
-            <ProgressBar value={overall.planned ? overall.completed / overall.planned : undefined} aria-label="Scan progress" />
-          </div>
-          <ScenarioRunTiming run={run} overall={overall} />
-        </section>}
-        {state.activeConversations.length > 0 && <section className={styles.section} aria-labelledby="live-conversations-heading">
-          <Text as="h2" id="live-conversations-heading" size={500} weight="semibold">Executing</Text>
-          {state.activeConversations.map((conversation) => (
-            <div key={conversation.conversation_id} className={styles.liveConversation}>
-              <Button appearance="transparent" onClick={(event) => {
-                detailsTrigger.current = event.currentTarget
-                navigate(scenarioRunAttackRoutePath(scenarioResultId, conversation.attack_result_id), { state: location.state })
-              }}>{conversation.atomic_attack_name}</Button>
-              <Text className={styles.preview}>{conversation.objective}</Text>
-              <Link to={scenarioConversationRoutePath(scenarioResultId, conversation.conversation_id)}>Watch live conversation</Link>
-            </div>
-          ))}
-        </section>}
-        {savedConversations.length > 0 && <section className={styles.section} aria-label="Saved conversations">
-          <Text as="h2" size={500} weight="semibold">Saved conversations</Text>
-          {savedConversations.map((conversation) => <div
-            key={`${conversation.attack_result_id}:${conversation.conversation_id}`} className={styles.liveConversation}>
-            <Text>{conversation.atomic_attack_name}</Text>
-            <Text className={styles.preview}>{conversation.objective}</Text>
-            <Link to={scenarioConversationRoutePath(scenarioResultId, conversation.conversation_id)}>Open saved conversation</Link>
-          </div>)}
-        </section>}
-        <section className={styles.section} aria-labelledby="atomic-groups-heading">
-          <div className={styles.sectionHeading}>
-            <div className={styles.objectivesHeading}>
-              <Text as="h2" id="atomic-groups-heading" size={500} weight="semibold">
-                Atomic attack groups
-              </Text>
-              <Button
-                appearance="subtle"
-                className={styles.touchTarget}
-                icon={atomicGroupsExpanded ? <ChevronDownRegular /> : <ChevronRightRegular />}
-                aria-expanded={atomicGroupsExpanded}
-                aria-controls="atomic-groups-panel"
-                aria-label={`${atomicGroupsExpanded ? 'Collapse' : 'Expand'} atomic attack groups`}
-                data-testid="toggle-atomic-groups-btn"
-                ref={atomicGroupsToggleRef}
-                onClick={() => setAtomicGroupsExpandedChoice(!atomicGroupsExpanded)}
-              >
-              </Button>
-            </div>
-            <Text className={styles.sectionHint}>
-              {`${displayGroups.length.toLocaleString()} group${displayGroups.length === 1 ? '' : 's'}, ${executionCount.toLocaleString()} ${producerCounts ? '' : 'loaded '}execution${executionCount === 1 ? '' : 's'}`}
-            </Text>
-          </div>
-          <div id="atomic-groups-panel" hidden={!atomicGroupsExpanded}>
-            {atomicGroupsExpanded && (
-              <ScenarioResultHierarchy hierarchy={hierarchy} runStatus={run.status}>
-                {displayGroups.length === 0 ? (
-                  <EmptyState text="No atomic attack groups have been persisted yet." />
-                ) : (
-                  <div className={styles.displayGroupList}>
-                    {displayGroups.map((group) => {
-                      // Merge member groups newest-first so the row cap keeps the group's latest executions.
-                      const attempts = (group.atomic_group_ids ?? [])
-                        .flatMap((atomicGroupId) => attemptsByGroupId.get(atomicGroupId) ?? [])
-                        .sort((left, right) => Date.parse(right.timestamp) - Date.parse(left.timestamp))
-                      const defaultExpanded = displayGroups.length <= AUTO_EXPAND_GROUP_LIMIT
-                      const expanded = expandedGroupChoices.get(group.id) ?? defaultExpanded
-                      const panelId = `atomic-group-${group.id.replace(/[^a-zA-Z0-9_-]/g, '-')}`
-                      return (
-                        <article key={group.id} className={styles.displayGroup}>
-                          <div className={styles.displayGroupSummary}>
-                            <Button
-                              appearance="subtle"
-                              className={styles.expandButton}
-                              icon={expanded ? <ChevronDownRegular /> : <ChevronRightRegular />}
-                              aria-expanded={expanded}
-                              aria-controls={panelId}
-                              aria-label={`${expanded ? 'Collapse' : 'Expand'} attacks in ${group.display_group}`}
-                              onClick={() => toggleDisplayGroup(group.id, defaultExpanded)}
-                            />
-                            <span className={styles.displayGroupIdentity}>
-                              <Text size={400} weight="semibold">{group.display_group}</Text>
-                              <Text size={200} className={styles.sectionHint}>
-                                {group.atomic_attack_names.join(', ')}
-                              </Text>
-                            </span>
-                            <span className={styles.displayGroupMetrics}>
-                              <DisplayGroupMetric
-                                label="Completed"
-                                value={formatCompletion(group.completed, group.planned)}
-                              />
-                              <DisplayGroupMetric
-                                label="Attack success"
-                                value={formatSuccess(group.succeeded, group.completed, group.success_percentage)}
-                              />
-                              <DisplayGroupMetric label="Errors" value={String(group.errors)} />
-                              <DisplayGroupMetric label="Retries" value={String(group.retries)} />
-                            </span>
-                          </div>
-                          {expanded && (
-                            <div
-                              id={panelId}
-                              className={styles.displayGroupPanel}
-                              aria-label={`${group.display_group} attack executions`}
-                            >
-                              <AttackExecutionTable
-                                scenarioResultId={scenarioResultId}
-                                label={`${group.display_group} attack results`}
-                                attempts={attempts.slice(0, MAX_VISIBLE_ATTEMPTS_PER_GROUP)}
-                                totalAttempts={attempts.length}
-                                roots={hierarchy.roots.groups
-                                  .filter((savedGroup) => group.atomic_group_ids.includes(savedGroup.atomic_group_id))
-                                  .flatMap((savedGroup) => savedGroup.roots)}
-                                hierarchy={hierarchy}
-                                seedObjectives={seedObjectives}
-                                onOpenDetails={openAttemptDetails}
-                                showTimestamp={false}
-                                showConversationLink
-                                booleanOutcome
-                              />
-                            </div>
-                          )}
-                        </article>
-                      )
-                    })}
-                  </div>
-                )}
-              </ScenarioResultHierarchy>
-            )}
-          </div>
-        </section>
-        <section className={styles.section} aria-labelledby="objectives-heading">
-          <Text as="h2" id="objectives-heading" size={500} weight="semibold">Datasets &amp; objectives</Text>
-          <div className={styles.tableScroll}><Table size="small" aria-label="Datasets and objectives">
-            <TableHeader><TableRow><TableHeaderCell>Dataset</TableHeaderCell><TableHeaderCell>Objective</TableHeaderCell><TableHeaderCell>Attack success</TableHeaderCell><TableHeaderCell>Completed</TableHeaderCell></TableRow></TableHeader>
-            <TableBody>{summary.seed_groups.map((seed) => {
-              const planSeed = planSeeds.get(seed.id)
-              return <TableRow key={seed.id}>
-                <TableCell>{datasetsBySeed.get(seed.id) || 'Not recorded'}</TableCell>
-                <TableCell><Button appearance="transparent" className={styles.objectiveLinkButton} onClick={(event) => {
-                  objectiveTrigger.current = event.currentTarget
-                  setObjective(planSeed ?? { id: seed.id, objective_sha256: '', objective: seed.objective ?? 'Not recorded', prompts: [] })
-                }}>
-                  {objectivePreview(seed.objective ?? null, seed.id)}
-                </Button></TableCell>
-                <TableCell>{formatProgressSuccess(seed)}</TableCell>
-                <TableCell>{seed.completed}{seed.planned === null ? '' : ` / ${seed.planned}`}</TableCell>
-              </TableRow>
-            })}</TableBody>
-          </Table></div>
-        </section>
+        <ScenarioRunHeader run={run} active={active} controls={controls} headerRef={headerRef} />
+        <ScenarioRunNotices run={run} summary={summary} state={state} onRetry={retry} onOpenAttempt={attackDetails.open}
+          inlineAttempt={singleAttempt && 'outcome' in singleAttempt ? singleAttempt : null} />
+        <ScenarioRunProgress scenarioResultId={scenarioResultId} run={run} overall={summary.overall}
+          liveAttacks={runningAttacks} conversationState={location.state}
+          onOpenAttack={attackDetails.open} />
+        <ScenarioRunSavedConversations scenarioResultId={scenarioResultId} conversations={savedConversations}
+          conversationState={location.state} />
+        {singleGroupId ? (
+          <section className={styles.section} aria-label="Attack details">
+            <ScenarioAttackDetails context={detailsContext} attempt={singleAttempt} atomicGroupId={singleGroupId}
+              preparing={active} framed />
+          </section>
+        ) : <>
+          <AtomicAttackGroupsSection
+            scenarioResultId={scenarioResultId}
+            runStatus={run.status}
+            summary={summary}
+            results={state.results}
+            hierarchy={hierarchy}
+            seedObjectives={seedObjectives}
+            techniqueNames={techniqueNames}
+            onOpenDetails={attackDetails.open}
+            toggleRef={groupsToggleRef}
+          />
+          <ScenarioRunObjectivesSection
+            summary={summary}
+            plan={state.plan}
+            results={state.results}
+            activeConversations={state.activeConversations}
+            onOpenObjective={(seed: ScenarioRunPlanSeedGroup, trigger: HTMLElement) => {
+              objectiveTrigger.current = trigger
+              setObjective(seed)
+            }}
+          />
+        </>}
         {run.status === 'COMPLETED' && (
           <Accordion collapsible onToggle={(_, data) => { setPairedExpanded(data.openItems.includes('paired')) }}>
             <AccordionItem value="paired">
@@ -547,100 +193,20 @@ function ScenarioRunContent({ scenarioResultId, attackResultId }: ScenarioRunCon
             </AccordionItem>
           </Accordion>
         )}
-        <section className={styles.section} aria-labelledby="configuration-heading">
-          <Text as="h2" id="configuration-heading" size={500} weight="semibold">Scenario configuration</Text>
-          {run.scenario_identity ? <Table size="small" aria-label="Scenario configuration"><TableBody>
-            <RegistryIdentityRow name={run.scenario_registry_name ?? run.scenario_name} identity={run.scenario_identity}
-              columns={1} expanded={identityExpanded} onToggle={() => { setIdentityExpanded((value: boolean) => !value) }} />
-          </TableBody></Table> : <Text className={styles.sectionHint}>No saved scenario identity.</Text>}
-        </section>
+        {!singleGroupId && <ScenarioRunConfigurationSection run={run} />}
       </div>
-      <Dialog open={cancelOpen} onOpenChange={(_, data) => { if (!cancelling) setCancelOpen(data.open) }}>
-        <DialogSurface><DialogBody><DialogTitle>Cancel scan?</DialogTitle><DialogContent className={styles.dialogContent}>
-          <Text>Stop remaining attacks. Saved conversations and results stay available.</Text>
-          {cancelError && <MessageBar intent="error"><MessageBarBody>{cancelError}</MessageBarBody></MessageBar>}
-        </DialogContent><DialogActions><Button disabled={cancelling} onClick={() => { setCancelOpen(false) }}>Keep running</Button>
-          <Button appearance="primary" disabled={cancelling} onClick={() => { void cancel() }}>{cancelling ? 'Cancelling...' : 'Cancel scan'}</Button>
-        </DialogActions></DialogBody></DialogSurface>
-      </Dialog>
-      <Dialog
-        open={selectedAttempt !== null}
-        onOpenChange={(_, data) => {
-          if (!data.open) {
-            closeAttemptDetails()
-          }
-        }}
-      >
-        <DialogSurface className={styles.attackDetailDialogSurface}>
-          <DialogBody className={styles.attackDetailDialogBody}>
-            <DialogTitle
-              action={(
-                <Button
-                  appearance="subtle"
-                  icon={<DismissRegular />}
-                  aria-label="Close attack details"
-                  onClick={closeAttemptDetails}
-                />
-              )}
-            >
-              {selectedAttempt?.atomic_attack_name || 'Attack attempt'}
-            </DialogTitle>
-            {selectedAttempt && (
-              <DialogContent className={styles.attackDetailDialogContent}>
-                <AttackAttemptDetails
-                  attempt={selectedAttempt}
-                  objective={
-                    (hierarchySelection?.attack_result_id === selectedAttempt.attack_result_id
-                      ? hierarchySelection.objective
-                      : null) ??
-                    ('objective' in selectedAttempt ? selectedAttempt.objective : null) ??
-                    (selectedAttempt.seed_group_id ? seedObjectives.get(selectedAttempt.seed_group_id) : null) ??
-                    null
-                  }
-                  atomicGroup={selectedAttemptGroup}
-                  techniqueDetails={selectedActive?.technique_details
-                    ?? (selectedAtomicGroupId ? progressAtomicGroups.get(selectedAtomicGroupId)?.technique_details : null)}
-                  objectiveScorer={objectiveScorer}
-                  conversationPath={selectedActive
-                    ? scenarioConversationRoutePath(scenarioResultId, selectedActive.conversation_id)
-                    : selectedAttempt.conversation_id
-                      ? attackConversationRoutePath(selectedAttempt.attack_result_id, selectedAttempt.conversation_id, scenarioResultId)
-                      : null}
-                  conversationState={location.state}
-                />
-              </DialogContent>
-            )}
-            <DialogActions>
-              <Button appearance="primary" onClick={closeAttemptDetails}>Close</Button>
-            </DialogActions>
-          </DialogBody>
-        </DialogSurface>
-      </Dialog>
+      <CancelScanDialog open={controls.cancelOpen} cancelling={controls.cancelling} error={controls.cancelError}
+        onOpenChange={controls.setCancelOpen} onConfirm={controls.cancel} />
+      <AttackDetailsDialog
+        run={run}
+        context={detailsContext}
+        attempt={attackDetails.selectedAttempt}
+        hierarchySelection={attackDetails.hierarchySelection}
+        onClose={attackDetails.close}
+      />
       <ObjectiveDetailsDialog objective={objective} onClose={closeObjective}
-        attempts={objective ? attemptsBySeed.get(objective.id) ?? [] : []}
-        onOpenAttempt={openDetails} scenarioResultId={scenarioResultId} />
+        attempts={objective ? attemptsBySeed.get(objective.id) ?? [] : []} techniqueNames={techniqueNames}
+        onOpenAttempt={openObjectiveAttempt} scenarioResultId={scenarioResultId} />
     </main>
   )
 }
-
-function EmptyState({ text }: { readonly text: string }) {
-  return <Text className={useScenarioRunPageStyles().sectionHint}>{text}</Text>
-}
-
-function DisplayGroupMetric({ label, value }: { readonly label: string; readonly value: string }) {
-  return (
-    <div>
-      <Text size={200}>{label}</Text>
-      <Text weight="semibold">{value}</Text>
-    </div>
-  )
-}
-
-function formatCompletion(completed: number, planned: number | null): string {
-  return planned === null ? `${completed}/total unavailable` : `${completed}/${planned}`
-}
-
-function formatSuccess(succeeded: number, completed: number, percentage: number | null): string {
-  if (percentage === null) return completed === 0 ? 'Unavailable' : `${succeeded}/${completed}`
-  return `${percentage}%`
-}
diff --git a/frontend/src/components/Scenarios/ScenarioRunProgress.tsx b/frontend/src/components/Scenarios/ScenarioRunProgress.tsx
new file mode 100644
index 0000000000..2e152b8d7b
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScenarioRunProgress.tsx
@@ -0,0 +1,56 @@
+import { mergeClasses, ProgressBar, Text } from '@fluentui/react-components'
+
+import type { ScenarioActiveConversation, ScenarioProgressCounts, ScenarioProgressHeader } from '@/types'
+import { isTerminalRunState } from '@/utils/scenarioRunProgress'
+
+import AttackActivity from './AttackActivity'
+import LiveAttacksPopover from './LiveAttacksPopover'
+import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+import type { LiveAttack } from './scenarioRunLayout'
+import ScenarioRunTiming from './ScenarioRunTiming'
+
+interface ScenarioRunProgressProps {
+  readonly scenarioResultId: string
+  readonly run: ScenarioProgressHeader
+  readonly overall: ScenarioProgressCounts
+  /** All running attacks remain available even when a matching attempt is shown inline. */
+  readonly liveAttacks?: readonly LiveAttack[]
+  /** Router state carried to a live conversation, so its back link returns here. */
+  readonly conversationState: unknown
+  readonly onOpenAttack: (conversation: ScenarioActiveConversation, trigger: HTMLElement) => void
+}
+
+/**
+ * Queue position or completed attacks, timing, and live attacks while a scan is active.
+ * It stays mounted and collapses when the scan finishes, so the results below do not jump.
+ */
+export default function ScenarioRunProgress({
+  scenarioResultId, run, overall, liveAttacks, conversationState, onOpenAttack,
+}: ScenarioRunProgressProps) {
+  const styles = useScenarioRunPageStyles()
+  const active = !isTerminalRunState(run.status)
+  const queued = run.status === 'QUEUED'
+  const status = queued
+    ? `Queued${run.queue_position ? ` · Position ${run.queue_position}` : ''}`
+    : `${overall.completed}${overall.planned === null ? '' : ` of ${overall.planned}`} attacks complete`
+  return (
+    <div className={mergeClasses(styles.progressRegion, !active && styles.progressRegionComplete)}
+      aria-hidden={!active} inert={!active}>
+      <div className={styles.progressClip}>
+        <section className={styles.progressSurface} aria-label="Scan progress">
+          <div className={styles.progressPrimary}>
+            <AttackActivity label={queued ? 'Waiting to start' : 'Scan in progress'} />
+            <Text weight="semibold">{status}</Text>
+            <ProgressBar value={overall.planned ? overall.completed / overall.planned : undefined} aria-label="Scan progress" />
+          </div>
+          <div className={styles.progressTiming}>
+            <ScenarioRunTiming run={run} />
+            <ScenarioRunTiming run={run} overall={overall} />
+          </div>
+          {liveAttacks && <LiveAttacksPopover scenarioResultId={scenarioResultId} liveAttacks={liveAttacks}
+            conversationState={conversationState} onOpenAttack={onOpenAttack} />}
+        </section>
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/components/Scenarios/ScenarioRunSavedConversations.tsx b/frontend/src/components/Scenarios/ScenarioRunSavedConversations.tsx
new file mode 100644
index 0000000000..1339a9e316
--- /dev/null
+++ b/frontend/src/components/Scenarios/ScenarioRunSavedConversations.tsx
@@ -0,0 +1,38 @@
+import { Text } from '@fluentui/react-components'
+import { Link } from 'react-router'
+
+import type { ScenarioActiveConversation } from '@/types'
+import { attackConversationRoutePath } from '@/utils/routeParams'
+
+import { useScenarioRunPageStyles } from './ScenarioRunPage.styles'
+
+interface ScenarioRunSavedConversationsProps {
+  readonly scenarioResultId: string
+  /** Conversations saved by attacks that stopped before saving a result. */
+  readonly conversations: readonly ScenarioActiveConversation[]
+  /** Router state carried to the conversation, so its back link returns here. */
+  readonly conversationState: unknown
+}
+
+/** Interrupted attacks' saved conversations, which have no result row to open them from. */
+export default function ScenarioRunSavedConversations({
+  scenarioResultId, conversations, conversationState,
+}: ScenarioRunSavedConversationsProps) {
+  const styles = useScenarioRunPageStyles()
+  if (conversations.length === 0) return null
+  return (
+    <section className={styles.section} aria-labelledby="saved-conversations-heading">
+      <Text as="h2" id="saved-conversations-heading" size={500} weight="semibold">Saved conversations</Text>
+      {conversations.map((conversation) => (
+        <div key={`${conversation.attack_result_id}:${conversation.conversation_id}`} className={styles.liveConversation}>
+          <Text>{conversation.atomic_attack_name}</Text>
+          <Text className={styles.preview}>{conversation.objective}</Text>
+          <Link to={attackConversationRoutePath(conversation.attack_result_id, conversation.conversation_id, scenarioResultId)}
+            state={conversationState}>
+            Open saved conversation
+          </Link>
+        </div>
+      ))}
+    </section>
+  )
+}
diff --git a/frontend/src/components/Scenarios/ScenarioRunTiming.tsx b/frontend/src/components/Scenarios/ScenarioRunTiming.tsx
index 74bc677508..995dd51df0 100644
--- a/frontend/src/components/Scenarios/ScenarioRunTiming.tsx
+++ b/frontend/src/components/Scenarios/ScenarioRunTiming.tsx
@@ -23,7 +23,10 @@ export default function ScenarioRunTiming({ run, overall }: ScenarioRunTimingPro
   }, [active, run.started_at])
   if (overall) {
     const eta = getEtaMilliseconds(run, overall, now)
-    return eta === null ? null : <Text>About {formatDuration(eta)} left</Text>
+    const pending = overall.planned !== null && overall.planned > 1
+    return <Text>{eta === null
+      ? pending ? 'Estimating time remaining' : 'Time remaining unavailable'
+      : `About ${formatDuration(eta)} left`}</Text>
   }
   const elapsed = run.started_at ? formatDuration(getElapsedMilliseconds(run, now))
     : run.status === 'CREATED' || run.status === 'QUEUED' ? 'Not started' : 'Not recorded'
diff --git a/frontend/src/components/Scenarios/ScenarioTechniqueSection.tsx b/frontend/src/components/Scenarios/ScenarioTechniqueSection.tsx
index b1f5e30a61..fc23378bb0 100644
--- a/frontend/src/components/Scenarios/ScenarioTechniqueSection.tsx
+++ b/frontend/src/components/Scenarios/ScenarioTechniqueSection.tsx
@@ -5,7 +5,8 @@ import { ChevronDownRegular, ChevronRightRegular } from '@fluentui/react-icons'
 
 import ContextualHelpLabel from '@/components/ContextualHelpLabel'
 import { HELP_DEFINITIONS } from '@/components/helpDefinitions'
-import { useRegistryIdentityRowStyles } from '@/components/Registry/RegistryIdentityRow.styles'
+import { IdentityJson } from '@/components/Registry/IdentityDisclosure'
+import { useIdentityDisclosureStyles } from '@/components/Registry/IdentityDisclosure.styles'
 
 import { useScenarioDetailStyles } from './ScenarioDetail.styles'
 import { exceedsTechniqueLimit, type SelectableTechnique } from './scenarioLaunchForm'
@@ -46,7 +47,7 @@ export default function ScenarioTechniqueSection({
   onRemoveToken,
 }: ScenarioTechniqueSectionProps) {
   const styles = useScenarioDetailStyles()
-  const identityStyles = useRegistryIdentityRowStyles()
+  const identityStyles = useIdentityDisclosureStyles()
   const identityId = useId()
   const techniqueLimitDescriptionId = `${identityId}-technique-limit`
   const baselineUnavailableId = `${identityId}-baseline-unavailable`
@@ -187,11 +188,13 @@ export default function ScenarioTechniqueSection({
               icon={expanded ? <ChevronDownRegular /> : <ChevronRightRegular />}
               aria-label={`Identity for ${technique.name}`} aria-expanded={expanded} aria-controls={regionId}
               onClick={() => toggleIdentity(technique.name)} />
-            {expanded && <div id={regionId} role="region" aria-label={`Identity for ${technique.name}`}
-              className={mergeClasses(styles.identityRegion, identityStyles.details)}>
-              {technique.identifier ? <pre className={identityStyles.json}>{JSON.stringify(technique.identifier, null, 2)}</pre>
-                : <Text>{technique.isBaseline ? 'Baseline identity is available after launch.' : 'Identity was not recorded for this technique.'}</Text>}
-            </div>}
+            {expanded && (technique.identifier
+              ? <IdentityJson id={regionId} name={technique.name} identity={technique.identifier}
+                className={styles.identityRegion} />
+              : <div id={regionId} role="region" aria-label={`Identity for ${technique.name}`}
+                className={mergeClasses(styles.identityRegion, identityStyles.details)}>
+                <Text>{technique.isBaseline ? 'Baseline identity is available after launch.' : 'Identity was not recorded for this technique.'}</Text>
+              </div>)}
           </div>
           )
         })}
diff --git a/frontend/src/components/Scenarios/scenarioHierarchy.ts b/frontend/src/components/Scenarios/scenarioHierarchy.ts
index 87bfbbe876..49fcfc3449 100644
--- a/frontend/src/components/Scenarios/scenarioHierarchy.ts
+++ b/frontend/src/components/Scenarios/scenarioHierarchy.ts
@@ -1,9 +1,9 @@
 import type {
-  AttackResultRole,
   ScenarioDisplayGroupProgress,
   ScenarioHierarchyGroup,
   ScenarioHierarchyNode,
   ScenarioHierarchyProjection,
+  ScenarioProgressSummary,
 } from '@/types'
 
 /** One saved child-reference position under a parent: a loaded child, or a reference that did not resolve. */
@@ -113,12 +113,18 @@ export function hierarchyDisplayGroups(
   ]
 }
 
-const ROLE_LABELS: Record<AttackResultRole, string> = {
-  orchestration: 'Orchestration',
-  target_facing: 'Target-facing',
-  unknown: 'Unknown role',
+interface RunExecutionCount {
+  readonly count: number
+  /** False when the server did not report totals, so only loaded results were counted. */
+  readonly exact: boolean
 }
 
-export function resultRoleLabel(role: AttackResultRole): string {
-  return ROLE_LABELS[role] ?? ROLE_LABELS.unknown
+/** Attack executions in a run: the server's producer totals, otherwise the results loaded so far. */
+export function runExecutionCount(summary: ScenarioProgressSummary, loadedResults: number): RunExecutionCount {
+  const producerCounts = summary.overall.producer_counts
+  if (!producerCounts) return { count: loadedResults, exact: false }
+  return {
+    count: producerCounts.target_facing.attempts + producerCounts.orchestration.attempts + producerCounts.unknown.attempts,
+    exact: true,
+  }
 }
diff --git a/frontend/src/components/Scenarios/scenarioRunLayout.test.ts b/frontend/src/components/Scenarios/scenarioRunLayout.test.ts
new file mode 100644
index 0000000000..434e0397f2
--- /dev/null
+++ b/frontend/src/components/Scenarios/scenarioRunLayout.test.ts
@@ -0,0 +1,136 @@
+import type {
+  ScenarioActiveConversation,
+  ScenarioHierarchyGroup,
+  ScenarioHierarchyNode,
+  ScenarioProgressCounts,
+  ScenarioProgressResult,
+  ScenarioRunPlan,
+} from '@/types'
+import { INITIAL_SCENARIO_RUN_PROGRESS_STATE, type ScenarioRunProgressState } from '@/utils/scenarioRunProgress'
+
+import {
+  attackIdForConversation,
+  interruptedConversations,
+  liveAttacks,
+  singleAtomicGroupId,
+  singleAttackAttempt,
+} from './scenarioRunLayout'
+
+const COUNTS: ScenarioProgressCounts = { completed: 0, planned: 1, succeeded: 0, success_percentage: null, errors: 0, retries: 0 }
+const RESULT: ScenarioProgressResult = {
+  attack_result_id: 'attack', conversation_id: 'main', related_conversation_ids: ['pruned'], atomic_group_id: 'group',
+  atomic_attack_name: 'PromptSendingAttack', seed_group_id: 'seed', outcome: 'success', execution_time_ms: 1,
+  timestamp: '2026-01-01T00:00:00Z', total_retries: 0, retries: [],
+}
+const PLAN: ScenarioRunPlan = {
+  version: 1,
+  atomic_groups: [{
+    id: 'group', atomic_attack_name: RESULT.atomic_attack_name, display_group: 'Direct', technique_eval_hash: 'hash',
+    seed_group_ids: ['seed'], tags: [], is_compound: false,
+  }],
+  seed_groups: [{ id: 'seed', objective_sha256: 'sha', objective: 'Objective', prompts: [] }],
+}
+const PLANNED_GROUP = PLAN.atomic_groups[0]
+const LIVE: ScenarioActiveConversation = {
+  attack_result_id: 'live', conversation_id: 'live-main', conversation_ids: ['live-first', 'live-main'],
+  atomic_attack_name: 'Crescendo', objective: 'Objective', started_at: '2026-01-01T00:00:00Z', seed_identifiers: [],
+}
+
+function root(overrides: Partial<ScenarioHierarchyNode> = {}): ScenarioHierarchyNode {
+  return {
+    attack_result_id: 'root', conversation_id: 'root-main', result_role: 'target_facing', atomic_attack_name: 'PromptSendingAttack',
+    atomic_group_id: 'group', seed_group_id: 'seed', objective: 'Objective', outcome: 'success', execution_time_ms: 1,
+    executed_turns: 1, timestamp: '2026-01-01T00:00:00Z', total_retries: 0, retries: [], retries_truncated: false,
+    child_attack_result_ids: [], child_references_truncated: false, children: [], children_truncated: false,
+    child_offset: 0, unresolved_child_attack_result_ids: [], unresolved_child_references_truncated: false,
+    conversations: [], conversations_truncated: false, ...overrides,
+  }
+}
+
+function hierarchyGroup(roots: ScenarioHierarchyNode[]): ScenarioHierarchyGroup {
+  return { atomic_group_id: 'group', atomic_attack_name: 'PromptSendingAttack', display_group: 'Direct', roots, counts: COUNTS }
+}
+
+function state(overrides: Partial<ScenarioRunProgressState>): ScenarioRunProgressState {
+  return { ...INITIAL_SCENARIO_RUN_PROGRESS_STATE, ...overrides }
+}
+
+describe('singleAtomicGroupId', () => {
+  it('keeps single-card eligibility across saved retry attempts', () => {
+    const attempts = [RESULT, { ...RESULT, attack_result_id: 'retry' }]
+    expect(singleAtomicGroupId(PLAN)).toBe('group')
+    expect(singleAttackAttempt(PLANNED_GROUP, attempts, [hierarchyGroup([root(), root({ attack_result_id: 'retry' })])], [], false))
+      .toBe(attempts[1])
+  })
+  it('should find the only atomic group of a one-attack run', () => {
+    expect(singleAtomicGroupId(PLAN)).toBe('group')
+  })
+
+  it.each<[string, ScenarioRunPlan | null]>([
+    ['an unknown plan', null],
+    ['legacy unknown capability', { ...PLAN, atomic_groups: [{ ...PLANNED_GROUP, is_compound: undefined }] }],
+    ['a running compound before children exist', { ...PLAN, atomic_groups: [{ ...PLANNED_GROUP, is_compound: true }] }],
+    ['no atomic group', { ...PLAN, atomic_groups: [] }],
+    ['two atomic groups', { ...PLAN, atomic_groups: [PLANNED_GROUP, { ...PLANNED_GROUP, id: 'other' }] }],
+    ['two seeds', { ...PLAN, seed_groups: [...PLAN.seed_groups, { ...PLAN.seed_groups[0], id: 'other' }] }],
+  ])('should not treat a run with %s as a single attack', (_label, plan) => {
+    expect(singleAtomicGroupId(plan)).toBeNull()
+  })
+})
+
+describe('singleAttackAttempt', () => {
+  it('prefers a matching active retry over the previous saved result', () => {
+    const retry = { ...LIVE, atomic_attack_name: RESULT.atomic_attack_name, seed_group_id: RESULT.seed_group_id }
+    expect(singleAttackAttempt(PLANNED_GROUP, [RESULT], [], [retry], true)).toBe(retry)
+    expect(singleAttackAttempt(PLANNED_GROUP, [RESULT], [], [retry], false)).toBe(RESULT)
+  })
+  it('uses saved results and hierarchy fallback but never an unrelated active conversation', () => {
+    const saved = root()
+    expect(singleAttackAttempt(PLANNED_GROUP, [RESULT], [hierarchyGroup([saved])], [LIVE], true)).toBe(RESULT)
+    expect(singleAttackAttempt(PLANNED_GROUP, [], [hierarchyGroup([saved])], [LIVE], true)).toBe(saved)
+    expect(singleAttackAttempt(PLANNED_GROUP, [], [], [LIVE], true)).toBeNull()
+    expect(singleAttackAttempt(PLANNED_GROUP, [], [], [], false)).toBeNull()
+  })
+  it('chooses the latest saved retry and applies the same chronology to hierarchy roots', () => {
+    const latest = { ...RESULT, attack_result_id: 'retry', timestamp: '2026-01-02T00:00:00Z' }
+    expect(singleAttackAttempt(PLANNED_GROUP, [RESULT, latest], [], [], false)).toBe(latest)
+    const latestRoot = root({ attack_result_id: latest.attack_result_id, timestamp: latest.timestamp })
+    expect(singleAttackAttempt(PLANNED_GROUP, [], [hierarchyGroup([latestRoot, root()])], [], false)).toBe(latestRoot)
+  })
+})
+
+describe('liveAttacks', () => {
+  it('should have no running attacks when no conversations are active', () => {
+    expect(liveAttacks([])).toEqual([])
+  })
+
+  it('should list each running attack once with all of its conversations counted', () => {
+    const attacks = liveAttacks([LIVE, { ...LIVE, conversation_id: 'live-first', conversation_ids: undefined }, { ...LIVE, attack_result_id: 'other', conversation_ids: undefined }])
+    expect(attacks.map((attack) => [attack.conversation.attack_result_id, attack.conversationCount])).toEqual([['live', 2], ['other', 1]])
+  })
+})
+
+describe('interruptedConversations', () => {
+  it('should keep saved conversations that no running or completed attack shows, once each', () => {
+    const recorded = { ...LIVE, attack_result_id: 'stopped', conversation_id: 'stopped-main', conversation_ids: undefined }
+    const conversations = interruptedConversations(state({
+      results: [RESULT], activeConversations: [LIVE],
+      recordedConversations: [recorded, recorded, { ...recorded, conversation_id: 'pruned' }, { ...recorded, conversation_id: 'live-first' }],
+    }))
+    expect(conversations).toEqual([recorded])
+  })
+})
+
+describe('attackIdForConversation', () => {
+  it('should find the attack owning a completed, pruned, running, or interrupted conversation', () => {
+    const run = state({
+      results: [RESULT], activeConversations: [LIVE],
+      recordedConversations: [{ ...LIVE, attack_result_id: 'stopped', conversation_id: 'stopped-main' }],
+    })
+    expect(attackIdForConversation(run, 'main')).toBe('attack')
+    expect(attackIdForConversation(run, 'pruned')).toBe('attack')
+    expect(attackIdForConversation(run, 'live-first')).toBe('live')
+    expect(attackIdForConversation(run, 'stopped-main')).toBe('stopped')
+    expect(attackIdForConversation(run, 'unknown')).toBeNull()
+  })
+})
diff --git a/frontend/src/components/Scenarios/scenarioRunLayout.ts b/frontend/src/components/Scenarios/scenarioRunLayout.ts
new file mode 100644
index 0000000000..0694e9e022
--- /dev/null
+++ b/frontend/src/components/Scenarios/scenarioRunLayout.ts
@@ -0,0 +1,90 @@
+import type {
+  ScenarioActiveConversation,
+  ScenarioHierarchyGroup,
+  ScenarioHierarchyNode,
+  ScenarioProgressResult,
+  ScenarioRunPlan,
+  ScenarioRunPlanAtomicGroup,
+} from '@/types'
+import { compareAttempts, type ScenarioRunProgressState } from '@/utils/scenarioRunProgress'
+
+/** Stable eligibility comes from the saved plan, never the number of attempts saved so far. */
+export function singleAtomicGroupId(plan: ScenarioRunPlan | null): string | null {
+  const group = plan?.atomic_groups[0]
+  return plan?.atomic_groups.length === 1 && plan.seed_groups.length === 1
+    && group?.seed_group_ids.length === 1 && group.seed_group_ids[0] === plan.seed_groups[0]?.id
+    && group.is_compound === false ? group.id : null
+}
+
+/** A matching live retry while active, otherwise the latest applicable saved attempt or hierarchy root. */
+export function singleAttackAttempt(
+  group: ScenarioRunPlanAtomicGroup,
+  results: readonly ScenarioProgressResult[],
+  hierarchyGroups: readonly ScenarioHierarchyGroup[],
+  activeConversations: readonly ScenarioActiveConversation[],
+  active: boolean,
+): ScenarioProgressResult | ScenarioHierarchyNode | ScenarioActiveConversation | null {
+  const live = active ? activeConversations.find((conversation) =>
+    conversation.atomic_attack_name === group.atomic_attack_name
+    && conversation.seed_group_id !== null && conversation.seed_group_id !== undefined
+    && group.seed_group_ids.includes(conversation.seed_group_id)) : undefined
+  return live
+    ?? results.filter((attempt) => attempt.atomic_group_id === group.id
+      && group.seed_group_ids.includes(attempt.seed_group_id)).slice(-1)[0]
+    ?? hierarchyGroups.find((candidate) => candidate.atomic_group_id === group.id)?.roots
+      .filter((root) => group.seed_group_ids.includes(root.seed_group_id)).sort(compareAttempts).slice(-1)[0]
+    ?? null
+}
+
+/** One running attack, which may have started several objective conversations. */
+export interface LiveAttack {
+  /** The conversation the attack is working on. */
+  readonly conversation: ScenarioActiveConversation
+  readonly conversationCount: number
+}
+
+/** Running attacks, one per attack, in the order they were reported. */
+export function liveAttacks(activeConversations: readonly ScenarioActiveConversation[]): LiveAttack[] {
+  const conversationsByAttack = new Map<string, [ScenarioActiveConversation, ...ScenarioActiveConversation[]]>()
+  for (const conversation of activeConversations) {
+    const conversations = conversationsByAttack.get(conversation.attack_result_id)
+    if (conversations) {
+      conversations.push(conversation)
+    } else {
+      conversationsByAttack.set(conversation.attack_result_id, [conversation])
+    }
+  }
+  return [...conversationsByAttack.values()].map((conversations) => ({
+    conversation: conversations[0],
+    conversationCount: new Set(conversations.flatMap((conversation) => [
+      conversation.conversation_id, ...(conversation.conversation_ids ?? []),
+    ])).size,
+  }))
+}
+
+/** Conversations saved by attacks that stopped before saving a result, excluding running and completed ones. */
+export function interruptedConversations(state: ScenarioRunProgressState): ScenarioActiveConversation[] {
+  const shownConversationIds = new Set([
+    ...state.results.flatMap((attempt) => [attempt.conversation_id, ...(attempt.related_conversation_ids ?? [])]),
+    ...state.activeConversations.flatMap((conversation) => [
+      conversation.conversation_id, ...(conversation.conversation_ids ?? []),
+    ]),
+  ])
+  const interrupted = new Map<string, ScenarioActiveConversation>()
+  for (const conversation of state.recordedConversations) {
+    if (!shownConversationIds.has(conversation.conversation_id)) {
+      interrupted.set(`${conversation.attack_result_id}:${conversation.conversation_id}`, conversation)
+    }
+  }
+  return [...interrupted.values()]
+}
+
+/** The attack in a run that owns a conversation, whether it is running, completed, or was interrupted. */
+export function attackIdForConversation(state: ScenarioRunProgressState, conversationId: string): string | null {
+  const active = state.activeConversations.find((conversation) =>
+    conversation.conversation_id === conversationId || conversation.conversation_ids?.includes(conversationId))
+  const completed = state.results.find((attempt) =>
+    attempt.conversation_id === conversationId || attempt.related_conversation_ids?.includes(conversationId))
+  const recorded = state.recordedConversations.find((conversation) => conversation.conversation_id === conversationId)
+  return completed?.attack_result_id ?? active?.attack_result_id ?? recorded?.attack_result_id ?? null
+}
diff --git a/frontend/src/components/Scenarios/scenarioRunNavigation.test.ts b/frontend/src/components/Scenarios/scenarioRunNavigation.test.ts
new file mode 100644
index 0000000000..a0a754959c
--- /dev/null
+++ b/frontend/src/components/Scenarios/scenarioRunNavigation.test.ts
@@ -0,0 +1,22 @@
+import { scenarioRunBackLink } from './scenarioRunNavigation'
+
+describe('scenarioRunBackLink', () => {
+  it('returns to the suite execution that opened the run', () => {
+    expect(scenarioRunBackLink({ suiteExecutionId: 'suite-1', suiteName: 'Nightly', fromScenarioHistory: true }))
+      .toEqual({ path: '/scanner/history/suites/executions/suite-1', label: 'Back to Nightly' })
+    expect(scenarioRunBackLink({ suiteExecutionId: 'suite-1' }).label).toBe('Back to suite execution')
+  })
+
+  it('returns to scan history with its filters', () => {
+    expect(scenarioRunBackLink({ scenarioHistorySearch: '?status=FAILED' }))
+      .toEqual({ path: '/scanner/history?status=FAILED', label: 'Back to scans' })
+    expect(scenarioRunBackLink({ fromScenarioHistory: true }))
+      .toEqual({ path: '/scanner/history', label: 'Back to scans' })
+  })
+
+  it('returns to the launched scenario, or the scanner catalog', () => {
+    expect(scenarioRunBackLink({ scenarioName: 'garak/encoding' }))
+      .toEqual({ path: '/scanner/launch/garak%2Fencoding', label: 'Back to scenario' })
+    expect(scenarioRunBackLink(null)).toEqual({ path: '/scanner/launch', label: 'Back to scanners' })
+  })
+})
diff --git a/frontend/src/components/Scenarios/scenarioRunNavigation.ts b/frontend/src/components/Scenarios/scenarioRunNavigation.ts
new file mode 100644
index 0000000000..ece7af2438
--- /dev/null
+++ b/frontend/src/components/Scenarios/scenarioRunNavigation.ts
@@ -0,0 +1,32 @@
+import { suiteExecutionRoutePath } from '@/components/ScenarioSuites/suiteRoutes'
+
+/** Where the run page was opened from, carried in router location state. */
+export interface ScenarioRunNavigationState {
+  fromScenarioHistory?: boolean
+  scenarioHistorySearch?: string
+  scenarioName?: string
+  suiteExecutionId?: string
+  suiteName?: string
+}
+
+interface ScenarioRunBackLink {
+  readonly path: string
+  readonly label: string
+}
+
+/** Return to the suite, history filters, or scanner that opened the run. */
+export function scenarioRunBackLink(state: ScenarioRunNavigationState | null): ScenarioRunBackLink {
+  if (state?.suiteExecutionId) {
+    return {
+      path: suiteExecutionRoutePath(state.suiteExecutionId),
+      label: `Back to ${state.suiteName ?? 'suite execution'}`,
+    }
+  }
+  if (state?.fromScenarioHistory || state?.scenarioHistorySearch) {
+    return { path: `/scanner/history${state.scenarioHistorySearch ?? ''}`, label: 'Back to scans' }
+  }
+  if (state?.scenarioName) {
+    return { path: `/scanner/launch/${encodeURIComponent(state.scenarioName)}`, label: 'Back to scenario' }
+  }
+  return { path: '/scanner/launch', label: 'Back to scanners' }
+}
diff --git a/frontend/src/components/Scorers/ScorerEvaluationDetails.styles.ts b/frontend/src/components/Scorers/ScorerEvaluationDetails.styles.ts
new file mode 100644
index 0000000000..32de033fa0
--- /dev/null
+++ b/frontend/src/components/Scorers/ScorerEvaluationDetails.styles.ts
@@ -0,0 +1,22 @@
+import { makeStyles, tokens } from '@fluentui/react-components'
+
+import { mobileTouchTarget } from '@/styles/touchTargets'
+
+export const useScorerEvaluationDetailsStyles = makeStyles({
+  trigger: {
+    ...mobileTouchTarget,
+    color: tokens.colorBrandForegroundLink,
+  },
+  surface: {
+    display: 'flex',
+    flexDirection: 'column',
+    gap: tokens.spacingVerticalL,
+    width: '28rem',
+    maxWidth: `calc(100vw - ${tokens.spacingHorizontalXXL} - ${tokens.spacingHorizontalXXL})`,
+    maxHeight: '70vh',
+    overflowY: 'auto',
+    overflowWrap: 'anywhere',
+  },
+  heading: { margin: 0 },
+  description: { color: tokens.colorNeutralForeground2 },
+})
diff --git a/frontend/src/components/Scorers/ScorerEvaluationDetails.test.tsx b/frontend/src/components/Scorers/ScorerEvaluationDetails.test.tsx
new file mode 100644
index 0000000000..3d8619216b
--- /dev/null
+++ b/frontend/src/components/Scorers/ScorerEvaluationDetails.test.tsx
@@ -0,0 +1,68 @@
+import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { render, screen, within } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+
+import type { ScorerEvaluationMetrics } from '@/types'
+
+import ScorerEvaluationDetails from './ScorerEvaluationDetails'
+
+function TestWrapper({ children }: { children: React.ReactNode }) {
+  return <FluentProvider theme={webLightTheme}>{children}</FluentProvider>
+}
+
+describe('ScorerEvaluationDetails', () => {
+  it('should disclose complete binary metrics and extra keys by keyboard without confusing identities', async () => {
+    const user = userEvent.setup()
+    render(<TestWrapper><ScorerEvaluationDetails name="configured judge" scoreType="true_false"
+      metrics={{ accuracy: 0.93, accuracy_standard_error: 0.02, recall: 0, precision: 0.9, f1_score: 0.8,
+        num_responses: 100, num_human_raters: 0, custom_value: 'retained', average_score_time_seconds: 0 }}
+      evaluationIdentity={{ class_name: 'Judge', hash: 'behavioral-projection', eval_hash: 'evaluation-hash' }} /></TestWrapper>)
+    expect(screen.queryByRole('group', { name: 'Num responses' })).not.toBeInTheDocument()
+    const trigger = screen.getByRole('button', { name: 'Evaluation metrics for configured judge' })
+    trigger.focus()
+    await user.keyboard('{Enter}')
+    const dialog = screen.getByRole('dialog', { name: 'Scorer evaluation metrics' })
+    expect(within(dialog).getByRole('group', { name: 'Accuracy' })).toHaveTextContent('93.00%')
+    expect(within(dialog).getByRole('group', { name: 'Recall' })).toHaveTextContent('0.00%')
+    expect(within(dialog).getByRole('group', { name: 'Accuracy std error' })).toHaveTextContent('0.0200')
+    expect(within(dialog).getByRole('group', { name: 'Num responses' })).toHaveTextContent('100')
+    expect(within(dialog).getByRole('group', { name: 'Num human raters' })).toHaveTextContent('0')
+    expect(within(dialog).getByRole('group', { name: 'Custom value' })).toHaveTextContent('retained')
+    expect(within(dialog).getByRole('group', { name: 'Average score time' })).toHaveTextContent('Unavailable')
+    expect(dialog).toHaveTextContent('not an individual attack score or the scan success rate')
+    expect(within(dialog).getByRole('link', { name: 'About scorer metrics' })).toHaveAttribute(
+      'href', 'https://microsoft.github.io/PyRIT/latest/code/scoring/scorer-metrics/',
+    )
+    await user.click(within(dialog).getByRole('button', { name: 'Identity for Behavioral evaluation identity' }))
+    expect(within(dialog).getByRole('region', { name: 'Identity for Behavioral evaluation identity' })).toHaveTextContent('evaluation-hash')
+    await user.keyboard('{Escape}')
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
+    expect(trigger).toHaveFocus()
+  })
+
+  it('should show zero float-scale errors, agreement, extra sample counts and missing supplied values', async () => {
+    const user = userEvent.setup()
+    render(<TestWrapper><ScorerEvaluationDetails name="scale" scoreType="float_scale" metrics={{
+      mean_absolute_error: 0, mae_standard_error: 0.01, krippendorff_alpha_combined: 0.8,
+      num_responses: 25, custom_standard_error: null,
+    }} /></TestWrapper>)
+    await user.click(screen.getByRole('button', { name: 'Evaluation metrics for scale' }))
+    const dialog = screen.getByRole('dialog')
+    expect(within(dialog).getByRole('group', { name: 'Mean absolute error' })).toHaveTextContent('0.0000')
+    expect(within(dialog).getByRole('group', { name: 'Agreement (Krippendorff alpha)' })).toHaveTextContent('0.8000')
+    expect(within(dialog).getByRole('group', { name: 'Num responses' })).toHaveTextContent('25')
+    expect(within(dialog).getByRole('group', { name: 'Custom standard error' })).toHaveTextContent('Unavailable')
+    expect(within(dialog).queryByRole('group', { name: 'Accuracy' })).not.toBeInTheDocument()
+  })
+
+  it.each<ScorerEvaluationMetrics | null | undefined>([null, undefined, {}, { accuracy: null }])(
+    'should explain unavailable official evaluations for %p', async (metrics: ScorerEvaluationMetrics | null | undefined) => {
+      const user = userEvent.setup()
+      render(<TestWrapper><ScorerEvaluationDetails name="unevaluated" metrics={metrics} /></TestWrapper>)
+      await user.click(screen.getByRole('button', { name: 'Evaluation metrics for unevaluated' }))
+      expect(screen.getByRole('dialog')).toHaveTextContent('No official evaluation metrics are available')
+      expect(screen.getByRole('link', { name: 'About scorer metrics' })).toBeVisible()
+      expect(screen.queryByRole('group', { name: 'Accuracy' })).not.toBeInTheDocument()
+    },
+  )
+})
diff --git a/frontend/src/components/Scorers/ScorerEvaluationDetails.tsx b/frontend/src/components/Scorers/ScorerEvaluationDetails.tsx
new file mode 100644
index 0000000000..0470115bbb
--- /dev/null
+++ b/frontend/src/components/Scorers/ScorerEvaluationDetails.tsx
@@ -0,0 +1,57 @@
+import { useId } from 'react'
+
+import { Button, Link, Popover, PopoverSurface, PopoverTrigger, Text } from '@fluentui/react-components'
+
+import IdentityDisclosure from '@/components/Registry/IdentityDisclosure'
+import type { ComponentIdentifier, ScorerEvaluationMetrics } from '@/types'
+
+import ScorerMetricsDetails from './ScorerMetricsDetails'
+import { useScorerEvaluationDetailsStyles } from './ScorerEvaluationDetails.styles'
+
+const SCORER_METRICS_DOCUMENTATION_URL = 'https://microsoft.github.io/PyRIT/latest/code/scoring/scorer-metrics/'
+
+interface ScorerEvaluationDetailsProps {
+  readonly name: string
+  readonly metrics?: ScorerEvaluationMetrics | null
+  readonly scoreType?: string | null
+  readonly evaluationIdentity?: ComponentIdentifier | null
+  readonly recorded?: boolean
+}
+
+export default function ScorerEvaluationDetails({
+  name, metrics, scoreType, evaluationIdentity, recorded = false,
+}: ScorerEvaluationDetailsProps) {
+  const styles = useScorerEvaluationDetailsStyles()
+  const headingId = useId()
+  const hasMetrics = metrics && Object.values(metrics).some((value: ScorerEvaluationMetrics[string]) => value != null)
+  return (
+    <Popover withArrow trapFocus>
+      <PopoverTrigger disableButtonEnhancement>
+        <Button appearance="transparent" size="small" className={styles.trigger}
+          aria-label={`Evaluation metrics for ${name}`}>
+          Evaluation metrics
+        </Button>
+      </PopoverTrigger>
+      <PopoverSurface role="dialog" aria-labelledby={headingId} className={styles.surface}>
+        <Text as="h3" id={headingId} size={400} weight="semibold" className={styles.heading}>
+          Scorer evaluation metrics
+        </Text>
+        <Text className={styles.description}>
+          {recorded ? 'Quality of the recorded scorer configuration' : 'Quality of this scorer configuration'},
+          not an individual attack score or the scan success rate.
+        </Text>
+        {hasMetrics ? (
+          <ScorerMetricsDetails metrics={metrics} scoreType={scoreType} fallback="Unavailable" />
+        ) : (
+          <Text>No official evaluation metrics are available for this scorer configuration.</Text>
+        )}
+        {evaluationIdentity && (
+          <IdentityDisclosure name="Behavioral evaluation identity" identity={evaluationIdentity} />
+        )}
+        <Link href={SCORER_METRICS_DOCUMENTATION_URL} target="_blank" rel="noopener noreferrer">
+          About scorer metrics
+        </Link>
+      </PopoverSurface>
+    </Popover>
+  )
+}
diff --git a/frontend/src/components/Scorers/ScorerMetricsDetails.styles.ts b/frontend/src/components/Scorers/ScorerMetricsDetails.styles.ts
index 4d92c1e635..e808c6f571 100644
--- a/frontend/src/components/Scorers/ScorerMetricsDetails.styles.ts
+++ b/frontend/src/components/Scorers/ScorerMetricsDetails.styles.ts
@@ -1,6 +1,19 @@
 import { makeStyles, tokens } from '@fluentui/react-components'
 
 export const useScorerMetricsDetailsStyles = makeStyles({
+  metric: {
+    display: 'flex',
+    flexDirection: 'column',
+    gap: tokens.spacingVerticalXXS,
+    minWidth: 0,
+  },
+  label: {
+    color: tokens.colorNeutralForeground3,
+  },
+  value: {
+    overflowWrap: 'anywhere',
+    whiteSpace: 'pre-wrap',
+  },
   metrics: {
     display: 'grid',
     gap: `${tokens.spacingVerticalM} ${tokens.spacingHorizontalL}`,
diff --git a/frontend/src/components/AttackResults/ObjectiveScorerDetails.test.tsx b/frontend/src/components/Scorers/ScorerMetricsDetails.test.tsx
similarity index 74%
rename from frontend/src/components/AttackResults/ObjectiveScorerDetails.test.tsx
rename to frontend/src/components/Scorers/ScorerMetricsDetails.test.tsx
index 8f432014c2..7b6ede1a50 100644
--- a/frontend/src/components/AttackResults/ObjectiveScorerDetails.test.tsx
+++ b/frontend/src/components/Scorers/ScorerMetricsDetails.test.tsx
@@ -1,9 +1,9 @@
 import { FluentProvider, webLightTheme } from '@fluentui/react-components'
 import { render, screen, within } from '@testing-library/react'
 
-import type { ScenarioObjectiveScorer, ScenarioObjectiveScorerMetrics } from '@/types'
+import type { ScenarioObjectiveScorerMetrics } from '@/types'
 
-import ObjectiveScorerDetails from './ObjectiveScorerDetails'
+import ScorerMetricsDetails from './ScorerMetricsDetails'
 
 const TestWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
   <FluentProvider theme={webLightTheme}>{children}</FluentProvider>
@@ -12,17 +12,14 @@ const TestWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
 const PERCENT_METRIC_LABELS = ['Accuracy', 'Precision', 'Recall']
 
 function renderScorer(metrics: ScenarioObjectiveScorerMetrics | null): void {
-  const scorer: ScenarioObjectiveScorer = {
-    component_name: 'SelfAskTrueFalseScorer', parameters: {}, children: {}, metrics,
-  }
-  render(<TestWrapper><ObjectiveScorerDetails scorer={scorer} /></TestWrapper>)
+  render(<TestWrapper><ScorerMetricsDetails metrics={metrics && { ...metrics }} fallback="Unavailable" /></TestWrapper>)
 }
 
 function expectMetric(label: string, value: string): void {
   expect(within(screen.getByRole('group', { name: label })).getByText(value)).toBeInTheDocument()
 }
 
-describe('ObjectiveScorerDetails', () => {
+describe('ScorerMetricsDetails', () => {
   beforeEach(() => { jest.clearAllMocks() })
 
   it('should show accuracy, precision, and recall as percentages and keep F1 on its 0-to-1 scale', () => {
@@ -57,10 +54,4 @@ describe('ObjectiveScorerDetails', () => {
     expectMetric('Precision', 'Unavailable')
     expectMetric('Recall', 'Unavailable')
   })
-
-  it('should explain when no official evaluation exists', () => {
-    renderScorer(null)
-    expect(screen.getByText('Official evaluation has not been run for this scorer configuration.')).toBeInTheDocument()
-    expect(screen.queryByRole('group', { name: 'Accuracy' })).not.toBeInTheDocument()
-  })
 })
diff --git a/frontend/src/components/Scorers/ScorerMetricsDetails.tsx b/frontend/src/components/Scorers/ScorerMetricsDetails.tsx
index 8aeedae1d5..9b79d905ec 100644
--- a/frontend/src/components/Scorers/ScorerMetricsDetails.tsx
+++ b/frontend/src/components/Scorers/ScorerMetricsDetails.tsx
@@ -1,6 +1,5 @@
 import { Text } from '@fluentui/react-components'
 
-import { DetailMetric } from '@/components/AttackResults/ComponentIdentityDetails'
 import type { ScorerEvaluationMetrics } from '@/types'
 import { formatScorerMetric, scorerMetricLabel } from '@/utils/scorerPresentation'
 
@@ -20,8 +19,12 @@ export default function ScorerMetricsDetails({
   const full = scoreType === 'float_scale'
     ? ['mean_absolute_error', 'mae_standard_error', 'krippendorff_alpha_combined', 'average_score_time_seconds']
     : ['accuracy', 'accuracy_standard_error', 'f1_score', 'precision', 'recall', 'average_score_time_seconds']
-  const renderMetric = (name: string) => <DetailMetric key={name}
-    label={scorerMetricLabel(name)} value={formatScorerMetric(name, metrics[name], fallback)} />
+  const renderMetric = (name: string) => (
+    <div key={name} className={styles.metric} role="group" aria-label={scorerMetricLabel(name)}>
+      <Text size={200} className={styles.label}>{scorerMetricLabel(name)}</Text>
+      <Text weight="semibold" className={styles.value}>{formatScorerMetric(name, metrics[name], fallback)}</Text>
+    </div>
+  )
   return (
     <div className={styles.metrics}>
       {[...full, ...Object.keys(metrics).filter((name: string) => !full.includes(name))].map(renderMetric)}
diff --git a/frontend/src/hooks/useAttackFindings.test.tsx b/frontend/src/hooks/useAttackFindings.test.tsx
new file mode 100644
index 0000000000..7400e7f5be
--- /dev/null
+++ b/frontend/src/hooks/useAttackFindings.test.tsx
@@ -0,0 +1,72 @@
+import { act, renderHook, waitFor } from '@testing-library/react'
+
+import { attacksApi } from '@/services/api'
+import type { AttackFindingItem } from '@/types'
+
+import { useAttackFindings } from './useAttackFindings'
+
+jest.mock('@/services/api', () => ({ attacksApi: { getAttackFindings: jest.fn() } }))
+
+const FINDING = {
+  id: 'finding-1', operation_id: 'operation-1', title: 'Prompt leak', severity: 'high', description: '',
+  created_at: '2026-10-08T12:00:00Z', operation_name: 'Review', evidence_id: 'evidence-1',
+} as AttackFindingItem
+
+describe('useAttackFindings', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('should load the findings that link an attack', async () => {
+    jest.mocked(attacksApi.getAttackFindings).mockResolvedValue({ attack_result_id: 'attack-1', items: [FINDING] })
+    const { result } = renderHook(() => useAttackFindings('attack-1'))
+
+    expect(result.current.loading).toBe(true)
+    await waitFor(() => { expect(result.current.loading).toBe(false) })
+    expect(result.current.findings).toEqual([FINDING])
+    expect(result.current.error).toBeNull()
+    expect(attacksApi.getAttackFindings).toHaveBeenCalledWith('attack-1')
+  })
+
+  it('should not request findings without an attack', () => {
+    const { result } = renderHook(() => useAttackFindings(null))
+    expect(result.current).toMatchObject({ findings: [], loading: false, error: null })
+    expect(attacksApi.getAttackFindings).not.toHaveBeenCalled()
+  })
+
+  it('should keep findings visible while a refresh reloads them', async () => {
+    jest.mocked(attacksApi.getAttackFindings).mockResolvedValueOnce({ attack_result_id: 'attack-1', items: [FINDING] })
+    const { result } = renderHook(() => useAttackFindings('attack-1'))
+    await waitFor(() => { expect(result.current.loading).toBe(false) })
+    expect(result.current.findings).toEqual([FINDING])
+
+    let resolve: (value: { attack_result_id: string; items: AttackFindingItem[] }) => void = () => {}
+    jest.mocked(attacksApi.getAttackFindings).mockReturnValueOnce(new Promise((complete) => { resolve = complete }))
+    act(() => { result.current.refresh() })
+    expect(result.current.loading).toBe(true)
+    expect(result.current.findings).toEqual([FINDING])
+
+    await act(async () => { resolve({ attack_result_id: 'attack-1', items: [] }) })
+    expect(result.current.findings).toEqual([])
+    expect(attacksApi.getAttackFindings).toHaveBeenCalledTimes(2)
+  })
+
+  it('should not show another attack\'s findings after switching attacks', async () => {
+    jest.mocked(attacksApi.getAttackFindings).mockResolvedValueOnce({ attack_result_id: 'attack-1', items: [FINDING] })
+    const { result, rerender } = renderHook(({ id }: { id: string }) => useAttackFindings(id), { initialProps: { id: 'attack-1' } })
+    await waitFor(() => { expect(result.current.findings).toEqual([FINDING]) })
+
+    jest.mocked(attacksApi.getAttackFindings).mockReturnValueOnce(new Promise(() => {}))
+    rerender({ id: 'attack-2' })
+    expect(result.current.findings).toEqual([])
+    expect(result.current.loading).toBe(true)
+  })
+
+  it('should report a failed request', async () => {
+    jest.mocked(attacksApi.getAttackFindings).mockRejectedValue(new Error('Findings unavailable'))
+    const { result } = renderHook(() => useAttackFindings('attack-1'))
+    await waitFor(() => { expect(result.current.loading).toBe(false) })
+    expect(result.current.error).toBe('Findings unavailable')
+    expect(result.current.findings).toEqual([])
+  })
+})
diff --git a/frontend/src/hooks/useAttackFindings.ts b/frontend/src/hooks/useAttackFindings.ts
new file mode 100644
index 0000000000..fa022d591d
--- /dev/null
+++ b/frontend/src/hooks/useAttackFindings.ts
@@ -0,0 +1,51 @@
+import { useCallback, useEffect, useState } from 'react'
+
+import { attacksApi } from '@/services/api'
+import { toApiError } from '@/services/errors'
+import type { AttackFindingItem } from '@/types'
+
+export interface AttackFindingsState {
+  findings: AttackFindingItem[]
+  loading: boolean
+  error: string | null
+  refresh: () => void
+}
+
+interface LoadedFindings {
+  attackResultId: string
+  revision: number
+  findings: AttackFindingItem[]
+  error: string | null
+}
+
+/** Findings in any Operation that link this attack as evidence. Without an attack id, there are none. */
+export function useAttackFindings(attackResultId: string | null | undefined): AttackFindingsState {
+  const [revision, setRevision] = useState(0)
+  const [loaded, setLoaded] = useState<LoadedFindings | null>(null)
+
+  useEffect(() => {
+    if (!attackResultId) return
+    let ignore = false
+    attacksApi.getAttackFindings(attackResultId)
+      .then((response) => {
+        if (!ignore) setLoaded({ attackResultId, revision, findings: response.items, error: null })
+      })
+      .catch((cause: unknown) => {
+        if (!ignore) setLoaded({ attackResultId, revision, findings: [], error: toApiError(cause).detail })
+      })
+    return () => { ignore = true }
+  }, [attackResultId, revision])
+
+  const refresh = useCallback((): void => {
+    setRevision((current: number) => current + 1)
+  }, [])
+
+  // Keep the previous answer for the same attack while a refresh is in flight, so attached findings do not flicker.
+  const current = attackResultId && loaded?.attackResultId === attackResultId ? loaded : null
+  return {
+    findings: current?.findings ?? [],
+    loading: Boolean(attackResultId) && current?.revision !== revision,
+    error: current?.error ?? null,
+    refresh,
+  }
+}
diff --git a/frontend/src/hooks/useConversationMessages.test.ts b/frontend/src/hooks/useConversationMessages.test.ts
index d809f61aaa..c64e620784 100644
--- a/frontend/src/hooks/useConversationMessages.test.ts
+++ b/frontend/src/hooks/useConversationMessages.test.ts
@@ -55,6 +55,54 @@ describe('useConversationMessages', () => {
     ))
   })
 
+  it('should retain a long live window and split turn through saved paging while rejecting a late live response', async () => {
+    jest.mocked(backendMessagesToFrontend).mockImplementation(
+      jest.requireActual<typeof import('@/utils/messageMapper')>('@/utils/messageMapper').backendMessagesToFrontend,
+    )
+    const full: ConversationMessagesResponse = {
+      conversation_id: 'main', target_response_status: null,
+      messages: [{
+        role: 'assistant', turn_number: 1, created_at: '2026-01-01T00:00:00Z',
+        message_pieces: Array.from({ length: 122 }, (_value: unknown, index: number) => ({
+          id: `piece-${index}`, original_value: `Piece ${index}`, converted_value: `Piece ${index}`,
+          original_value_data_type: 'text', converted_value_data_type: 'text', scores: [], response_error: 'none',
+        })),
+      }],
+    }
+    const lateLive = deferred<ConversationMessagesResponse>()
+    const continuation = deferred<ConversationMessagesResponse>()
+    getMessages.mockResolvedValueOnce(full).mockReturnValueOnce(lateLive.promise).mockResolvedValueOnce({
+      ...full, messages: full.messages.map((message: BackendMessage) => ({ ...message, message_pieces: message.message_pieces.slice(0, 100) })),
+      pagination: { limit: 100, has_more: true, next_cursor: 'saved-next' }, partial_message_sequences: [1],
+    }).mockReturnValueOnce(continuation.promise)
+    const { result, rerender } = renderMessages()
+    await waitFor(() => { expect(result.current.messages[0]?.content).toContain('Piece 121') })
+    let refresh = Promise.resolve()
+    act(() => { refresh = result.current.loadConversation('attack', 'main') })
+    rerender({ messagePageSize: 100 })
+    await waitFor(() => { expect(getMessages).toHaveBeenLastCalledWith('attack', 'main', { limit: 100, cursor: 'saved-next' }) })
+    expect(result.current.messages[0].content).toContain('Piece 121')
+    expect(result.current.isTranscriptIncomplete).toBe(true)
+    await act(async () => {
+      continuation.resolve({
+        ...full, messages: full.messages.map((message: BackendMessage) => ({ ...message, message_pieces: message.message_pieces.slice(100) })),
+        pagination: { limit: 100, has_more: false, next_cursor: null }, partial_message_sequences: [],
+      })
+    })
+    expect(result.current.loadedPieceCount).toBe(122)
+    expect(result.current.isTranscriptIncomplete).toBe(false)
+    expect(result.current.messages[0].content).toContain('Piece 121')
+    expect(result.current.messages[0].isPartial).toBe(false)
+    await act(async () => {
+      lateLive.resolve({ ...full, messages: [{ ...full.messages[0], message_pieces: [{
+        ...full.messages[0].message_pieces[0], original_value: 'Stale live data', converted_value: 'Stale live data',
+      }] }] })
+      await refresh
+    })
+    expect(result.current.loadedPieceCount).toBe(122)
+    expect(result.current.messages[0].content).not.toContain('Stale live data')
+  })
+
   it('polls an injected saved-conversation reader without changing manual send ownership', async () => {
     jest.useFakeTimers()
     const readConversation = jest.fn().mockResolvedValue(transcript('main', [1]))
diff --git a/frontend/src/hooks/useConversationMessages.ts b/frontend/src/hooks/useConversationMessages.ts
index b9f779bae1..dcadd4a782 100644
--- a/frontend/src/hooks/useConversationMessages.ts
+++ b/frontend/src/hooks/useConversationMessages.ts
@@ -26,6 +26,12 @@ interface SavedTranscriptPage {
   consumedCursors: ReadonlySet<string>
 }
 
+interface LoadedFullTranscript {
+  readonly attackResultId: string | null
+  readonly conversationId: string
+  readonly response: ConversationMessagesResponse
+}
+
 function mergeTranscriptPage(
   previous: ConversationMessagesResponse | null, incoming: ConversationMessagesResponse, conversationId: string,
   cursor?: string, consumedCursors?: ReadonlySet<string>,
@@ -126,6 +132,7 @@ export function useConversationMessages({
   const [isLoadingMoreMessages, setIsLoadingMoreMessages] = useState(false)
   const [messageContinuationIssue, setMessageContinuationIssue] = useState<{ detail: string; restartRequired: boolean } | null>(null)
   const savedTranscriptPageRef = useRef<SavedTranscriptPage | null>(null)
+  const fullTranscriptRef = useRef<LoadedFullTranscript | null>(null)
   const loadedAttackResultIdRef = useRef<string | null>(null)
   const loadedConversationIdRef = useRef<string | null>(null)
   const viewedAttackRef = useRef(attackResultId)
@@ -201,6 +208,7 @@ export function useConversationMessages({
   }, [viewedConversationId, attackResultId, messagePageSize])
 
   const resetConversationMessages = useCallback((): void => {
+    fullTranscriptRef.current = null
     setMessages([])
     setLoadedConversationId(null)
     setLoadedAttackResultId(null)
@@ -235,10 +243,33 @@ export function useConversationMessages({
       }
       // Discard superseded loads and responses invalidated by a send.
       if (!isCurrentLoad()) { return }
-      const response = messagePageSize === undefined ? incoming : mergeTranscriptPage(null, incoming, convId)
+      let response = messagePageSize === undefined ? incoming : mergeTranscriptPage(null, incoming, convId)
+      const consumedCursors = new Set<string>()
+      const full = fullTranscriptRef.current
+      if (messagePageSize !== undefined && arId && full?.attackResultId === arId && full.conversationId === convId) {
+        const missing = new Set(full.response.messages.flatMap((message: BackendMessage) => message.message_pieces.map((piece: BackendMessagePiece) => piece.id)))
+        for (const message of response.messages) {
+          for (const piece of message.message_pieces) missing.delete(piece.id)
+        }
+        // Complete the already-visible live window before installing its saved paging state.
+        while (missing.size > 0 && response.pagination?.has_more) {
+          const cursor = response.pagination.next_cursor
+          if (!cursor) throw new Error('The saved transcript continuation is missing. Restart transcript loading.')
+          const next = await attacksApi.getMessages(arId, convId, { limit: messagePageSize, cursor })
+          if (!isCurrentLoad()) return
+          response = mergeTranscriptPage(response, next, convId, cursor, consumedCursors)
+          consumedCursors.add(cursor)
+          for (const message of next.messages) {
+            for (const piece of message.message_pieces) missing.delete(piece.id)
+          }
+        }
+      }
       setMessageContinuationIssue(null)
       if (messagePageSize !== undefined && arId) {
-        saveTranscriptPage({ attackResultId: arId, conversationId: convId, pageSize: messagePageSize, response, consumedCursors: new Set() })
+        saveTranscriptPage({ attackResultId: arId, conversationId: convId, pageSize: messagePageSize, response, consumedCursors })
+        fullTranscriptRef.current = null
+      } else {
+        fullTranscriptRef.current = { attackResultId: arId, conversationId: convId, response }
       }
       setConversationLoadIssue(
         findingEvidenceId && response.messages.length === 0 && !response.pagination?.has_more
diff --git a/frontend/src/hooks/useLiveAttackMetadata.test.tsx b/frontend/src/hooks/useLiveAttackMetadata.test.tsx
new file mode 100644
index 0000000000..d4bc4c7321
--- /dev/null
+++ b/frontend/src/hooks/useLiveAttackMetadata.test.tsx
@@ -0,0 +1,73 @@
+import { act, renderHook } from '@testing-library/react'
+
+import { attacksApi } from '@/services/api'
+import type { AttackMetadata } from '@/types'
+
+import { LIVE_ATTACK_POLL_INTERVAL_MS, useLiveAttackMetadata } from './useLiveAttackMetadata'
+
+jest.mock('@/services/api', () => ({ attacksApi: { getAttackMetadata: jest.fn() } }))
+
+const METADATA: AttackMetadata = {
+  attack_result_id: 'live', conversation_id: 'main', objective: 'Goal', labels: {}, execution_read_only: true,
+  in_progress: true, related_conversation_count: 0, last_response_message_piece_id: null,
+  selected_conversation_id: 'main', selected_conversation_valid: true,
+}
+
+async function advance(): Promise<void> {
+  await act(async () => { await jest.advanceTimersByTimeAsync(LIVE_ATTACK_POLL_INTERVAL_MS) })
+}
+
+describe('useLiveAttackMetadata', () => {
+  const onMetadata = jest.fn()
+  const onGone = jest.fn()
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.useFakeTimers()
+  })
+
+  afterEach(() => {
+    jest.useRealTimers()
+  })
+
+  it('should read until the attack is no longer in progress, retrying failed reads', async () => {
+    jest.mocked(attacksApi.getAttackMetadata)
+      .mockRejectedValueOnce({ isAxiosError: true, response: { status: 503, data: { detail: 'Busy' } } })
+      .mockResolvedValueOnce(METADATA)
+      .mockResolvedValueOnce({ ...METADATA, in_progress: false })
+    renderHook(() => useLiveAttackMetadata({ attackResultId: 'live', onMetadata, onGone }))
+    expect(attacksApi.getAttackMetadata).not.toHaveBeenCalled()
+    await advance()
+    expect(onMetadata).not.toHaveBeenCalled()
+    await advance()
+    expect(onMetadata).toHaveBeenLastCalledWith(METADATA)
+    await advance()
+    expect(onMetadata).toHaveBeenLastCalledWith({ ...METADATA, in_progress: false })
+    await advance()
+    expect(attacksApi.getAttackMetadata).toHaveBeenCalledTimes(3)
+    expect(attacksApi.getAttackMetadata).toHaveBeenCalledWith('live')
+    expect(onGone).not.toHaveBeenCalled()
+  })
+
+  it('should stop and report an attack that is neither running nor saved', async () => {
+    jest.mocked(attacksApi.getAttackMetadata).mockRejectedValue({ isAxiosError: true, response: { status: 404, data: { detail: 'Missing' } } })
+    renderHook(() => useLiveAttackMetadata({ attackResultId: 'live', onMetadata, onGone }))
+    await advance()
+    await advance()
+    expect(onGone).toHaveBeenCalledTimes(1)
+    expect(attacksApi.getAttackMetadata).toHaveBeenCalledTimes(1)
+  })
+
+  it('should not read without an attack or after it stops following', async () => {
+    jest.mocked(attacksApi.getAttackMetadata).mockResolvedValue(METADATA)
+    const view = renderHook(({ id }: { id: string | null }) => useLiveAttackMetadata({ attackResultId: id, onMetadata, onGone }),
+      { initialProps: { id: null as string | null } })
+    await advance()
+    expect(attacksApi.getAttackMetadata).not.toHaveBeenCalled()
+    view.rerender({ id: 'live' })
+    await advance()
+    view.rerender({ id: null })
+    await advance()
+    expect(attacksApi.getAttackMetadata).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/frontend/src/hooks/useLiveAttackMetadata.ts b/frontend/src/hooks/useLiveAttackMetadata.ts
new file mode 100644
index 0000000000..18cbd602c9
--- /dev/null
+++ b/frontend/src/hooks/useLiveAttackMetadata.ts
@@ -0,0 +1,55 @@
+import { useEffect, useRef } from 'react'
+
+import { SCENARIO_RUN_POLL_INTERVAL_MS } from '@/hooks/useScenarioRunProgress'
+import { attacksApi } from '@/services/api'
+import { toApiError } from '@/services/errors'
+import type { AttackMetadata } from '@/types'
+
+/** Running scan attacks refresh at the same pace as the scan they belong to. */
+export const LIVE_ATTACK_POLL_INTERVAL_MS = SCENARIO_RUN_POLL_INTERVAL_MS
+
+interface UseLiveAttackMetadataOptions {
+  /** The running attack to follow; null stops following. */
+  readonly attackResultId: string | null
+  /** Receives each read, including the first one that is no longer in progress. */
+  readonly onMetadata: (metadata: AttackMetadata) => void
+  /** The attack is neither running nor saved any more, such as after a cancelled scan. */
+  readonly onGone: () => void
+}
+
+/**
+ * Re-reads a running scan attack's metadata until a read says it is no longer in progress.
+ * A failed read keeps the current metadata and is retried on the next interval.
+ */
+export function useLiveAttackMetadata({ attackResultId, onMetadata, onGone }: UseLiveAttackMetadataOptions): void {
+  const callbacks = useRef({ onMetadata, onGone })
+  useEffect(() => {
+    callbacks.current = { onMetadata, onGone }
+  }, [onMetadata, onGone])
+
+  useEffect(() => {
+    if (!attackResultId) return
+    let active = true
+    let timer: ReturnType<typeof setTimeout>
+    const schedule = (): void => {
+      timer = setTimeout(() => { void read() }, LIVE_ATTACK_POLL_INTERVAL_MS)
+    }
+    const read = async (): Promise<void> => {
+      try {
+        const metadata = await attacksApi.getAttackMetadata(attackResultId)
+        if (!active) return
+        callbacks.current.onMetadata(metadata)
+        if (metadata.in_progress) schedule()
+      } catch (error: unknown) {
+        if (!active) return
+        if (toApiError(error).status === 404) callbacks.current.onGone()
+        else schedule()
+      }
+    }
+    schedule()
+    return () => {
+      active = false
+      clearTimeout(timer)
+    }
+  }, [attackResultId])
+}
diff --git a/frontend/src/hooks/useScenarioRunAttackDetails.ts b/frontend/src/hooks/useScenarioRunAttackDetails.ts
new file mode 100644
index 0000000000..481f4f50a9
--- /dev/null
+++ b/frontend/src/hooks/useScenarioRunAttackDetails.ts
@@ -0,0 +1,66 @@
+import { useMemo, useRef, useState } from 'react'
+
+import { useLocation, useNavigate } from 'react-router'
+
+import type { ScenarioActiveConversation, ScenarioHierarchyNode, ScenarioProgressResult } from '@/types'
+import { scenarioRunAttackRoutePath, scenarioRunRoutePath } from '@/utils/routeParams'
+
+export type ScenarioRunAttempt = ScenarioProgressResult | ScenarioHierarchyNode | ScenarioActiveConversation
+
+interface UseScenarioRunAttackDetailsOptions {
+  readonly scenarioResultId: string
+  /** The attack named by the route, if any. */
+  readonly attackResultId: string | null
+  readonly results: readonly ScenarioProgressResult[]
+  readonly activeConversations: readonly ScenarioActiveConversation[]
+  /** Receives focus on close when the control that opened the details is gone. */
+  readonly fallbackFocus: () => HTMLElement | null
+}
+
+export interface ScenarioRunAttackDetails {
+  readonly selectedAttempt: ScenarioRunAttempt | null
+  /** The hierarchy node the details were opened from, which may carry the objective. */
+  readonly hierarchySelection: ScenarioHierarchyNode | null
+  readonly open: (attempt: ScenarioRunAttempt, trigger: HTMLElement | null) => void
+  readonly close: () => void
+}
+
+/** The attack shown in the run's details dialog, addressed by route so it survives reloads and back navigation. */
+export function useScenarioRunAttackDetails({
+  scenarioResultId,
+  attackResultId,
+  results,
+  activeConversations,
+  fallbackFocus,
+}: UseScenarioRunAttackDetailsOptions): ScenarioRunAttackDetails {
+  const navigate = useNavigate()
+  const location = useLocation()
+  const trigger = useRef<HTMLElement | null>(null)
+  const [hierarchySelection, setHierarchySelection] = useState<ScenarioHierarchyNode | null>(null)
+
+  // A hierarchy node can be opened before the paged progress feed has delivered it.
+  const selectedAttempt = useMemo<ScenarioRunAttempt | null>(
+    () =>
+      results.find((attempt) => attempt.attack_result_id === attackResultId) ??
+      activeConversations.find((conversation) => conversation.attack_result_id === attackResultId) ??
+      (hierarchySelection?.attack_result_id === attackResultId ? hierarchySelection : null),
+    [attackResultId, results, activeConversations, hierarchySelection],
+  )
+
+  return {
+    selectedAttempt,
+    hierarchySelection,
+    open: (attempt: ScenarioRunAttempt, opener: HTMLElement | null): void => {
+      trigger.current = opener
+      setHierarchySelection('result_role' in attempt ? attempt : null)
+      navigate(scenarioRunAttackRoutePath(scenarioResultId, attempt.attack_result_id), { state: location.state })
+    },
+    close: (): void => {
+      navigate(scenarioRunRoutePath(scenarioResultId), { replace: true, state: location.state })
+      requestAnimationFrame(() => {
+        const focusTarget = trigger.current?.isConnected ? trigger.current : fallbackFocus()
+        focusTarget?.focus()
+      })
+    },
+  }
+}
diff --git a/frontend/src/hooks/useScenarioRunControls.ts b/frontend/src/hooks/useScenarioRunControls.ts
new file mode 100644
index 0000000000..4dc257c21c
--- /dev/null
+++ b/frontend/src/hooks/useScenarioRunControls.ts
@@ -0,0 +1,118 @@
+import { useEffect, useRef, useState } from 'react'
+
+import { useLocation, useNavigate } from 'react-router'
+
+import { useScenarioRunResume } from '@/hooks/useScenarioRunResume'
+import { scenariosApi } from '@/services/api'
+import { toApiError } from '@/services/errors'
+import type { ScenarioRunSummary } from '@/types'
+import { scenarioRerunRoutePath } from '@/utils/routeParams'
+
+interface UseScenarioRunControlsOptions {
+  readonly scenarioResultId: string
+  readonly applyRunSummary: (run: ScenarioRunSummary) => void
+  /** Reload run progress after a resume that did not start. */
+  readonly retry: () => void
+  readonly refreshQueue: () => void
+  /** The run's own error, which the page already shows with the run. */
+  readonly runError?: string | null
+}
+
+export interface ScenarioRunControls {
+  readonly rerunPending: boolean
+  readonly rerun: () => void
+  readonly cancelOpen: boolean
+  readonly setCancelOpen: (open: boolean) => void
+  readonly cancelling: boolean
+  readonly cancelError: string | null
+  readonly cancel: () => void
+  readonly resumePending: boolean
+  readonly resume: () => void
+  /** The rerun or resume failure to show beside the controls. */
+  readonly controlError: string | null
+}
+
+/** Rerun, cancel, and resume one scan, keeping each request's pending state and errors. */
+export function useScenarioRunControls({
+  scenarioResultId,
+  applyRunSummary,
+  retry,
+  refreshQueue,
+  runError,
+}: UseScenarioRunControlsOptions): ScenarioRunControls {
+  const navigate = useNavigate()
+  const location = useLocation()
+  const [cancelOpen, setCancelOpen] = useState(false)
+  const [cancelling, setCancelling] = useState(false)
+  const [cancelError, setCancelError] = useState<string | null>(null)
+  const [rerunPending, setRerunPending] = useState(false)
+  const [rerunError, setRerunError] = useState<string | null>(null)
+  const rerunRequest = useRef<AbortController | null>(null)
+  const resumeRequest = useScenarioRunResume({
+    onResumed: applyRunSummary,
+    onRefresh: (succeeded: boolean): void => {
+      refreshQueue()
+      if (!succeeded) retry()
+    },
+  })
+
+  // Leaving the run, or opening an attempt on it, abandons a rerun still loading its configuration.
+  useEffect(() => () => {
+    rerunRequest.current?.abort()
+    rerunRequest.current = null
+  }, [location.pathname])
+
+  async function requestRerun(): Promise<void> {
+    rerunRequest.current?.abort()
+    const controller = new AbortController()
+    rerunRequest.current = controller
+    setRerunPending(true)
+    setRerunError(null)
+    try {
+      const request = await scenariosApi.getLaunchConfiguration(scenarioResultId, controller.signal)
+      if (rerunRequest.current !== controller || controller.signal.aborted) return
+      navigate(scenarioRerunRoutePath(request.scenario_name, scenarioResultId))
+    } catch (error: unknown) {
+      if (rerunRequest.current !== controller || controller.signal.aborted) return
+      setRerunError(toApiError(error).detail)
+    } finally {
+      if (rerunRequest.current === controller) {
+        rerunRequest.current = null
+        setRerunPending(false)
+      }
+    }
+  }
+
+  async function requestCancel(): Promise<void> {
+    setCancelling(true)
+    setCancelError(null)
+    try {
+      applyRunSummary(await scenariosApi.cancelRun(scenarioResultId))
+      setCancelOpen(false)
+    } catch (error: unknown) {
+      setCancelError(toApiError(error).detail)
+    } finally {
+      setCancelling(false)
+    }
+  }
+
+  return {
+    rerunPending,
+    rerun: (): void => { void requestRerun() },
+    cancelOpen,
+    setCancelOpen: (open: boolean): void => {
+      if (open) setCancelError(null)
+      if (!cancelling) setCancelOpen(open)
+    },
+    cancelling,
+    cancelError,
+    cancel: (): void => { void requestCancel() },
+    resumePending: resumeRequest.pendingRunId !== null,
+    resume: (): void => {
+      setRerunError(null)
+      resumeRequest.requestResume(scenarioResultId)
+    },
+    controlError: rerunError ?? resumeRequest.error
+      ?? (resumeRequest.executionError !== runError ? resumeRequest.executionError : null),
+  }
+}
diff --git a/frontend/src/services/recordedScanConversations.test.ts b/frontend/src/services/recordedScanConversations.test.ts
new file mode 100644
index 0000000000..df2e774533
--- /dev/null
+++ b/frontend/src/services/recordedScanConversations.test.ts
@@ -0,0 +1,51 @@
+import { scenariosApi } from './api'
+import { readRecordedScanConversations } from './recordedScanConversations'
+
+jest.mock('./api', () => ({ scenariosApi: { getRunProgress: jest.fn(), getRunConversation: jest.fn() } }))
+
+const record = {
+  attack_result_id: 'interrupted', conversation_id: 'recorded', atomic_attack_name: 'direct',
+  objective: 'Stored objective', started_at: '2026-01-01T00:00:00Z', seed_identifiers: [],
+}
+const progress = {
+  run: { scenario_result_id: 'scan', scenario_name: 'Scenario', scenario_version: 1,
+    status: 'CANCELLED' as const, created_at: '2026-01-01T00:00:00Z' },
+  plan: null, results: [], has_more: false, plan_complete: true, recorded_conversations: [record],
+  summary: { overall: { completed: 0, planned: 1, succeeded: 0, success_percentage: null, errors: 0, retries: 0 },
+    techniques: [], seed_groups: [], atomic_groups: [] },
+}
+
+describe('readRecordedScanConversations', () => {
+  beforeEach(() => {
+    jest.resetAllMocks()
+    jest.mocked(scenariosApi.getRunProgress).mockResolvedValue(progress)
+    jest.mocked(scenariosApi.getRunConversation).mockResolvedValue({ conversation_id: 'recorded', messages: [], target_response_status: null })
+  })
+
+  it('should verify SDK run, attack and selected conversation ownership without inventing results', async () => {
+    jest.mocked(scenariosApi.getRunProgress).mockResolvedValue({
+      ...progress, recorded_conversations: [record, record, { ...record, conversation_id: 'another-branch' }],
+    })
+    expect(await readRecordedScanConversations('scan', 'interrupted', 'recorded')).toEqual([
+      record, { ...record, conversation_id: 'another-branch' },
+    ])
+    expect(scenariosApi.getRunConversation).toHaveBeenCalledWith('scan', 'recorded')
+    expect(progress.results).toEqual([])
+    expect(progress.summary.overall.completed).toBe(0)
+  })
+
+  it.each([['unrelated-attack', 'recorded'], ['interrupted', 'unrelated-conversation']])(
+    'should reject unrelated ownership %s/%s', async (attackId: string, conversationId: string) => {
+      expect(await readRecordedScanConversations('scan', attackId, conversationId)).toBeNull()
+      expect(scenariosApi.getRunConversation).not.toHaveBeenCalled()
+    },
+  )
+
+  it('should reject a mismatched run response and propagate scoped read failures rather than showing empty evidence', async () => {
+    jest.mocked(scenariosApi.getRunProgress).mockResolvedValueOnce({ ...progress, run: { ...progress.run, scenario_result_id: 'other' } })
+    await expect(readRecordedScanConversations('scan', 'interrupted', 'recorded')).rejects.toThrow('different scan')
+    const unavailable = new Error('Stored conversation is unavailable')
+    jest.mocked(scenariosApi.getRunConversation).mockRejectedValueOnce(unavailable)
+    await expect(readRecordedScanConversations('scan', 'interrupted', 'recorded')).rejects.toBe(unavailable)
+  })
+})
diff --git a/frontend/src/services/recordedScanConversations.ts b/frontend/src/services/recordedScanConversations.ts
new file mode 100644
index 0000000000..f2f9e4c542
--- /dev/null
+++ b/frontend/src/services/recordedScanConversations.ts
@@ -0,0 +1,18 @@
+import type { ScenarioActiveConversation } from '@/types'
+
+import { scenariosApi } from './api'
+
+/** Resolve SDK-recorded ownership without creating an attack result or inferring an outcome. */
+export async function readRecordedScanConversations(
+  scenarioResultId: string, attackResultId: string, conversationId: string,
+): Promise<ScenarioActiveConversation[] | null> {
+  const progress = await scenariosApi.getRunProgress(scenarioResultId)
+  if (progress.run.scenario_result_id !== scenarioResultId) {
+    throw new Error('The server returned a different scan while loading recorded conversation evidence.')
+  }
+  const records = (progress.recorded_conversations ?? []).filter((record: ScenarioActiveConversation) => record.attack_result_id === attackResultId)
+  if (!records.some((record: ScenarioActiveConversation) => record.conversation_id === conversationId)) return null
+  // The scoped read also verifies stored conversation metadata against the SDK-owned run provenance.
+  await scenariosApi.getRunConversation(scenarioResultId, conversationId)
+  return [...new Map(records.map((record: ScenarioActiveConversation) => [record.conversation_id, record])).values()]
+}
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 3f3331a30f..9a3bb923b8 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -842,6 +842,9 @@ export type AttackTargetResolutionStatus =
 
 export type AttackOutcome = 'undetermined' | 'success' | 'failure' | 'error'
 
+/** An attack's saved outcome, or where it is before one exists. */
+export type AttackDisplayOutcome = AttackOutcome | 'in_progress' | 'preparing'
+
 // Wire contracts from pyrit.models.analytics. The SDK selects and counts the cohort.
 export type AttackAnalyticsDimensionName =
   | 'operation'
@@ -1246,6 +1249,20 @@ export interface DisplayScore extends BackendScore {
   sourceLabel: string
 }
 
+/**
+ * The fields a score popover shows, independent of where the score was recorded,
+ * so scan results do not need to fabricate a message-piece score.
+ */
+export interface ScoreSummary {
+  scorer: string
+  scoreType: string
+  value?: string | null
+  status?: string
+  rationale?: string | null
+  categories?: string[] | null
+  isObjective?: boolean
+}
+
 export interface BackendMessagePiece {
   id: string
   sequence?: number
@@ -1410,6 +1427,20 @@ export interface AttackConversationsResponse {
   total_count?: number | null
 }
 
+/** Read-only display references may lack saved-result counts and a main conversation. */
+export interface ConversationReferenceView extends Omit<ConversationSummary, 'message_count'> {
+  message_count: number | null
+}
+
+export interface AttackConversationReferencesView extends Omit<AttackConversationsResponse, 'main_conversation_id' | 'conversations'> {
+  main_conversation_id: string | null
+  conversations: ConversationReferenceView[]
+}
+
+export type ReadAttackConversationReferences = (
+  attackResultId: string, params?: ConversationPageParams,
+) => Promise<AttackConversationReferencesView>
+
 
 export interface CreateConversationRequest {
   source_conversation_id?: string
@@ -2272,6 +2303,8 @@ export interface PairedOutcomeDetailPage {
 }
 
 export interface ScenarioRunPlanAtomicGroup {
+  /** Absent in legacy plans, whose topology is unknown. */
+  is_compound?: boolean | null
   kind?: 'baseline' | 'attack' | 'adaptive' | 'unknown' | null
   id: string
   atomic_attack_name: string
diff --git a/frontend/src/utils/routeParams.ts b/frontend/src/utils/routeParams.ts
index ad84cf5e55..64afe9c6e3 100644
--- a/frontend/src/utils/routeParams.ts
+++ b/frontend/src/utils/routeParams.ts
@@ -68,10 +68,6 @@ export function scenarioRunAttackRoutePath(scenarioResultId: string, attackResul
   return `${scenarioRunRoutePath(scenarioResultId)}/${encodeURIComponent(attackResultId)}`
 }
 
-export function scenarioConversationRoutePath(scenarioResultId: string, conversationId: string): string {
-  return `${scenarioRunRoutePath(scenarioResultId)}/conversations/${encodeURIComponent(conversationId)}`
-}
-
 export function scenarioRerunRoutePath(scenarioName: string, scenarioResultId: string): string {
   return `/scanner/launch/${encodeURIComponent(scenarioName)}?rerun=${encodeURIComponent(scenarioResultId)}`
 }
diff --git a/frontend/src/utils/scenarioRunProgress.ts b/frontend/src/utils/scenarioRunProgress.ts
index ff3c59fa24..72123a74d6 100644
--- a/frontend/src/utils/scenarioRunProgress.ts
+++ b/frontend/src/utils/scenarioRunProgress.ts
@@ -180,7 +180,10 @@ export function getEtaMilliseconds(
   return Number.isFinite(estimate) && estimate >= 0 ? estimate : null
 }
 
-function compareAttempts(left: ScenarioProgressResult, right: ScenarioProgressResult): number {
+export function compareAttempts(
+  left: Pick<ScenarioProgressResult, 'timestamp' | 'attack_result_id'>,
+  right: Pick<ScenarioProgressResult, 'timestamp' | 'attack_result_id'>,
+): number {
   const timestampDifference = Date.parse(left.timestamp) - Date.parse(right.timestamp)
   if (Number.isFinite(timestampDifference) && timestampDifference !== 0) {
     return timestampDifference
diff --git a/frontend/src/utils/scoreSummary.test.ts b/frontend/src/utils/scoreSummary.test.ts
new file mode 100644
index 0000000000..fc01d0b0ea
--- /dev/null
+++ b/frontend/src/utils/scoreSummary.test.ts
@@ -0,0 +1,34 @@
+import type { BackendScore, ScenarioProgressScore } from '@/types'
+
+import { scoreSummaryFromBackendScore, scoreSummaryFromProgressScore, scoreSummaryValue } from './scoreSummary'
+
+describe('scoreSummary', () => {
+  it('maps a message-piece score without losing its role', () => {
+    const score: BackendScore = {
+      id: 'score-1', message_piece_id: 'piece-1', scorer_type: 'Judge', score_type: 'true_false',
+      score_value: 'false', status: 'complete', is_objective_score: false, score_category: ['harm'],
+      score_rationale: 'Refused.', timestamp: '2026-01-01T00:00:00Z',
+    }
+    expect(scoreSummaryFromBackendScore(score)).toEqual({
+      scorer: 'Judge', scoreType: 'true_false', value: 'false', status: 'complete',
+      rationale: 'Refused.', categories: ['harm'], isObjective: false,
+    })
+  })
+
+  it('treats a scan result score as the objective score', () => {
+    const score: ScenarioProgressScore = {
+      scorer_name: 'objective', score_type: 'true_false', status: 'complete', score_value: 'true',
+      score_rationale: 'Met.', score_category: ['jailbreak'],
+    }
+    expect(scoreSummaryFromProgressScore(score)).toEqual({
+      scorer: 'objective', scoreType: 'true_false', value: 'true', status: 'complete',
+      rationale: 'Met.', categories: ['jailbreak'], isObjective: true,
+    })
+  })
+
+  it('names the status of a score without a value', () => {
+    expect(scoreSummaryValue({ scorer: 'Judge', scoreType: 'true_false', value: 'true', status: 'complete' })).toBe('true')
+    expect(scoreSummaryValue({ scorer: 'Judge', scoreType: 'true_false', value: null, status: 'undetermined' })).toBe('undetermined')
+    expect(scoreSummaryValue({ scorer: 'Judge', scoreType: 'true_false' })).toBe('')
+  })
+})
diff --git a/frontend/src/utils/scoreSummary.ts b/frontend/src/utils/scoreSummary.ts
new file mode 100644
index 0000000000..342eb674e4
--- /dev/null
+++ b/frontend/src/utils/scoreSummary.ts
@@ -0,0 +1,31 @@
+import type { BackendScore, ScenarioProgressScore, ScoreSummary } from '@/types'
+
+export function scoreSummaryFromBackendScore(score: BackendScore): ScoreSummary {
+  return {
+    scorer: score.scorer_type,
+    scoreType: score.score_type,
+    value: score.score_value,
+    status: score.status,
+    rationale: score.score_rationale,
+    categories: score.score_category,
+    isObjective: score.is_objective_score,
+  }
+}
+
+/** A scan result's score is the attack's objective score. */
+export function scoreSummaryFromProgressScore(score: ScenarioProgressScore): ScoreSummary {
+  return {
+    scorer: score.scorer_name,
+    scoreType: score.score_type,
+    value: score.score_value,
+    status: score.status,
+    rationale: score.score_rationale,
+    categories: score.score_category,
+    isObjective: true,
+  }
+}
+
+/** An undetermined score has no value, so name its status instead. */
+export function scoreSummaryValue(score: ScoreSummary): string {
+  return score.value ?? score.status ?? ''
+}
diff --git a/pyrit/backend/README.md b/pyrit/backend/README.md
index 444cd2be87..0e3630fe40 100644
--- a/pyrit/backend/README.md
+++ b/pyrit/backend/README.md
@@ -500,10 +500,10 @@ not additional results.
 Available flat execution rows remain usable while relationships load or if the
 hierarchy request fails, with an explicit loading/error notice.
 
-Clicking a result with a main conversation opens the existing chat view and
-preserves scenario-run provenance for its return breadcrumb. Conversationless
-compound results expand their children instead. A separate Details action reuses
-the existing metadata dialog. Hierarchy requests do not load transcript bodies;
+Clicking a result row or pressing Enter on it opens the attack details dialog.
+An explicit expansion button shows a compound result's saved children. The separate
+Conversation link opens Chat and preserves scenario-run provenance for its return
+breadcrumb. Hierarchy requests do not load transcript bodies;
 the Chat viewer loads saved evidence through the bounded conversation reads above.
 
 `GET /api/scenarios/runs/{scenario_result_id}/hierarchy?max_nodes=1000` returns a
diff --git a/pyrit/executor/attack/compound/sequential_attack.py b/pyrit/executor/attack/compound/sequential_attack.py
index 8ea3423ace..5a281f7c37 100644
--- a/pyrit/executor/attack/compound/sequential_attack.py
+++ b/pyrit/executor/attack/compound/sequential_attack.py
@@ -215,6 +215,7 @@ class SequentialAttack(AttackStrategy[AttackContext[AttackParameters], Sequentia
     FIXED_PARAMS_TYPE = AttackParameters.excluding("next_message", "prepended_conversation")
 
     RESULT_ROLE: ClassVar[AttackResultRole] = AttackResultRole.ORCHESTRATION
+    IS_COMPOUND: ClassVar[bool] = True
 
     CHILD_ATTACK_RESULT_IDS_KEY: str = "child_attack_result_ids"
     """Metadata key under which the per-child-attack result IDs are stored."""
diff --git a/pyrit/executor/attack/core/attack_strategy.py b/pyrit/executor/attack/core/attack_strategy.py
index e43dd2b462..5c3a7703cb 100644
--- a/pyrit/executor/attack/core/attack_strategy.py
+++ b/pyrit/executor/attack/core/attack_strategy.py
@@ -746,6 +746,9 @@ class AttackStrategy(Strategy[AttackStrategyContextT, AttackStrategyResultT], Id
     #: No scoring configuration alone does not imply delegation.
     DELEGATES_SCORING: ClassVar[bool] = False
 
+    #: Whether this strategy executes child attacks, independent of result attribution.
+    IS_COMPOUND: ClassVar[bool] = False
+
     #: What this strategy's persisted results represent. Compound attacks that only coordinate
     #: child attacks, and never call the objective target themselves, set ``ORCHESTRATION``.
     RESULT_ROLE: ClassVar[AttackResultRole] = AttackResultRole.TARGET_FACING
diff --git a/pyrit/models/scenario_progress.py b/pyrit/models/scenario_progress.py
index 57d3006a6e..f75f637202 100644
--- a/pyrit/models/scenario_progress.py
+++ b/pyrit/models/scenario_progress.py
@@ -78,6 +78,8 @@ class ScenarioRunPlanAtomicGroup(BaseModel):
     #: None for plans persisted before kinds were recorded, so those plans round-trip unchanged.
     kind: ScenarioRunPlanGroupKind | None = None
     selected_technique_eval_hashes: list[str] | None = Field(default=None, min_length=1)
+    #: Unknown for legacy plans; saved attempts and result roles cannot establish topology.
+    is_compound: bool | None = None
 
 
 class ScenarioRunPlan(BaseModel):
diff --git a/pyrit/scenario/core/scenario.py b/pyrit/scenario/core/scenario.py
index 0c4da608af..22d2fa250b 100644
--- a/pyrit/scenario/core/scenario.py
+++ b/pyrit/scenario/core/scenario.py
@@ -1736,6 +1736,7 @@ def _build_run_plan(self) -> ScenarioRunPlan:
                     description=technique.description if technique else None,
                     tags=sorted(technique.tags) if technique else [],
                     kind=atomic_attack.group_kind,
+                    is_compound=atomic_attack.attack_technique.attack.IS_COMPOUND,
                 )
             )
         return ScenarioRunPlan(
diff --git a/tests/unit/models/test_scenario_progress.py b/tests/unit/models/test_scenario_progress.py
index 2ee15f203b..b7a9b7efea 100644
--- a/tests/unit/models/test_scenario_progress.py
+++ b/tests/unit/models/test_scenario_progress.py
@@ -60,10 +60,19 @@ def test_run_plan_without_adaptive_choices_round_trips_unchanged() -> None:
     payload = plan.model_dump(mode="json", exclude_none=True)
 
     assert "selected_technique_eval_hashes" not in payload["atomic_groups"][0]
+    assert "is_compound" not in payload["atomic_groups"][0]
     restored = ScenarioRunPlan.model_validate(payload)
     assert restored.model_dump(mode="json", exclude_none=True) == payload
 
 
+@pytest.mark.parametrize("is_compound", [False, True])
+def test_run_plan_preserves_known_compound_capability(is_compound: bool) -> None:
+    group = _group().model_copy(update={"is_compound": is_compound})
+    plan = ScenarioRunPlan(atomic_groups=[group], seed_groups=[_seed()])
+    restored = ScenarioRunPlan.model_validate_json(plan.model_dump_json(exclude_none=True))
+    assert restored.atomic_groups[0].is_compound is is_compound
+
+
 def test_run_plan_rejects_empty_adaptive_choices() -> None:
     payload = _group().model_dump()
     payload["selected_technique_eval_hashes"] = []
diff --git a/tests/unit/scenario/benchmark/test_adversarial.py b/tests/unit/scenario/benchmark/test_adversarial.py
index 61c097b3c2..79079e13a8 100644
--- a/tests/unit/scenario/benchmark/test_adversarial.py
+++ b/tests/unit/scenario/benchmark/test_adversarial.py
@@ -213,6 +213,7 @@ def _register_mock_factory(*, name: str, tags: list[str] | None = None, seed_tec
     factory.requirements = TechniqueRequirements()
     technique_instance = MagicMock(spec=AttackTechnique)
     technique_instance.attack = MagicMock(spec=AttackStrategy)
+    technique_instance.attack.IS_COMPOUND = False
     technique_instance.seed_technique = seed_technique
     technique_instance.requirements = factory.requirements
     technique_instance.get_identifier.return_value = ComponentIdentifier(
@@ -2202,6 +2203,7 @@ def _make_exact_cached_result(
 
 def _make_cache_reuse_candidate(*, seed_groups: list[AttackSeedGroup]) -> MagicMock:
     candidate = MagicMock(spec=AtomicAttack)
+    candidate.attack_technique.attack.IS_COMPOUND = False
     candidate.atomic_attack_name = "attack_a"
     candidate.display_group = "adv_target"
     candidate.technique_name = None
@@ -2499,6 +2501,7 @@ async def test_all_cached_scenario_completes_from_persisted_copy(self, sqlite_in
         bench._memory_labels = {"pipeline_build_id": "42"}
         bench._precomputed_cached_results = {"attack_a": [source_result]}
         candidate = MagicMock(spec=AtomicAttack)
+        candidate.attack_technique.attack.IS_COMPOUND = False
         candidate.atomic_attack_name = "attack_a"
         candidate.technique_eval_hash = "technique-hash"
         candidate.seed_groups = [AttackSeedGroup(seeds=[SeedObjective(value="objective")])]
diff --git a/tests/unit/scenario/core/test_scenario.py b/tests/unit/scenario/core/test_scenario.py
index 16056ea663..aba6c4ddae 100644
--- a/tests/unit/scenario/core/test_scenario.py
+++ b/tests/unit/scenario/core/test_scenario.py
@@ -18,7 +18,14 @@
 from pyrit.analytics import compute_scenario_statistics
 from pyrit.datasets import SeedDatasetProvider
 from pyrit.exceptions import ScenarioRunInProgressException
-from pyrit.executor.attack import AttackExecutorResult, AttackStrategy, PromptSendingAttack, RedTeamingAttack
+from pyrit.executor.attack import (
+    AttackExecutorResult,
+    AttackStrategy,
+    PromptSendingAttack,
+    RedTeamingAttack,
+    SequentialAttack,
+    SequentialChildAttack,
+)
 from pyrit.memory import CentralMemory, MemoryInterface
 from pyrit.models import (
     SCENARIO_RUN_PLAN_METADATA_KEY,
@@ -78,6 +85,7 @@ async def save_attack_results_to_memory_async(attack_results):
 def _make_identifiable_mock_attack() -> MagicMock:
     """Create a mock attack with a valid canonical identifier for run-plan construction."""
     attack = MagicMock(spec=AttackStrategy)
+    attack.IS_COMPOUND = False
     attack.get_identifier.return_value = ComponentIdentifier(
         class_name="MockAttack",
         class_module="tests.unit.scenario.core.test_scenario",
@@ -130,6 +138,7 @@ def _make_mock_atomic_attacks(count: int = 6):
     mock_attack.get_attack_scoring_config.return_value = MagicMock()
     for i in range(count):
         run = MagicMock(spec=AtomicAttack)
+        run.attack_technique.attack.IS_COMPOUND = False
         run.group_kind = ScenarioRunPlanGroupKind.ATTACK
         run.seed_group_adaptations = {}
         run.atomic_attack_name = f"attack_run_{i}"
@@ -159,6 +168,7 @@ def mock_atomic_attacks():
     mock_attack.get_attack_scoring_config.return_value = MagicMock()
 
     run1 = MagicMock(spec=AtomicAttack)
+    run1.attack_technique.attack.IS_COMPOUND = False
     run1.group_kind = ScenarioRunPlanGroupKind.ATTACK
     run1.seed_group_adaptations = {}
     run1.atomic_attack_name = "attack_run_1"
@@ -169,6 +179,7 @@ def mock_atomic_attacks():
     type(run1).objectives = PropertyMock(return_value=["objective1"])
 
     run2 = MagicMock(spec=AtomicAttack)
+    run2.attack_technique.attack.IS_COMPOUND = False
     run2.group_kind = ScenarioRunPlanGroupKind.ATTACK
     run2.seed_group_adaptations = {}
     run2.atomic_attack_name = "attack_run_2"
@@ -179,6 +190,7 @@ def mock_atomic_attacks():
     type(run2).objectives = PropertyMock(return_value=["objective2"])
 
     run3 = MagicMock(spec=AtomicAttack)
+    run3.attack_technique.attack.IS_COMPOUND = False
     run3.group_kind = ScenarioRunPlanGroupKind.ATTACK
     run3.seed_group_adaptations = {}
     run3.atomic_attack_name = "attack_run_3"
@@ -697,6 +709,36 @@ def test_init_with_empty_attack_techniques(self, mock_objective_target):
 class TestScenarioInitialization2:
     """Tests for Scenario initialize_async method."""
 
+    @pytest.mark.parametrize("compound", [False, True])
+    async def test_run_plan_records_strategy_topology_and_preserves_it_on_resume(
+        self, mock_objective_target, compound: bool
+    ) -> None:
+        seed = AttackSeedGroup(seeds=[SeedObjective(value="objective")])
+        strategy = PromptSendingAttack(objective_target=mock_objective_target)
+        if compound:
+            strategy = SequentialAttack(
+                objective_target=mock_objective_target,
+                child_attacks=[SequentialChildAttack(strategy=strategy, seed_group=seed)],
+            )
+        atomic = AtomicAttack(
+            atomic_attack_name="topology", attack_technique=AttackTechnique(attack=strategy), seed_groups=[seed]
+        )
+        scenario = ConcreteScenario(name="Topology", version=1, atomic_attacks_to_return=[atomic])
+        scenario.set_params_from_args(args={"objective_target": mock_objective_target})
+        await scenario.initialize_async()
+        [stored] = await scenario._memory.get_scenario_results_async(scenario_result_ids=[scenario._scenario_result_id])
+        payload = stored.metadata[SCENARIO_RUN_PLAN_METADATA_KEY]
+        assert payload["atomic_groups"][0]["is_compound"] is compound
+        resumed = ConcreteScenario(
+            name="Topology",
+            version=1,
+            atomic_attacks_to_return=[atomic],
+            scenario_result_id=scenario._scenario_result_id,
+        )
+        resumed.set_params_from_args(args={"objective_target": mock_objective_target})
+        await resumed.initialize_async()
+        assert resumed._build_run_plan().model_dump(mode="json", exclude_none=True) == payload
+
     async def test_initialize_async_populates_atomic_attacks(self, mock_atomic_attacks, mock_objective_target):
         """Test that initialize_async populates atomic attacks."""
         scenario = ConcreteScenario(
@@ -724,6 +766,7 @@ async def test_initialize_async_deduplicates_logical_seed_groups_in_run_plan(sel
             AttackSeedGroup(seeds=[SeedObjective(value="duplicate objective")]),
         ]
         atomic_attack = MagicMock(spec=AtomicAttack)
+        atomic_attack.attack_technique.attack.IS_COMPOUND = False
         atomic_attack.group_kind = ScenarioRunPlanGroupKind.ATTACK
         atomic_attack.seed_group_adaptations = {}
         atomic_attack.atomic_attack_name = "duplicate_attack"
@@ -759,6 +802,7 @@ async def test_build_run_plan_preserves_unique_seed_group_order(self, mock_objec
             AttackSeedGroup(seeds=[SeedObjective(value="second objective")]),
         ]
         atomic_attack = MagicMock(spec=AtomicAttack)
+        atomic_attack.attack_technique.attack.IS_COMPOUND = False
         atomic_attack.group_kind = ScenarioRunPlanGroupKind.ATTACK
         atomic_attack.seed_group_adaptations = {}
         atomic_attack.atomic_attack_name = "unique_attack"
@@ -1166,6 +1210,7 @@ async def test_atomic_attack_count_with_different_sizes(self, mock_objective_tar
         mock_attack.get_attack_scoring_config.return_value = MagicMock()
 
         single_run_mock = MagicMock(spec=AtomicAttack)
+        single_run_mock.attack_technique.attack.IS_COMPOUND = False
         single_run_mock.group_kind = ScenarioRunPlanGroupKind.ATTACK
         single_run_mock.seed_group_adaptations = {}
         single_run_mock.atomic_attack_name = "attack_1"
@@ -1190,6 +1235,7 @@ async def test_atomic_attack_count_with_different_sizes(self, mock_objective_tar
         many_runs = []
         for i in range(10):
             run = MagicMock(spec=AtomicAttack)
+            run.attack_technique.attack.IS_COMPOUND = False
             run.group_kind = ScenarioRunPlanGroupKind.ATTACK
             run.seed_group_adaptations = {}
             run.atomic_attack_name = f"attack_{i}"
diff --git a/tests/unit/scenario/core/test_scenario_partial_results.py b/tests/unit/scenario/core/test_scenario_partial_results.py
index 6301a56472..40ab898cb4 100644
--- a/tests/unit/scenario/core/test_scenario_partial_results.py
+++ b/tests/unit/scenario/core/test_scenario_partial_results.py
@@ -80,6 +80,7 @@ def create_mock_atomic_attack(name: str, objectives: list[str]) -> MagicMock:
     mock_attack_strategy.get_attack_scoring_config.return_value = MagicMock()
 
     attack = MagicMock(spec=AtomicAttack)
+    attack.attack_technique.attack.IS_COMPOUND = False
     attack.group_kind = ScenarioRunPlanGroupKind.ATTACK
     attack.seed_group_adaptations = {}
     attack.atomic_attack_name = name
diff --git a/tests/unit/scenario/core/test_scenario_retry.py b/tests/unit/scenario/core/test_scenario_retry.py
index 8a644bdc42..b33b41d964 100644
--- a/tests/unit/scenario/core/test_scenario_retry.py
+++ b/tests/unit/scenario/core/test_scenario_retry.py
@@ -151,6 +151,7 @@ def create_mock_atomic_attack(name: str, objectives: list[str], run_async_mock:
     mock_attack_strategy.get_attack_scoring_config.return_value = MagicMock()
 
     attack = MagicMock(spec=AtomicAttack)
+    attack.attack_technique.attack.IS_COMPOUND = False
     attack.group_kind = ScenarioRunPlanGroupKind.ATTACK
     attack.seed_group_adaptations = {}
     attack.atomic_attack_name = name
@@ -890,6 +891,7 @@ async def test_duplicate_objective_text_in_atomic_attack_is_rejected(self, mock_
         from pyrit.scenario import AtomicAttack, AttackTechnique
 
         mock_attack = MagicMock(spec=AttackStrategy)
+        mock_attack.IS_COMPOUND = False
         duplicate_groups = [
             AttackSeedGroup(seeds=[SeedObjective(value="dup-obj")]),
             AttackSeedGroup(seeds=[SeedObjective(value="dup-obj")]),
@@ -1103,6 +1105,7 @@ def _make_scenario_with_atomics(self, atomics):
 
     def test_noop_when_metadata_has_no_persisted_hashes(self):
         atomic = MagicMock(spec=AtomicAttack)
+        atomic.attack_technique.attack.IS_COMPOUND = False
         atomic.group_kind = ScenarioRunPlanGroupKind.ATTACK
         scenario = self._make_scenario_with_atomics([atomic])
         stored = MagicMock()
@@ -1112,9 +1115,11 @@ def test_noop_when_metadata_has_no_persisted_hashes(self):
 
     def test_replays_persisted_subset_across_atomics(self):
         atomic_a = MagicMock(spec=AtomicAttack)
+        atomic_a.attack_technique.attack.IS_COMPOUND = False
         atomic_a.group_kind = ScenarioRunPlanGroupKind.ATTACK
         atomic_a.keep_seed_groups_with_hashes.return_value = {"h1", "h2"}
         atomic_b = MagicMock(spec=AtomicAttack)
+        atomic_b.attack_technique.attack.IS_COMPOUND = False
         atomic_b.group_kind = ScenarioRunPlanGroupKind.ATTACK
         atomic_b.keep_seed_groups_with_hashes.return_value = {"h3"}
         scenario = self._make_scenario_with_atomics([atomic_a, atomic_b])
@@ -1128,6 +1133,7 @@ def test_replays_persisted_subset_across_atomics(self):
 
     def test_raises_when_persisted_hash_is_missing(self):
         atomic = MagicMock(spec=AtomicAttack)
+        atomic.attack_technique.attack.IS_COMPOUND = False
         atomic.group_kind = ScenarioRunPlanGroupKind.ATTACK
         atomic.keep_seed_groups_with_hashes.return_value = {"h1"}  # h2 missing
         scenario = self._make_scenario_with_atomics([atomic])