diff --git a/apps/presentation/dashboard/smoke/benchmark-study-contract-smoke.ts b/apps/presentation/dashboard/smoke/benchmark-study-contract-smoke.ts
index d33197f68a..b34dd59e3f 100644
--- a/apps/presentation/dashboard/smoke/benchmark-study-contract-smoke.ts
+++ b/apps/presentation/dashboard/smoke/benchmark-study-contract-smoke.ts
@@ -2,9 +2,19 @@ import fixture from "../public/benchmark-study.example.json" with { type: "json"
 import {
   parseBenchmarkStudyDashboard,
   resolveBenchmarkStudyDashboardUrl,
+  selectBenchmarkStudyRun,
 } from "../src/data/benchmark-study.js";
 
 const packet = parseBenchmarkStudyDashboard(fixture);
+const first = packet.runs[0]!;
+const second = { ...first, case_id: "another-case" };
+if (selectBenchmarkStudyRun([first, second], first.run_id, second.case_id) !== second) throw new Error("run selection lost its case");
+if (selectBenchmarkStudyRun([first, second], first.run_id, "") !== undefined) throw new Error("ambiguous legacy link selected a run");
+if (selectBenchmarkStudyRun([first], first.run_id, "") !== first) throw new Error("unique legacy link stopped resolving");
+if (selectBenchmarkStudyRun([first], first.run_id, "missing-case") !== undefined) throw new Error("stale case link selected another case");
+if (selectBenchmarkStudyRun([first], "missing-run", "") !== undefined) throw new Error("stale run link selected another run");
+if (selectBenchmarkStudyRun([first, first], first.run_id, first.case_id) !== undefined) throw new Error("duplicate full identity selected a run");
+if (selectBenchmarkStudyRun([first], "", "") !== first) throw new Error("unselected runs view lost its default");
 if (packet.status !== "provisional") throw new Error("fixture must expose provisional coverage");
 if (packet.campaign.intended_cell_denominator !== 8) throw new Error("campaign denominator drifted");
 if (packet.campaign.selected_score_countable_cell_count !== 6) throw new Error("countable numerator drifted");
diff --git a/apps/presentation/dashboard/src/data/benchmark-study.ts b/apps/presentation/dashboard/src/data/benchmark-study.ts
index b81f388393..ffda1dc700 100644
--- a/apps/presentation/dashboard/src/data/benchmark-study.ts
+++ b/apps/presentation/dashboard/src/data/benchmark-study.ts
@@ -196,6 +196,15 @@ export type BenchmarkStudyCase = BenchmarkStudyDashboard["cases"][number];
 export type BenchmarkStudyRun = BenchmarkStudyDashboard["runs"][number];
 export type BenchmarkStudyView = "campaign" | "arms" | "cases" | "runs";
 
+export function selectBenchmarkStudyRun(
+  runs: BenchmarkStudyRun[], runId: string, caseId: string,
+): BenchmarkStudyRun | undefined {
+  if (!runId && !caseId) return runs[0];
+  const matches = runs.filter((run) => run.run_id === runId && (!caseId || run.case_id === caseId));
+  // Legacy runId-only bookmarks are safe only when they identify exactly one run.
+  return matches.length === 1 ? matches[0] : undefined;
+}
+
 export function parseBenchmarkStudyDashboard(value: unknown): BenchmarkStudyDashboard {
   return benchmarkStudyDashboardSchema.parse(value);
 }
diff --git a/apps/presentation/dashboard/src/router.tsx b/apps/presentation/dashboard/src/router.tsx
index cf1101ee4e..f6730d4eb7 100644
--- a/apps/presentation/dashboard/src/router.tsx
+++ b/apps/presentation/dashboard/src/router.tsx
@@ -38,6 +38,7 @@ const benchmarkStudySearchSchema = z.object({
   dashboardUrl: z.string().optional().default(""),
   view: z.enum(["campaign", "arms", "cases", "runs"]).optional().default("campaign"),
   runId: z.string().optional().default(""),
+  caseId: z.string().optional().default(""),
 });
 
 // Bookmarks remain valid, but the retired boards no longer ship a second UI.
diff --git a/apps/presentation/dashboard/src/views/benchmark-study-page.tsx b/apps/presentation/dashboard/src/views/benchmark-study-page.tsx
index 9017f0f0c2..a4928bee29 100644
--- a/apps/presentation/dashboard/src/views/benchmark-study-page.tsx
+++ b/apps/presentation/dashboard/src/views/benchmark-study-page.tsx
@@ -13,6 +13,7 @@ import { benchmarkStudyRoute } from "../router";
 import {
   parseBenchmarkStudyDashboard,
   resolveBenchmarkStudyDashboardUrl,
+  selectBenchmarkStudyRun,
   type BenchmarkStudyArm,
   type BenchmarkStudyCase,
   type BenchmarkStudyDashboard,
@@ -190,7 +191,7 @@ function ArmsView({ packet }: { packet: BenchmarkStudyDashboard }) {
   );
 }
 
-function CasesView({ packet, primaryMetric, onOpenRun }: { packet: BenchmarkStudyDashboard; primaryMetric: string; onOpenRun: (runId: string) => void }) {
+function CasesView({ packet, primaryMetric, onOpenRun }: { packet: BenchmarkStudyDashboard; primaryMetric: string; onOpenRun: (runId: string, caseId: string) => void }) {
   return (
     <div className="benchmark-table-shell benchmark-wide-table">
       <table>
@@ -208,7 +209,7 @@ function CasesView({ packet, primaryMetric, onOpenRun }: { packet: BenchmarkStud
                 {item.arms.map((cell) => (
                   <td key={cell.arm_id}>
                     {cell.selected_run_id && cell.score_countable ? (
-                      <button className="benchmark-cell-link" onClick={() => onOpenRun(cell.selected_run_id!)} type="button">
+                      <button className="benchmark-cell-link" onClick={() => onOpenRun(cell.selected_run_id!, item.case_id)} type="button">
                         <span>{primaryMetric}: {metricValue(cell.metrics[primaryMetric])}</span>
                         {packet.design.metric_catalog.filter((metric) => metric.metric_name !== primaryMetric).map((metric) => (
                           <small className="benchmark-cell-metric" key={metric.metric_name}>{metric.metric_name}: {metricValue(cell.metrics[metric.metric_name])}</small>
@@ -261,23 +262,23 @@ function RunDetail({ run, packet }: { run: BenchmarkStudyRun; packet: BenchmarkS
   );
 }
 
-function RunsView({ packet, selectedRunId, onSelectRun }: { packet: BenchmarkStudyDashboard; selectedRunId: string; onSelectRun: (runId: string) => void }) {
-  const selected = packet.runs.find((run) => run.run_id === selectedRunId) ?? packet.runs[0];
+function RunsView({ packet, selectedRunId, selectedCaseId, onSelectRun }: { packet: BenchmarkStudyDashboard; selectedRunId: string; selectedCaseId: string; onSelectRun: (runId: string, caseId: string) => void }) {
+  const selected = selectBenchmarkStudyRun(packet.runs, selectedRunId, selectedCaseId);
   return (
     <div className="benchmark-runs-layout">
       <div className="benchmark-table-shell">
         <table>
           <thead><tr><th>Run</th><th>Case</th><th>Arm</th><th>Status</th><th>Countability</th></tr></thead>
           <tbody>{packet.runs.map((run) => (
-            <tr aria-selected={run.run_id === selected?.run_id} key={run.run_id}>
-              <td><button className="benchmark-run-link" onClick={() => onSelectRun(run.run_id)} type="button">{run.run_id}</button></td>
+            <tr aria-selected={run === selected} key={JSON.stringify([run.case_id, run.run_id])}>
+              <td><button className="benchmark-run-link" onClick={() => onSelectRun(run.run_id, run.case_id)} type="button">{run.run_id}</button></td>
               <td>{run.case_id}</td><td>{run.arm_id}</td><td>{run.status}</td>
               <td>{run.countability.score_countable ? "Score-countable" : "Diagnostic only"}</td>
             </tr>
           ))}</tbody>
         </table>
       </div>
-      {selected && <RunDetail packet={packet} run={selected} />}
+      {selected ? <RunDetail packet={packet} run={selected} /> : <p role="status">Select a run from the table to view its details.</p>}
     </div>
   );
 }
@@ -323,7 +324,7 @@ export function BenchmarkStudyPage() {
   if (!packet) return <main aria-busy="true" className="benchmark-page benchmark-loading"><Activity aria-hidden="true" /><h1>Reading benchmark study</h1><p>Validating the public-safe dashboard packet…</p></main>;
 
   const primaryMetric = packet.design.metric_catalog.find((metric) => metric.role === "primary")?.metric_name ?? "primary";
-  const setView = (view: BenchmarkStudyView, runId = search.runId) => navigate({ search: (current) => ({ ...current, view, runId }) });
+  const setView = (view: BenchmarkStudyView, runId = search.runId, caseId = search.caseId) => navigate({ search: (current) => ({ ...current, view, runId, caseId }) });
   const sourcePath = new URL(source.url).pathname;
 
   return (
@@ -361,8 +362,8 @@ export function BenchmarkStudyPage() {
       <div className="benchmark-content">
         {search.view === "campaign" && <CampaignView packet={packet} primaryMetric={primaryMetric} />}
         {search.view === "arms" && <ArmsView packet={packet} />}
-        {search.view === "cases" && <CasesView onOpenRun={(runId) => setView("runs", runId)} packet={packet} primaryMetric={primaryMetric} />}
-        {search.view === "runs" && <RunsView onSelectRun={(runId) => setView("runs", runId)} packet={packet} selectedRunId={search.runId} />}
+        {search.view === "cases" && <CasesView onOpenRun={(runId, caseId) => setView("runs", runId, caseId)} packet={packet} primaryMetric={primaryMetric} />}
+        {search.view === "runs" && <RunsView onSelectRun={(runId, caseId) => setView("runs", runId, caseId)} packet={packet} selectedRunId={search.runId} selectedCaseId={search.caseId} />}
       </div>
 
       <footer className="benchmark-footer">
diff --git a/docs/assets/benchmark-study/run-identity-after.png b/docs/assets/benchmark-study/run-identity-after.png
new file mode 100644
index 0000000000..5f272514c4
Binary files /dev/null and b/docs/assets/benchmark-study/run-identity-after.png differ
diff --git a/docs/assets/benchmark-study/run-identity-ambiguous.png b/docs/assets/benchmark-study/run-identity-ambiguous.png
new file mode 100644
index 0000000000..f131ed135c
Binary files /dev/null and b/docs/assets/benchmark-study/run-identity-ambiguous.png differ
diff --git a/docs/assets/benchmark-study/run-identity-before.png b/docs/assets/benchmark-study/run-identity-before.png
new file mode 100644
index 0000000000..e2500ba4fc
Binary files /dev/null and b/docs/assets/benchmark-study/run-identity-before.png differ
diff --git a/examples/dashboard-benchmark-study-browser-smoke.mjs b/examples/dashboard-benchmark-study-browser-smoke.mjs
index 11768a0813..00f7a07b30 100644
--- a/examples/dashboard-benchmark-study-browser-smoke.mjs
+++ b/examples/dashboard-benchmark-study-browser-smoke.mjs
@@ -3,7 +3,7 @@
 
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -97,13 +97,58 @@ async function assertCommonSurface(page, label) {
   await assertNoHorizontalOverflow(page, label);
 }
 
+async function assertCaseScopedRunSelection(page, url) {
+  const fixture = JSON.parse(readFileSync(resolve(dashboardDir, "public/benchmark-study.example.json"), "utf8"));
+  const localIds = new Map(fixture.runs.map((run) => [run.run_id, run.arm_id]));
+  const packet = JSON.parse(JSON.stringify(fixture, (_key, value) => localIds.get(value) ?? value));
+  await page.route("**/case-local-runs.json", (route) => route.fulfill({ json: packet }));
+  const target = new URL(url);
+  target.search = new URLSearchParams({ dashboardUrl: "/case-local-runs.json", view: "cases" }).toString();
+  await page.goto(target.toString(), { waitUntil: "networkidle" });
+  const secondCase = page.getByRole("row").filter({ has: page.getByText("case-state-transition", { exact: true }) });
+  await secondCase.getByRole("button", { name: /Countable/ }).first().click();
+  const detail = page.getByRole("complementary", { name: "Run detail for goal_plain" });
+  await detail.waitFor();
+  if (process.env.LOOPX_BENCHMARK_STUDY_SCREENSHOT_DIR) {
+    mkdirSync(process.env.LOOPX_BENCHMARK_STUDY_SCREENSHOT_DIR, { recursive: true });
+    await page.screenshot({ path: resolve(process.env.LOOPX_BENCHMARK_STUDY_SCREENSHOT_DIR, "case-local-run.png"), fullPage: true });
+  }
+  if (!(await detail.innerText()).includes("case-state-transition · goal_plain")) {
+    throw new Error("case-cell navigation opened another case's reused run id");
+  }
+  if (new URL(page.url()).searchParams.get("caseId") !== "case-state-transition") {
+    throw new Error("run link lost its case identity");
+  }
+  await page.reload({ waitUntil: "networkidle" });
+  await detail.getByText("case-state-transition · goal_plain", { exact: true }).waitFor();
+  const firstCase = page.getByRole("row").filter({ has: page.getByRole("cell", { name: "case-api-contract", exact: true }) });
+  await firstCase.getByRole("button", { name: "goal_plain", exact: true }).click();
+  await detail.getByText("case-api-contract · goal_plain", { exact: true }).waitFor();
+
+  for (const caseId of ["", "missing-case"]) {
+    target.search = new URLSearchParams({ dashboardUrl: "/case-local-runs.json", view: "runs", runId: "goal_plain", caseId }).toString();
+    await page.goto(target.toString(), { waitUntil: "networkidle" });
+    await page.getByText("Select a run from the table to view its details.", { exact: true }).waitFor();
+    if (!caseId && process.env.LOOPX_BENCHMARK_STUDY_SCREENSHOT_DIR) {
+      await page.screenshot({ path: resolve(process.env.LOOPX_BENCHMARK_STUDY_SCREENSHOT_DIR, "ambiguous-run-link.png"), fullPage: true });
+    }
+    if (await page.getByRole("complementary", { name: /Run detail for/ }).count()) {
+      throw new Error("ambiguous or stale run link silently selected a different run");
+    }
+  }
+  // A unique legacy runId bookmark remains valid without a caseId parameter.
+  target.search = new URLSearchParams({ view: "runs", runId: "run-goal-state" }).toString();
+  await page.goto(target.toString(), { waitUntil: "networkidle" });
+  await page.getByRole("complementary").getByText("case-state-transition · goal_plain", { exact: true }).waitFor();
+}
+
 async function main() {
   const { chromium } = loadPlaywright();
-  const server = startDashboardServer();
+  const server = process.env.LOOPX_BENCHMARK_STUDY_URL ? null : startDashboardServer();
   let browser;
   const pageErrors = [];
   try {
-    const url = `http://127.0.0.1:${port}/benchmarks/study`;
+    const url = process.env.LOOPX_BENCHMARK_STUDY_URL ?? `http://127.0.0.1:${port}/benchmarks/study`;
     await waitForDashboard(url);
     browser = await launchBrowser(chromium);
 
@@ -149,11 +194,12 @@ async function main() {
     await rejected.goto(`${url}?dashboardUrl=${encodeURIComponent("https://example.com/study.json")}`, { waitUntil: "networkidle" });
     await rejected.getByText("Benchmark dashboard source must use same-origin local readback", { exact: true }).waitFor();
 
+    await assertCaseScopedRunSelection(desktop, url);
     if (pageErrors.length) throw new Error(`browser errors: ${pageErrors.join(" | ")}`);
     console.log("benchmark study browser smoke passed");
   } finally {
     await browser?.close();
-    server.kill("SIGTERM");
+    server?.kill("SIGTERM");
   }
 }
 
diff --git a/loopx/capabilities/benchmark_toolkit/README.md b/loopx/capabilities/benchmark_toolkit/README.md
index 176e6e4bd2..0f647c9220 100644
--- a/loopx/capabilities/benchmark_toolkit/README.md
+++ b/loopx/capabilities/benchmark_toolkit/README.md
@@ -914,6 +914,11 @@ silently pooled. Unknown fields and path-like references fail closed.
 Every non-baseline row names an exact `comparison_anchor_run_id`. Standard control
 or treatment rows anchor to a baseline. Explore rows use `diagnostic_only` claim
 scope and may anchor to the baseline or fixed standard arm they are examining.
+Run identity is `(benchmark_id, study_id, case_id, run_id)`; an anchor inherits
+the candidate's benchmark, study, and case. Run ids may be reused across those
+scopes. Duplicate full identities must be reconciled before board readback.
+Study provenance and case insights bind to this same identity. Dashboard run
+links retain the case; a legacy run-id-only link resolves only when unambiguous.
 Matched comparisons require compatible benchmark, study, case, model, primary
 metric, comparison protocol, score countability, and treatment fidelity. Exact
 protocol revisions remain visible as a warning even when a declared comparison
diff --git a/loopx/capabilities/benchmark_toolkit/experiment_board.py b/loopx/capabilities/benchmark_toolkit/experiment_board.py
index 582a898d24..3e4bc9f00b 100644
--- a/loopx/capabilities/benchmark_toolkit/experiment_board.py
+++ b/loopx/capabilities/benchmark_toolkit/experiment_board.py
@@ -10,6 +10,7 @@
 from ...domain_state import default_domain_state_file_path, upsert_domain_state_jsonl
 from .experiment_identity import (
     ARM_ROLES,
+    experiment_run_key,
     experiment_token_text as _token,
 )
 from .factorial_contrast import (
@@ -476,13 +477,7 @@ def upsert_benchmark_experiment_board_row(
 def _benchmark_experiment_board_row_key_tuple(
     payload: Mapping[str, Any],
 ) -> tuple[str, str, str, str]:
-    key = benchmark_experiment_board_row_key(payload)
-    return (
-        key["benchmark_id"],
-        key["study_id"],
-        key["case_id"],
-        key["run_id"],
-    )
+    return experiment_run_key(benchmark_experiment_board_row_key(payload))
 
 
 def _benchmark_experiment_board_observed_at(payload: Mapping[str, Any]) -> datetime:
@@ -730,9 +725,19 @@ def build_benchmark_experiment_board(
         else []
     )
 
-    by_run_id = {row["run_id"]: row for row in normalized}
+    by_run_key = {}
+    for row in normalized:
+        key = experiment_run_key(row)
+        if key in by_run_key:
+            raise ValueError("duplicate experiment-board run identity")
+        by_run_key[key] = row
     comparisons = [
-        _build_comparison(row, by_run_id.get(row.get("comparison_anchor_run_id")))
+        _build_comparison(
+            row,
+            by_run_key.get(
+                experiment_run_key(row, run_id=row["comparison_anchor_run_id"])
+            ),
+        )
         for row in normalized
         if row["arm_role"] != "baseline"
     ]
diff --git a/loopx/capabilities/benchmark_toolkit/experiment_identity.py b/loopx/capabilities/benchmark_toolkit/experiment_identity.py
index 3e92073d3a..bbac13d2f3 100644
--- a/loopx/capabilities/benchmark_toolkit/experiment_identity.py
+++ b/loopx/capabilities/benchmark_toolkit/experiment_identity.py
@@ -1,4 +1,4 @@
-"""One owner for the two vocabularies a benchmark experiment identity uses.
+"""Shared benchmark experiment vocabulary and scoped run identity.
 
 An arm role and a public-safe token are validated at the package boundary, at
 the study projection, at the concurrency envelope and at the CLI that admits a
@@ -13,11 +13,15 @@
 ``experiment_token_text`` is the reject path that goes with the token shape.
 Five modules carried a byte-identical private ``_token`` helper, so the shape and
 its rejection message travelled together in five copies.
+
+``experiment_run_key`` preserves the ledger's benchmark/study/case/run identity
+when normalized rows, anchors, provenance and insights are joined.
 """
 
 from __future__ import annotations
 
 import re
+from collections.abc import Mapping
 from typing import Any
 
 ARM_ROLES = frozenset({"baseline", "control", "treatment", "explore"})
@@ -26,6 +30,18 @@
 EXPERIMENT_TOKEN_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.:@+-]{0,127}$")
 
 
+def experiment_run_key(
+    row: Mapping[str, Any], *, run_id: str | None = None
+) -> tuple[str, str, str, str]:
+    """Identify a normalized board row or insight; anchors inherit the same scope."""
+    return (
+        row["benchmark_id"],
+        row["study_id"],
+        row["case_id"],
+        row["run_id"] if run_id is None else run_id,
+    )
+
+
 def experiment_token_text(value: Any, *, field: str) -> str:
     text = str(value or "").strip()
     if not EXPERIMENT_TOKEN_PATTERN.fullmatch(text):
diff --git a/loopx/capabilities/benchmark_toolkit/study_projection.py b/loopx/capabilities/benchmark_toolkit/study_projection.py
index de7466c3c5..76db741896 100644
--- a/loopx/capabilities/benchmark_toolkit/study_projection.py
+++ b/loopx/capabilities/benchmark_toolkit/study_projection.py
@@ -25,6 +25,7 @@
 )
 from .experiment_identity import (
     ARM_ROLES,
+    experiment_run_key,
     experiment_token_text as _token,
 )
 from .four_arm_contract import BENCHMARK_FOUR_ARM_CONTRACT_SCHEMA_VERSION
@@ -640,17 +641,13 @@ def _validate_case_insight_attachment(
         candidate["payload"]
         for candidate in active_envelopes
         if candidate["record_kind"] == "experiment_board_row"
-        and candidate["benchmark_id"] == envelope["benchmark_id"]
-        and candidate["study_id"] == envelope["study_id"]
-        and candidate["payload"]["run_id"] == insight["run_id"]
+        and experiment_run_key(candidate["payload"]) == experiment_run_key(insight)
     ]
     if len(board_rows) != 1:
         raise ValueError(
             "case-insight upload requires one active exact-run board record"
         )
     run = board_rows[0]
-    if run["case_id"] != insight["case_id"]:
-        raise ValueError("case insight identity does not match its board row")
     if not benchmark_run_status_is_terminal(run["status"]):
         raise ValueError("case-insight upload requires a terminal run")
     if run["status"] != insight["outcome_status"]:
@@ -1017,7 +1014,7 @@ def build_benchmark_study_dashboard(
     ]
     board_rows = [envelope["payload"] for envelope in board_envelopes]
     board_provenance = {
-        envelope["payload"]["run_id"]: {
+        experiment_run_key(envelope["payload"]): {
             key: envelope[key]
             for key in (
                 "record_id",
@@ -1062,7 +1059,7 @@ def build_benchmark_study_dashboard(
         if envelope["record_kind"] == "case_insight_projection"
     ]
     insights = {
-        envelope["payload"]["run_id"]: envelope["payload"]
+        experiment_run_key(envelope["payload"]): envelope["payload"]
         for envelope in insight_envelopes
     }
     insight_records = [envelope["payload"] for envelope in insight_envelopes]
@@ -1185,12 +1182,16 @@ def build_benchmark_study_dashboard(
                     sorted(
                         {
                             failure: sum(
-                                insights.get(row["run_id"], {}).get("failure_class")
+                                insights.get(experiment_run_key(row), {}).get(
+                                    "failure_class"
+                                )
                                 == failure
                                 for row in arm_rows
                             )
                             for failure in {
-                                insights.get(row["run_id"], {}).get("failure_class")
+                                insights.get(experiment_run_key(row), {}).get(
+                                    "failure_class"
+                                )
                                 for row in arm_rows
                             }
                             if failure
@@ -1213,7 +1214,7 @@ def build_benchmark_study_dashboard(
                     "score_countable": row is not None,
                     "metrics": row["metrics"] if row else {},
                     "effort": row["effort"] if row else {},
-                    "insight": insights.get(row["run_id"]) if row else None,
+                    "insight": insights.get(experiment_run_key(row)) if row else None,
                 }
             )
         complete = all(cell["score_countable"] for cell in arm_cells)
@@ -1347,8 +1348,8 @@ def build_benchmark_study_dashboard(
         "runs": [
             {
                 **row,
-                "redacted_insight": insights.get(row["run_id"]),
-                "upload_provenance": board_provenance[row["run_id"]],
+                "redacted_insight": insights.get(experiment_run_key(row)),
+                "upload_provenance": board_provenance[experiment_run_key(row)],
             }
             for row in board["runs"]
         ],
diff --git a/tests/capabilities/test_benchmark_experiment_board.py b/tests/capabilities/test_benchmark_experiment_board.py
index f49eb8f966..30319fe82b 100644
--- a/tests/capabilities/test_benchmark_experiment_board.py
+++ b/tests/capabilities/test_benchmark_experiment_board.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import copy
+import itertools
 import json
 import subprocess
 from pathlib import Path
@@ -224,6 +226,60 @@ def _connected_goal_registries(tmp_path: Path) -> tuple[Path, Path]:
     return project, global_registry
 
 
+@pytest.mark.parametrize("scope", ["benchmark_id", "study_id", "case_id"])
+def test_board_resolves_reused_run_ids_within_the_persisted_scope(scope: str) -> None:
+    baseline = _baseline()
+    treatment = _row(
+        run_id="treatment",
+        arm_id="loopx",
+        arm_role="treatment",
+        protocol_id="runner-v21",
+        observed_at="2026-08-18T00:01:00+00:00",
+        f2p=20,
+        comparison_anchor_run_id=baseline["run_id"],
+    )
+    other_baseline, other_treatment = copy.deepcopy(baseline), copy.deepcopy(treatment)
+    other_baseline[scope] = other_treatment[scope] = "z-other"
+    other_baseline["metrics"]["feature_pass"]["value"] = 60
+    other_treatment["metrics"]["feature_pass"]["value"] = 65
+    rows = [baseline, treatment, other_baseline, other_treatment]
+    for ordering in itertools.permutations(rows):
+        board = build_benchmark_experiment_board(ordering)
+        assert board["summary"]["matched_pair_countable_count"] == 2
+        assert [
+            c["metric_deltas"]["feature_pass"]["delta"] for c in board["comparisons"]
+        ] == [20, 5]
+    if scope != "case_id":
+        filtered = build_benchmark_experiment_board(rows, **{scope: baseline[scope]})
+        assert filtered["comparisons"] == board["comparisons"][:1]
+
+
+def test_board_never_falls_back_to_an_anchor_in_another_case() -> None:
+    baseline = _baseline(case_id="other-case")
+    treatment = _row(
+        run_id="treatment",
+        arm_id="loopx",
+        arm_role="treatment",
+        protocol_id="runner-v21",
+        observed_at="2026-08-18T00:01:00+00:00",
+        f2p=20,
+        comparison_anchor_run_id=baseline["run_id"],
+    )
+    comparison = build_benchmark_experiment_board([baseline, treatment])["comparisons"][
+        0
+    ]
+    assert comparison["reason_codes"] == ["comparison_anchor_run_missing"]
+    assert comparison["metric_deltas"] == {}
+
+
+def test_board_rejects_duplicate_full_run_identities() -> None:
+    baseline = _baseline()
+    conflicting = copy.deepcopy(baseline)
+    conflicting["metrics"]["feature_pass"]["value"] = 60
+    with pytest.raises(ValueError, match="duplicate experiment-board run identity"):
+        build_benchmark_experiment_board([baseline, conflicting])
+
+
 def test_row_rejects_raw_or_path_like_fields() -> None:
     raw_field = _baseline(raw_trajectory="private content")
     with pytest.raises(ValueError, match="unsupported fields"):
diff --git a/tests/capabilities/test_benchmark_study_projection.py b/tests/capabilities/test_benchmark_study_projection.py
index 491a3f7891..a51e479734 100644
--- a/tests/capabilities/test_benchmark_study_projection.py
+++ b/tests/capabilities/test_benchmark_study_projection.py
@@ -303,6 +303,133 @@ def _four_arm_contract() -> dict[str, object]:
     )
 
 
+def test_dashboard_preserves_provenance_for_case_local_run_ids() -> None:
+    first = _row(arm_id="goal_plain", arm_role="baseline", feature=5, reward=0)
+    second = copy.deepcopy(first)
+    second["case_id"] = "case-2"
+    envelopes = [
+        _envelope(first, record_kind="experiment_board_row", key="first"),
+        _envelope(second, record_kind="experiment_board_row", key="second"),
+    ]
+    for ordering in (envelopes, envelopes[::-1]):
+        packet = build_benchmark_study_dashboard(_manifest(), ordering)
+        assert [r["upload_provenance"]["record_id"] for r in packet["runs"]] == [
+            e["record_id"] for e in envelopes
+        ]
+
+
+@pytest.mark.parametrize("insights_last", [False, True])
+def test_case_local_run_ids_round_trip_with_insights_and_supersession(
+    tmp_path: Path,
+    insights_last: bool,
+) -> None:
+    store = tmp_path / "uploads.jsonl"
+    envelope_path = tmp_path / "envelope.json"
+
+    def upload(envelope: dict[str, object]) -> dict[str, object]:
+        if not insights_last:
+            return simulate_benchmark_upload(store, envelope, execute=True)
+        envelope_path.write_text(json.dumps(envelope), encoding="utf-8")
+        return _loopx_json(
+            "benchmark",
+            "upload-local",
+            "--envelope-json",
+            str(envelope_path),
+            "--store",
+            str(store),
+            "--execute",
+            "--format",
+            "json",
+        )
+
+    pending_insights = []
+    treatments = []
+    for case_id, score in (("case-1", 7), ("case-2", 8)):
+        baseline = _row(arm_id="goal_plain", arm_role="baseline", feature=5, reward=0)
+        treatment = _row(
+            arm_id="loopx_plain",
+            arm_role="treatment",
+            feature=score,
+            reward=0,
+            anchor=baseline["run_id"],
+        )
+        for row in (baseline, treatment):
+            row["case_id"] = case_id
+            envelope = _envelope(
+                row,
+                record_kind="experiment_board_row",
+                key=f"{case_id}-{row['arm_id']}",
+            )
+            upload(envelope)
+        treatments.append(envelope)
+        insight = _insight()
+        insight["case_id"] = case_id
+        insight["failure_class"] = case_id
+        envelope = _envelope(
+            insight, record_kind="case_insight_projection", key=f"{case_id}-insight"
+        )
+        if insights_last:
+            pending_insights.append(envelope)
+        else:
+            upload(envelope)
+    for envelope in pending_insights:
+        upload(envelope)
+
+    packet = build_benchmark_study_dashboard(
+        _manifest(), read_benchmark_local_upload_records(store)
+    )
+    assert packet["campaign"]["matched_pair_countable_count"] == 2
+    assert packet["status"] == "complete"
+    assert [
+        case["largest_eligible_primary_contrast"]["metric_deltas"][
+            "requirements_passed"
+        ]["delta"]
+        for case in packet["cases"]
+    ] == [2, 3]
+    for run in packet["runs"]:
+        if run["arm_role"] == "treatment":
+            assert run["redacted_insight"]["case_id"] == run["case_id"]
+    arm = next(a for a in packet["arms"] if a["arm_id"] == "loopx_plain")
+    assert arm["failure_class_counts"] == {"case-1": 1, "case-2": 1}
+
+    corrected = copy.deepcopy(treatments[0]["payload"])
+    corrected["metrics"]["requirements_passed"]["value"] = 9
+    replacement = _envelope(
+        corrected,
+        record_kind="experiment_board_row",
+        key="corrected-case-1",
+        supersedes=treatments[0]["record_id"],
+    )
+    upload(replacement)
+    replay = upload(replacement)
+    assert replay["disposition"] == "replayed"
+    packet = build_benchmark_study_dashboard(
+        _manifest(), read_benchmark_local_upload_records(store)
+    )
+    selected = [r for r in packet["runs"] if r["arm_role"] == "treatment"]
+    assert [r["metrics"]["requirements_passed"]["value"] for r in selected] == [9, 8]
+    assert [r["upload_provenance"]["record_id"] for r in selected] == [
+        replacement["record_id"],
+        treatments[1]["record_id"],
+    ]
+    assert [r["redacted_insight"]["case_id"] for r in selected] == ["case-1", "case-2"]
+    manifest_path = tmp_path / "manifest.json"
+    manifest_path.write_text(json.dumps(_manifest()), encoding="utf-8")
+    assert (
+        _loopx_json(
+            "benchmark",
+            "study-dashboard",
+            "--manifest-json",
+            str(manifest_path),
+            "--store",
+            str(store),
+            "--format",
+            "json",
+        )
+        == packet
+    )
+
+
 def test_two_arm_and_factorized_four_arm_manifests_validate() -> None:
     assert len(normalize_benchmark_study_manifest(_manifest())["arms"]) == 2
     assert (