From d1cfed3dfe5075179f33932b5281e1eac88388f0 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 13 Jul 2026 08:07:37 +0000
Subject: [PATCH 1/3] feat(web): add outlier and pipeline-error filters to runs
 list

Add runListFilters helpers and wire /runs plus /api/runs with outlier=true
and errors=true query params. Link from pipeline errors and outliers pages.

Co-authored-by: Eamon Boyle <eamonboyle@users.noreply.github.com>
---
 apps/web/app/api/runs/route.ts      |  38 +++++++---
 apps/web/app/errors/page.tsx        |   3 +
 apps/web/app/outliers/page.tsx      |   6 ++
 apps/web/app/runs/page.tsx          |  57 ++++++++++++---
 apps/web/lib/runListFilters.test.ts | 104 ++++++++++++++++++++++++++++
 apps/web/lib/runListFilters.ts      |  53 ++++++++++++++
 6 files changed, 243 insertions(+), 18 deletions(-)
 create mode 100644 apps/web/lib/runListFilters.test.ts
 create mode 100644 apps/web/lib/runListFilters.ts

diff --git a/apps/web/app/api/runs/route.ts b/apps/web/app/api/runs/route.ts
index c5bc604..b01bf95 100644
--- a/apps/web/app/api/runs/route.ts
+++ b/apps/web/app/api/runs/route.ts
@@ -1,23 +1,43 @@
-import { filterRunArtifacts, loadRunArtifacts } from "../../../lib/data";
+import { filterRunArtifacts, loadAnalysisIndex, loadRunArtifacts } from "../../../lib/data";
 import {
     resolveRunSortOrder,
     sortRunArtifacts,
 } from "../../../lib/artifactSort";
 import { runArtifactsToCsv } from "../../../lib/listExport";
+import { buildOutlierRunIdSet } from "../../../lib/outlierLookup";
+import {
+    applyRunListExtraFilters,
+    buildPipelineErrorRunIdSet,
+    parseRunListExtraFilters,
+} from "../../../lib/runListFilters";
 import { parseListPagination } from "../_shared/pagination";
 
 export async function GET(request: Request) {
     const url = new URL(request.url);
     const format = url.searchParams.get("format") ?? "json";
-    const runs = await loadRunArtifacts();
-    const filtered = filterRunArtifacts(runs, {
-        q: url.searchParams.get("q") ?? undefined,
-        model: url.searchParams.get("model") ?? undefined,
-        preset: url.searchParams.get("preset") ?? undefined,
-        fast: url.searchParams.get("fast") ?? undefined,
-        from: url.searchParams.get("from") ?? undefined,
-        to: url.searchParams.get("to") ?? undefined,
+    const [runs, index] = await Promise.all([
+        loadRunArtifacts(),
+        loadAnalysisIndex(),
+    ]);
+    const extraFilters = parseRunListExtraFilters({
+        outlier: url.searchParams.get("outlier") ?? undefined,
+        errors: url.searchParams.get("errors") ?? undefined,
     });
+    const filtered = applyRunListExtraFilters(
+        filterRunArtifacts(runs, {
+            q: url.searchParams.get("q") ?? undefined,
+            model: url.searchParams.get("model") ?? undefined,
+            preset: url.searchParams.get("preset") ?? undefined,
+            fast: url.searchParams.get("fast") ?? undefined,
+            from: url.searchParams.get("from") ?? undefined,
+            to: url.searchParams.get("to") ?? undefined,
+        }),
+        extraFilters,
+        {
+            outlierRunIds: buildOutlierRunIdSet(index),
+            errorRunIds: buildPipelineErrorRunIdSet(runs),
+        },
+    );
     const sort = resolveRunSortOrder(url.searchParams.get("sort") ?? undefined);
     const { offset, limit, page } = parseListPagination(url.searchParams);
     const sorted = sortRunArtifacts(filtered, sort);
diff --git a/apps/web/app/errors/page.tsx b/apps/web/app/errors/page.tsx
index cfb8cc5..5d93768 100644
--- a/apps/web/app/errors/page.tsx
+++ b/apps/web/app/errors/page.tsx
@@ -89,6 +89,9 @@ export default async function PipelineErrorsPage({
                     <Link href="/timing" className="button secondary">
                         Pipeline timing
                     </Link>
+                    <Link href="/runs?errors=true" className="button secondary">
+                        Runs with errors
+                    </Link>
                 </div>
             </div>
 
diff --git a/apps/web/app/outliers/page.tsx b/apps/web/app/outliers/page.tsx
index 77ae2f3..16c0662 100644
--- a/apps/web/app/outliers/page.tsx
+++ b/apps/web/app/outliers/page.tsx
@@ -79,6 +79,12 @@ export default async function OutliersPage({
                     <Link href="/benchmarks" className="button secondary">
                         All benchmarks
                     </Link>
+                    <Link
+                        href="/runs?outlier=true"
+                        className="button secondary"
+                    >
+                        Outlier runs list
+                    </Link>
                 </div>
             </div>
 
diff --git a/apps/web/app/runs/page.tsx b/apps/web/app/runs/page.tsx
index c083b2a..a9a828c 100644
--- a/apps/web/app/runs/page.tsx
+++ b/apps/web/app/runs/page.tsx
@@ -17,6 +17,12 @@ import {
 } from "../../lib/data";
 import { buildIndexRunLookup } from "../../lib/indexRunLookup";
 import { buildOutlierRunIdSet } from "../../lib/outlierLookup";
+import {
+    applyRunListExtraFilters,
+    buildPipelineErrorRunIdSet,
+    hasActiveRunListExtraFilters,
+    parseRunListExtraFilters,
+} from "../../lib/runListFilters";
 import {
     resolveRunSortOrder,
     sortRunArtifacts,
@@ -35,6 +41,8 @@ type RunsSearchParams = {
     fast?: string;
     from?: string;
     to?: string;
+    outlier?: string;
+    errors?: string;
     sort?: string;
     page?: string;
     pageSize?: string;
@@ -50,18 +58,24 @@ export default async function RunsPage({
         loadBenchmarkArtifacts(),
         loadAnalysisIndex(),
     ]);
+    const params = await searchParams;
     const indexLookup = index ? buildIndexRunLookup(index) : null;
     const outlierRunIds = buildOutlierRunIdSet(index);
+    const errorRunIds = buildPipelineErrorRunIdSet(runs);
+    const extraFilters = parseRunListExtraFilters(params);
     const { models, presets } = collectArtifactFacets(runs, benchmarks);
-    const params = await searchParams;
-    const filtered = filterRunArtifacts(runs, {
-        q: params.q,
-        model: params.model,
-        preset: params.preset,
-        fast: params.fast,
-        from: params.from,
-        to: params.to,
-    });
+    const filtered = applyRunListExtraFilters(
+        filterRunArtifacts(runs, {
+            q: params.q,
+            model: params.model,
+            preset: params.preset,
+            fast: params.fast,
+            from: params.from,
+            to: params.to,
+        }),
+        extraFilters,
+        { outlierRunIds, errorRunIds },
+    );
     const sort = resolveRunSortOrder(params.sort);
     const sorted = sortRunArtifacts(filtered, sort);
     const paging = paginateItems(sorted, params, {
@@ -120,6 +134,24 @@ export default async function RunsPage({
                         className="input"
                         title="Created at or before"
                     />
+                    <select
+                        name="outlier"
+                        defaultValue={params.outlier ?? ""}
+                        className="input"
+                        title="Filter to benchmark outlier runs"
+                    >
+                        <option value="">Outliers: any</option>
+                        <option value="true">Outliers only</option>
+                    </select>
+                    <select
+                        name="errors"
+                        defaultValue={params.errors ?? ""}
+                        className="input"
+                        title="Filter to runs with failed agent steps"
+                    >
+                        <option value="">Pipeline errors: any</option>
+                        <option value="true">With errors only</option>
+                    </select>
                 </div>
                 <div className="filter-sort-row">
                     <select name="sort" defaultValue={sort} className="input">
@@ -180,6 +212,8 @@ export default async function RunsPage({
                             fast: params.fast,
                             from: params.from,
                             to: params.to,
+                            outlier: extraFilters.outlierOnly ? "true" : undefined,
+                            errors: extraFilters.errorsOnly ? "true" : undefined,
                             sort,
                         }}
                     />
@@ -191,6 +225,8 @@ export default async function RunsPage({
                             fast: params.fast,
                             from: params.from,
                             to: params.to,
+                            outlier: extraFilters.outlierOnly ? "true" : undefined,
+                            errors: extraFilters.errorsOnly ? "true" : undefined,
                             sort,
                             pageSize: "500",
                             page: "1",
@@ -204,6 +240,9 @@ export default async function RunsPage({
                         Showing {paging.startDisplay}-{paging.endDisplay} of{" "}
                         {filtered.length} filtered
                         runs ({runs.length} total)
+                        {hasActiveRunListExtraFilters(extraFilters)
+                            ? " · outlier/error filters active"
+                            : ""}
                     </span>
                 </div>
             </form>
diff --git a/apps/web/lib/runListFilters.test.ts b/apps/web/lib/runListFilters.test.ts
new file mode 100644
index 0000000..4489cbf
--- /dev/null
+++ b/apps/web/lib/runListFilters.test.ts
@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest";
+import type { RunArtifact } from "./data";
+import {
+    applyRunListExtraFilters,
+    buildPipelineErrorRunIdSet,
+    hasActiveRunListExtraFilters,
+    parseRunListExtraFilters,
+} from "./runListFilters";
+
+function sampleRun(
+    id: string,
+    overrides: Partial<RunArtifact> = {},
+): RunArtifact {
+    return {
+        kind: "run",
+        id,
+        question: "Sample?",
+        metadata: {
+            createdAt: "2026-01-01T00:00:00.000Z",
+            model: "gpt-test",
+            pipelinePreset: "standard",
+            fastMode: false,
+        },
+        run: {
+            id,
+            finalAnswer: "answer",
+            steps: [],
+            metrics: {},
+        },
+        ...overrides,
+    };
+}
+
+describe("runListFilters", () => {
+    it("parses outlier and error flags", () => {
+        expect(parseRunListExtraFilters({})).toEqual({
+            outlierOnly: false,
+            errorsOnly: false,
+        });
+        expect(
+            parseRunListExtraFilters({ outlier: "true", errors: "true" }),
+        ).toEqual({
+            outlierOnly: true,
+            errorsOnly: true,
+        });
+    });
+
+    it("detects active extra filters", () => {
+        expect(
+            hasActiveRunListExtraFilters({
+                outlierOnly: false,
+                errorsOnly: false,
+            }),
+        ).toBe(false);
+        expect(
+            hasActiveRunListExtraFilters({
+                outlierOnly: true,
+                errorsOnly: false,
+            }),
+        ).toBe(true);
+    });
+
+    it("builds a set of run ids with pipeline errors", () => {
+        const runs = [
+            sampleRun("run_ok"),
+            sampleRun("run_fail", {
+                run: {
+                    id: "run_fail",
+                    finalAnswer: "answer",
+                    steps: [
+                        {
+                            id: "step_1",
+                            agentName: "Solver",
+                            role: "solver",
+                            createdAt: "2026-01-01T00:00:00.000Z",
+                            error: "timeout",
+                        },
+                    ],
+                    metrics: {},
+                },
+            }),
+        ];
+
+        expect([...buildPipelineErrorRunIdSet(runs)]).toEqual(["run_fail"]);
+    });
+
+    it("filters runs by outlier and error flags", () => {
+        const runs = [
+            sampleRun("run_a"),
+            sampleRun("run_b"),
+            sampleRun("run_c"),
+        ];
+        const filtered = applyRunListExtraFilters(
+            runs,
+            { outlierOnly: true, errorsOnly: true },
+            {
+                outlierRunIds: new Set(["run_a", "run_b"]),
+                errorRunIds: new Set(["run_b", "run_c"]),
+            },
+        );
+
+        expect(filtered.map((run) => run.id)).toEqual(["run_b"]);
+    });
+});
diff --git a/apps/web/lib/runListFilters.ts b/apps/web/lib/runListFilters.ts
new file mode 100644
index 0000000..142eee5
--- /dev/null
+++ b/apps/web/lib/runListFilters.ts
@@ -0,0 +1,53 @@
+import type { RunArtifact } from "./data";
+import { buildPipelineErrorRows } from "./pipelineErrors";
+
+export type RunListExtraFilterParams = {
+    outlier?: string;
+    errors?: string;
+};
+
+export type RunListExtraFilterFlags = {
+    outlierOnly: boolean;
+    errorsOnly: boolean;
+};
+
+export function parseRunListExtraFilters(
+    params: RunListExtraFilterParams,
+): RunListExtraFilterFlags {
+    return {
+        outlierOnly: params.outlier === "true",
+        errorsOnly: params.errors === "true",
+    };
+}
+
+export function hasActiveRunListExtraFilters(
+    flags: RunListExtraFilterFlags,
+): boolean {
+    return flags.outlierOnly || flags.errorsOnly;
+}
+
+export function buildPipelineErrorRunIdSet(runs: RunArtifact[]): Set<string> {
+    const ids = new Set<string>();
+    for (const row of buildPipelineErrorRows(runs)) {
+        ids.add(row.runId);
+    }
+    return ids;
+}
+
+export function applyRunListExtraFilters(
+    runs: RunArtifact[],
+    flags: RunListExtraFilterFlags,
+    context: {
+        outlierRunIds: Set<string>;
+        errorRunIds: Set<string>;
+    },
+): RunArtifact[] {
+    let result = runs;
+    if (flags.outlierOnly) {
+        result = result.filter((run) => context.outlierRunIds.has(run.id));
+    }
+    if (flags.errorsOnly) {
+        result = result.filter((run) => context.errorRunIds.has(run.id));
+    }
+    return result;
+}

From 42e302fccddbc06f562f4d4c82daa19c225e82ab Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 13 Jul 2026 08:07:43 +0000
Subject: [PATCH 2/3] feat(web): add compare shortcuts to activity feed

Attach same-question compare links for runs and benchmarks in the activity
timeline and include compareHref in CSV exports.

Co-authored-by: Eamon Boyle <eamonboyle@users.noreply.github.com>
---
 apps/web/app/activity/page.tsx       | 72 +++++++++++++++++-------
 apps/web/app/api/activity/route.ts   |  7 ++-
 apps/web/lib/activityCompare.test.ts | 83 ++++++++++++++++++++++++++++
 apps/web/lib/activityCompare.ts      | 68 +++++++++++++++++++++++
 apps/web/lib/activityExport.ts       |  2 +
 apps/web/lib/activityFeed.ts         |  1 +
 6 files changed, 213 insertions(+), 20 deletions(-)
 create mode 100644 apps/web/lib/activityCompare.test.ts
 create mode 100644 apps/web/lib/activityCompare.ts

diff --git a/apps/web/app/activity/page.tsx b/apps/web/app/activity/page.tsx
index c38bc88..2e8f701 100644
--- a/apps/web/app/activity/page.tsx
+++ b/apps/web/app/activity/page.tsx
@@ -11,6 +11,7 @@ import {
     buildActivityFeed,
     resolveActivitySortOrder,
 } from "../../lib/activityFeed";
+import { attachActivityCompareLinks } from "../../lib/activityCompare";
 import { collectArtifactFacets } from "../../lib/artifactFacets";
 import { loadBenchmarkArtifacts, loadRunArtifacts } from "../../lib/data";
 import { buildQueryString, paginateItems } from "../../lib/listPagination";
@@ -51,16 +52,20 @@ export default async function ActivityPage({
         loadBenchmarkArtifacts(),
     ]);
     const { models, presets } = collectArtifactFacets(runs, benchmarks);
-    const feed = buildActivityFeed(runs, benchmarks, {
-        kind,
-        q: params.q,
-        model: params.model,
-        preset: params.preset,
-        fast: params.fast,
-        from: params.from,
-        to: params.to,
-        sort,
-    });
+    const feed = attachActivityCompareLinks(
+        buildActivityFeed(runs, benchmarks, {
+            kind,
+            q: params.q,
+            model: params.model,
+            preset: params.preset,
+            fast: params.fast,
+            from: params.from,
+            to: params.to,
+            sort,
+        }),
+        runs,
+        benchmarks,
+    );
     const paging = paginateItems(feed, params, {
         defaultPageSize: 25,
         maxPageSize: 100,
@@ -280,6 +285,21 @@ export default async function ActivityPage({
                                     </Link>
                                 ),
                             },
+                            {
+                                key: "compare",
+                                label: "Compare",
+                                hideOnMobile: true,
+                                render: (row) => {
+                                    const href = (
+                                        row as { compareHref?: string }
+                                    ).compareHref;
+                                    return href ? (
+                                        <Link href={href}>Compare</Link>
+                                    ) : (
+                                        <span className="muted">—</span>
+                                    );
+                                },
+                            },
                         ]}
                         data={paging.paged.map((entry) => ({
                             ...entry,
@@ -289,15 +309,29 @@ export default async function ActivityPage({
                             `${(row as { kind: string }).kind}-${(row as { id: string }).id}`
                         }
                         renderCardActions={(row) => (
-                            <Link
-                                href={(row as { href: string }).href}
-                                className="button"
-                            >
-                                Open{" "}
-                                {(row as { kind: string }).kind === "run"
-                                    ? "trace"
-                                    : "benchmark"}
-                            </Link>
+                            <>
+                                <Link
+                                    href={(row as { href: string }).href}
+                                    className="button"
+                                >
+                                    Open{" "}
+                                    {(row as { kind: string }).kind === "run"
+                                        ? "trace"
+                                        : "benchmark"}
+                                </Link>
+                                {(row as { compareHref?: string })
+                                    .compareHref ? (
+                                    <Link
+                                        href={
+                                            (row as { compareHref: string })
+                                                .compareHref
+                                        }
+                                        className="button secondary"
+                                    >
+                                        Compare
+                                    </Link>
+                                ) : null}
+                            </>
                         )}
                     />
                 )}
diff --git a/apps/web/app/api/activity/route.ts b/apps/web/app/api/activity/route.ts
index 29e814a..61a605e 100644
--- a/apps/web/app/api/activity/route.ts
+++ b/apps/web/app/api/activity/route.ts
@@ -4,6 +4,7 @@ import {
     type ActivityFeedFilters,
 } from "../../../lib/activityFeed";
 import { activityEntriesToCsv } from "../../../lib/activityExport";
+import { attachActivityCompareLinks } from "../../../lib/activityCompare";
 import { loadBenchmarkArtifacts, loadRunArtifacts } from "../../../lib/data";
 import { parseListPagination } from "../_shared/pagination";
 
@@ -33,7 +34,11 @@ export async function GET(request: Request) {
         ),
     };
 
-    const feed = buildActivityFeed(runs, benchmarks, filters);
+    const feed = attachActivityCompareLinks(
+        buildActivityFeed(runs, benchmarks, filters),
+        runs,
+        benchmarks,
+    );
     const { offset, limit } = parseListPagination(url.searchParams);
     const items = feed.slice(offset, offset + limit);
 
diff --git a/apps/web/lib/activityCompare.test.ts b/apps/web/lib/activityCompare.test.ts
new file mode 100644
index 0000000..faf1d0f
--- /dev/null
+++ b/apps/web/lib/activityCompare.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import type { BenchmarkArtifact, RunArtifact } from "./data";
+import { buildActivityFeed } from "./activityFeed";
+import { attachActivityCompareLinks } from "./activityCompare";
+
+function sampleRun(
+    id: string,
+    question: string,
+    createdAt: string,
+): RunArtifact {
+    return {
+        kind: "run",
+        id,
+        question,
+        metadata: {
+            createdAt,
+            model: "gpt-test",
+            pipelinePreset: "standard",
+            fastMode: false,
+        },
+        run: {
+            id,
+            finalAnswer: "answer",
+            steps: [],
+            metrics: {},
+        },
+    };
+}
+
+function sampleBenchmark(
+    id: string,
+    question: string,
+    createdAt: string,
+): BenchmarkArtifact {
+    return {
+        kind: "benchmark",
+        id,
+        question,
+        metadata: {
+            createdAt,
+            model: "gpt-test",
+            pipelinePreset: "standard",
+            fastMode: false,
+        },
+        payload: {
+            runs: 3,
+            modeCount: 2,
+            modeSizes: [2, 1],
+            divergenceEntropy: 0.5,
+        },
+    };
+}
+
+describe("attachActivityCompareLinks", () => {
+    it("adds run compare links against the latest same-question peer", () => {
+        const runs = [
+            sampleRun("run_old", "Shared?", "2026-01-01T00:00:00.000Z"),
+            sampleRun("run_new", "Shared?", "2026-01-02T00:00:00.000Z"),
+        ];
+        const feed = buildActivityFeed(runs, [], { kind: "run" });
+        const linked = attachActivityCompareLinks(feed, runs, []);
+
+        expect(linked[0]?.compareHref).toBe(
+            "/runs/compare?left=run_new&right=run_old",
+        );
+        expect(linked[1]?.compareHref).toBe(
+            "/runs/compare?left=run_old&right=run_new",
+        );
+    });
+
+    it("adds benchmark compare links when another benchmark shares the question", () => {
+        const benchmarks = [
+            sampleBenchmark("bench_a", "Shared?", "2026-01-01T00:00:00.000Z"),
+            sampleBenchmark("bench_b", "Shared?", "2026-01-02T00:00:00.000Z"),
+        ];
+        const feed = buildActivityFeed([], benchmarks, { kind: "benchmark" });
+        const linked = attachActivityCompareLinks(feed, [], benchmarks);
+
+        expect(linked[0]?.compareHref).toBe(
+            "/benchmarks/compare?left=bench_b&right=bench_a",
+        );
+    });
+});
diff --git a/apps/web/lib/activityCompare.ts b/apps/web/lib/activityCompare.ts
new file mode 100644
index 0000000..81c8ac2
--- /dev/null
+++ b/apps/web/lib/activityCompare.ts
@@ -0,0 +1,68 @@
+import type { BenchmarkArtifact, RunArtifact } from "./data";
+import type { ActivityEntry } from "./activityFeed";
+
+function latestPeerId(
+    entries: Array<{ id: string; createdAt: string }>,
+    anchorId: string,
+): string | null {
+    const anchor = entries.find((entry) => entry.id === anchorId);
+    if (!anchor) return null;
+
+    const peer = entries
+        .filter((entry) => entry.id !== anchorId)
+        .sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
+
+    return peer?.id ?? null;
+}
+
+export function attachActivityCompareLinks(
+    entries: ActivityEntry[],
+    runs: RunArtifact[],
+    benchmarks: BenchmarkArtifact[],
+): ActivityEntry[] {
+    const runsByQuestion = new Map<string, RunArtifact[]>();
+    for (const run of runs) {
+        const bucket = runsByQuestion.get(run.question) ?? [];
+        bucket.push(run);
+        runsByQuestion.set(run.question, bucket);
+    }
+
+    const benchmarksByQuestion = new Map<string, BenchmarkArtifact[]>();
+    for (const benchmark of benchmarks) {
+        const bucket = benchmarksByQuestion.get(benchmark.question) ?? [];
+        bucket.push(benchmark);
+        benchmarksByQuestion.set(benchmark.question, bucket);
+    }
+
+    return entries.map((entry) => {
+        if (entry.kind === "run") {
+            const peers = runsByQuestion.get(entry.question) ?? [];
+            const peerId = latestPeerId(
+                peers.map((run) => ({
+                    id: run.id,
+                    createdAt: run.metadata.createdAt,
+                })),
+                entry.id,
+            );
+            if (!peerId) return entry;
+            return {
+                ...entry,
+                compareHref: `/runs/compare?left=${entry.id}&right=${peerId}`,
+            };
+        }
+
+        const peers = benchmarksByQuestion.get(entry.question) ?? [];
+        const peerId = latestPeerId(
+            peers.map((benchmark) => ({
+                id: benchmark.id,
+                createdAt: benchmark.metadata.createdAt,
+            })),
+            entry.id,
+        );
+        if (!peerId) return entry;
+        return {
+            ...entry,
+            compareHref: `/benchmarks/compare?left=${entry.id}&right=${peerId}`,
+        };
+    });
+}
diff --git a/apps/web/lib/activityExport.ts b/apps/web/lib/activityExport.ts
index 4a29f65..b4e33df 100644
--- a/apps/web/lib/activityExport.ts
+++ b/apps/web/lib/activityExport.ts
@@ -18,6 +18,7 @@ export function activityEntriesToCsv(entries: ActivityEntry[]): string {
         "fastMode",
         "detail",
         "href",
+        "compareHref",
     ];
     const rows = entries.map((entry) =>
         [
@@ -30,6 +31,7 @@ export function activityEntriesToCsv(entries: ActivityEntry[]): string {
             entry.fastMode ? "true" : "false",
             entry.detail,
             entry.href,
+            entry.compareHref ?? "",
         ]
             .map((value) => escapeCsv(String(value)))
             .join(","),
diff --git a/apps/web/lib/activityFeed.ts b/apps/web/lib/activityFeed.ts
index 829f17f..cbd4207 100644
--- a/apps/web/lib/activityFeed.ts
+++ b/apps/web/lib/activityFeed.ts
@@ -14,6 +14,7 @@ export type ActivityEntry = {
     fastMode: boolean;
     href: string;
     detail: string;
+    compareHref?: string;
 };
 
 export type ActivityFeedFilters = {

From 54409c5995914b10a8c339a9a44bad961027550d Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 13 Jul 2026 08:07:47 +0000
Subject: [PATCH 3/3] feat(web): export benchmark roster and question hub CSV

Add roster-csv export on benchmark detail API, question hub CSV API, and
export buttons on the corresponding pages.

Co-authored-by: Eamon Boyle <eamonboyle@users.noreply.github.com>
---
 apps/web/app/api/benchmarks/[id]/route.ts |  63 ++++++++-
 apps/web/app/api/questions/hub/route.ts   |  61 +++++++++
 apps/web/app/api/routes.test.ts           | 160 ++++++++++++++++++++++
 apps/web/app/benchmarks/[id]/page.tsx     |   7 +
 apps/web/app/questions/view/page.tsx      |  17 +++
 apps/web/lib/listExport.test.ts           |  30 ++++
 apps/web/lib/listExport.ts                |  82 +++++++++++
 7 files changed, 418 insertions(+), 2 deletions(-)
 create mode 100644 apps/web/app/api/questions/hub/route.ts

diff --git a/apps/web/app/api/benchmarks/[id]/route.ts b/apps/web/app/api/benchmarks/[id]/route.ts
index 9b59fd4..1495aee 100644
--- a/apps/web/app/api/benchmarks/[id]/route.ts
+++ b/apps/web/app/api/benchmarks/[id]/route.ts
@@ -1,15 +1,74 @@
-import { loadBenchmarkById } from "../../../../lib/data";
+import {
+    loadAnalysisIndex,
+    loadBenchmarkById,
+    loadBenchmarkPairsById,
+} from "../../../../lib/data";
+import {
+    buildBenchmarkRunRoster,
+    sortBenchmarkRunRoster,
+} from "../../../../lib/benchmarkRunRoster";
+import { findMostSimilarPeerRunId } from "../../../../lib/benchmarkPeers";
+import { benchmarkRunRosterToCsv } from "../../../../lib/listExport";
+import { buildBenchmarkOutlierLookup } from "../../../../lib/outlierLookup";
 
 export async function GET(
     request: Request,
     context: { params: Promise<{ id: string }> },
 ) {
     const { id } = await context.params;
+    const url = new URL(request.url);
+    const format = url.searchParams.get("format") ?? "json";
     const benchmark = await loadBenchmarkById(id);
     if (!benchmark) {
         return Response.json({ error: "benchmark not found" }, { status: 404 });
     }
-    const download = new URL(request.url).searchParams.get("download") === "1";
+
+    if (format === "roster-csv") {
+        const [pairsData, index] = await Promise.all([
+            loadBenchmarkPairsById(id),
+            loadAnalysisIndex(),
+        ]);
+        const pairs =
+            pairsData.pairs.length > 0
+                ? pairsData.pairs
+                : (benchmark.payload.summary?.stability?.pairs ?? []);
+        const rosterRunIds =
+            pairsData.runIds.length > 0
+                ? pairsData.runIds
+                : (benchmark.payload.runIds ?? []);
+        const outlierLookup = buildBenchmarkOutlierLookup(index, benchmark.id);
+        const roster = sortBenchmarkRunRoster(
+            buildBenchmarkRunRoster({
+                runIds: rosterRunIds,
+                pairs,
+                modes: benchmark.payload.modes,
+            }),
+        ).map((row) => {
+            const peerRunId = findMostSimilarPeerRunId(
+                row.runId,
+                rosterRunIds,
+                pairs,
+            );
+            return {
+                ...row,
+                peerRunId,
+                peerCompareHref: peerRunId
+                    ? `/runs/compare?left=${row.runId}&right=${peerRunId}`
+                    : null,
+                isOutlier: outlierLookup.has(row.runId),
+            };
+        });
+        const csv = benchmarkRunRosterToCsv(roster);
+        return new Response(csv, {
+            headers: {
+                "Content-Type": "text/csv; charset=utf-8",
+                "Content-Disposition": `attachment; filename="${id}-roster.csv"`,
+                "Cache-Control": "public, max-age=60",
+            },
+        });
+    }
+
+    const download = url.searchParams.get("download") === "1";
     const headers = download
         ? {
               "Content-Disposition": `attachment; filename="${id}.json"`,
diff --git a/apps/web/app/api/questions/hub/route.ts b/apps/web/app/api/questions/hub/route.ts
new file mode 100644
index 0000000..b56af3d
--- /dev/null
+++ b/apps/web/app/api/questions/hub/route.ts
@@ -0,0 +1,61 @@
+import {
+    filterBenchmarkArtifacts,
+    filterRunArtifacts,
+    loadBenchmarkArtifacts,
+    loadRunArtifacts,
+} from "../../../../lib/data";
+import { questionHubArtifactsToCsv } from "../../../../lib/listExport";
+
+export async function GET(request: Request) {
+    const url = new URL(request.url);
+    const question = (url.searchParams.get("question") ?? "").trim();
+    if (!question) {
+        return Response.json(
+            { error: "question query parameter is required" },
+            { status: 400 },
+        );
+    }
+
+    const format = url.searchParams.get("format") ?? "json";
+    const filters = {
+        q: url.searchParams.get("q") ?? undefined,
+        model: url.searchParams.get("model") ?? undefined,
+        preset: url.searchParams.get("preset") ?? undefined,
+        fast: url.searchParams.get("fast") ?? undefined,
+        from: url.searchParams.get("from") ?? undefined,
+        to: url.searchParams.get("to") ?? undefined,
+    };
+
+    const [allRuns, allBenchmarks] = await Promise.all([
+        loadRunArtifacts(),
+        loadBenchmarkArtifacts(),
+    ]);
+    const runs = filterRunArtifacts(allRuns, filters).filter(
+        (run) => run.question === question,
+    );
+    const benchmarks = filterBenchmarkArtifacts(allBenchmarks, filters).filter(
+        (benchmark) => benchmark.question === question,
+    );
+
+    if (format === "csv") {
+        const csv = questionHubArtifactsToCsv(question, runs, benchmarks);
+        const slug = question.slice(0, 48).replace(/[^\w.-]+/g, "_");
+        return new Response(csv, {
+            headers: {
+                "Content-Type": "text/csv; charset=utf-8",
+                "Content-Disposition": `attachment; filename="question-hub-${slug || "export"}.csv"`,
+                "Cache-Control": "public, max-age=60",
+            },
+        });
+    }
+
+    return Response.json({
+        question,
+        totals: {
+            runs: runs.length,
+            benchmarks: benchmarks.length,
+        },
+        runs,
+        benchmarks,
+    });
+}
diff --git a/apps/web/app/api/routes.test.ts b/apps/web/app/api/routes.test.ts
index 5287980..5e959c7 100644
--- a/apps/web/app/api/routes.test.ts
+++ b/apps/web/app/api/routes.test.ts
@@ -32,6 +32,7 @@ import { GET as getOutliers } from "./outliers/route";
 import { GET as getCatalog } from "./catalog/route";
 import { POST as postAnalysisRebuild } from "./analysis/rebuild/route";
 import { GET as getQuestions } from "./questions/route";
+import { GET as getQuestionsHub } from "./questions/hub/route";
 import { GET as getPairs } from "./pairs/route";
 import { GET as getErrors } from "./errors/route";
 
@@ -2314,6 +2315,165 @@ describe("web api routes", () => {
         expect(await csvResponse.text()).toContain("Shared topic");
     });
 
+    it("exports question hub artifacts as CSV", async () => {
+        const dir = await makeTempDir();
+        process.env.RUNS_DIR = dir;
+        await writeFile(
+            join(dir, "run_a.json"),
+            JSON.stringify({
+                kind: "run",
+                id: "run_a",
+                question: "Hub topic",
+                metadata: {
+                    createdAt: "2026-01-02T00:00:00.000Z",
+                    model: "gpt-a",
+                    pipelinePreset: "standard",
+                    fastMode: false,
+                },
+                run: { id: "run_a", finalAnswer: "A", steps: [], metrics: {} },
+            }),
+            "utf-8",
+        );
+        await writeFile(
+            join(dir, "benchmark_a.json"),
+            JSON.stringify({
+                kind: "benchmark",
+                id: "benchmark_a",
+                question: "Hub topic",
+                metadata: {
+                    createdAt: "2026-01-01T00:00:00.000Z",
+                    model: "gpt-a",
+                    pipelinePreset: "standard",
+                    fastMode: false,
+                },
+                payload: {
+                    runs: 2,
+                    modeCount: 1,
+                    modeSizes: [2],
+                    divergenceEntropy: 0.2,
+                    summary: { stability: { pairwiseMean: 0.9, pairs: [] } },
+                },
+            }),
+            "utf-8",
+        );
+
+        const response = await getQuestionsHub(
+            new Request(
+                "http://localhost/api/questions/hub?question=Hub%20topic&format=csv",
+            ),
+        );
+        expect(response.status).toBe(200);
+        const csv = await response.text();
+        expect(csv).toContain("Hub topic");
+        expect(csv).toContain("run_a");
+        expect(csv).toContain("benchmark_a");
+    });
+
+    it("filters runs API by pipeline errors", async () => {
+        const dir = await makeTempDir();
+        process.env.RUNS_DIR = dir;
+        await writeFile(
+            join(dir, "run_ok.json"),
+            JSON.stringify({
+                kind: "run",
+                id: "run_ok",
+                question: "Alpha",
+                metadata: {
+                    createdAt: "2026-01-01T00:00:00.000Z",
+                    model: "gpt-a",
+                    pipelinePreset: "standard",
+                    fastMode: false,
+                },
+                run: { id: "run_ok", finalAnswer: "A", steps: [], metrics: {} },
+            }),
+            "utf-8",
+        );
+        await writeFile(
+            join(dir, "run_fail.json"),
+            JSON.stringify({
+                kind: "run",
+                id: "run_fail",
+                question: "Beta",
+                metadata: {
+                    createdAt: "2026-01-02T00:00:00.000Z",
+                    model: "gpt-a",
+                    pipelinePreset: "standard",
+                    fastMode: false,
+                },
+                run: {
+                    id: "run_fail",
+                    finalAnswer: "B",
+                    steps: [
+                        {
+                            agentName: "Solver",
+                            role: "solver",
+                            createdAt: "2026-01-02T00:00:00.000Z",
+                            error: "timeout",
+                        },
+                    ],
+                    metrics: {},
+                },
+            }),
+            "utf-8",
+        );
+
+        const response = await getRuns(
+            new Request("http://localhost/api/runs?errors=true"),
+        );
+        expect(response.status).toBe(200);
+        const json = (await response.json()) as {
+            filtered: number;
+            items: Array<{ id: string }>;
+        };
+        expect(json.filtered).toBe(1);
+        expect(json.items[0].id).toBe("run_fail");
+    });
+
+    it("exports benchmark roster CSV", async () => {
+        const dir = await makeTempDir();
+        process.env.RUNS_DIR = dir;
+        await writeFile(
+            join(dir, "benchmark_roster.json"),
+            JSON.stringify({
+                kind: "benchmark",
+                id: "benchmark_roster",
+                question: "Roster topic",
+                metadata: {
+                    createdAt: "2026-01-01T00:00:00.000Z",
+                    model: "gpt-a",
+                    pipelinePreset: "standard",
+                    fastMode: false,
+                },
+                payload: {
+                    runs: 2,
+                    modeCount: 1,
+                    modeSizes: [2],
+                    divergenceEntropy: 0.2,
+                    runIds: ["run_a", "run_b"],
+                    modes: [{ members: [0, 1] }],
+                    summary: {
+                        stability: {
+                            pairwiseMean: 0.5,
+                            pairs: [{ i: 0, j: 1, similarity: 0.5 }],
+                        },
+                    },
+                },
+            }),
+            "utf-8",
+        );
+
+        const response = await getBenchmarkById(
+            new Request(
+                "http://localhost/api/benchmarks/benchmark_roster?format=roster-csv",
+            ),
+            { params: Promise.resolve({ id: "benchmark_roster" }) },
+        );
+        expect(response.status).toBe(200);
+        const csv = await response.text();
+        expect(csv).toContain("run_a");
+        expect(csv).toContain("avgSimilarity");
+    });
+
     it("returns filtered activity feed as JSON and CSV", async () => {
         const dir = await makeTempDir();
         process.env.RUNS_DIR = dir;
diff --git a/apps/web/app/benchmarks/[id]/page.tsx b/apps/web/app/benchmarks/[id]/page.tsx
index 93b9c36..dbbbb1e 100644
--- a/apps/web/app/benchmarks/[id]/page.tsx
+++ b/apps/web/app/benchmarks/[id]/page.tsx
@@ -143,6 +143,13 @@ export default async function BenchmarkDetailPage({
                         href={`/api/benchmarks/${benchmark.id}?download=1`}
                         filename={`${benchmark.id}.json`}
                     />
+                    <a
+                        href={`/api/benchmarks/${benchmark.id}?format=roster-csv`}
+                        className="button secondary"
+                        download={`${benchmark.id}-roster.csv`}
+                    >
+                        Export roster CSV
+                    </a>
                     <CopyPageLink />
                     <Link
                         href={questionHubHref(benchmark.question)}
diff --git a/apps/web/app/questions/view/page.tsx b/apps/web/app/questions/view/page.tsx
index 8c05f5d..b11b9d1 100644
--- a/apps/web/app/questions/view/page.tsx
+++ b/apps/web/app/questions/view/page.tsx
@@ -309,6 +309,23 @@ export default async function QuestionHubPage({
                             Compare benchmarks (picker)
                         </Link>
                     ) : null}
+                    <a
+                        href={`/api/questions/hub${buildQueryString(
+                            {
+                                question,
+                                model: params.model,
+                                preset: params.preset,
+                                fast: params.fast,
+                                from: params.from,
+                                to: params.to,
+                            },
+                            {},
+                        )}&format=csv`}
+                        className="button secondary"
+                        download="question-hub.csv"
+                    >
+                        Export hub CSV
+                    </a>
                 </div>
             </div>
 
diff --git a/apps/web/lib/listExport.test.ts b/apps/web/lib/listExport.test.ts
index 0be7d6f..f7b37c5 100644
--- a/apps/web/lib/listExport.test.ts
+++ b/apps/web/lib/listExport.test.ts
@@ -4,6 +4,7 @@ import {
     agentStatsToCsv,
     agentTimingToCsv,
     benchmarkArtifactsToCsv,
+    benchmarkRunRosterToCsv,
     confidenceDriftToCsv,
     counterfactualExplorerToCsv,
     evidenceExplorerToCsv,
@@ -13,6 +14,7 @@ import {
     presetLeaderboardToCsv,
     qualityRunsToCsv,
     questionGroupsToCsv,
+    questionHubArtifactsToCsv,
     runArtifactsToCsv,
     searchResultsToCsv,
 } from "./listExport";
@@ -286,4 +288,32 @@ describe("listExport", () => {
         expect(csv).toContain("missing evidence");
         expect(csv).toContain("run_1");
     });
+
+    it("exports benchmark roster rows", () => {
+        const csv = benchmarkRunRosterToCsv([
+            {
+                runIndex: 0,
+                runId: "run_a",
+                avgSimilarity: 0.42,
+                modeIndex: 1,
+                peerRunId: "run_b",
+                peerCompareHref: "/runs/compare?left=run_a&right=run_b",
+                isOutlier: true,
+            },
+        ]);
+        expect(csv).toContain("run_a");
+        expect(csv).toContain("isOutlier");
+        expect(csv).toContain("true");
+    });
+
+    it("exports question hub artifacts", () => {
+        const csv = questionHubArtifactsToCsv(
+            "Shared topic?",
+            [sampleRun],
+            [sampleBenchmark],
+        );
+        expect(csv).toContain("Shared topic?");
+        expect(csv).toContain("run_1");
+        expect(csv).toContain("bench_1");
+    });
 });
diff --git a/apps/web/lib/listExport.ts b/apps/web/lib/listExport.ts
index 82387ad..2723267 100644
--- a/apps/web/lib/listExport.ts
+++ b/apps/web/lib/listExport.ts
@@ -1,3 +1,4 @@
+import type { BenchmarkRunRosterRow } from "./benchmarkRunRoster";
 import type { AgentStatRow } from "./agentStats";
 import type { CatalogStats } from "./catalogStats";
 import type { ConfidenceDriftRow } from "./confidenceDrift";
@@ -553,6 +554,87 @@ export function evidenceExplorerToCsv(
     return sections.join("\n");
 }
 
+export function benchmarkRunRosterToCsv(
+    rows: Array<
+        BenchmarkRunRosterRow & {
+            peerRunId?: string | null;
+            peerCompareHref?: string | null;
+            isOutlier?: boolean;
+        }
+    >,
+): string {
+    const header = [
+        "runIndex",
+        "runId",
+        "modeIndex",
+        "avgSimilarity",
+        "peerRunId",
+        "peerCompareHref",
+        "isOutlier",
+    ];
+    const csvRows = rows.map((entry) =>
+        row([
+            entry.runIndex,
+            entry.runId,
+            entry.modeIndex ?? "",
+            entry.avgSimilarity ?? "",
+            entry.peerRunId ?? "",
+            entry.peerCompareHref ?? "",
+            entry.isOutlier ? "true" : "false",
+        ]),
+    );
+    return [header.join(","), ...csvRows].join("\n");
+}
+
+export function questionHubArtifactsToCsv(
+    question: string,
+    runs: RunArtifact[],
+    benchmarks: BenchmarkArtifact[],
+): string {
+    const sections: string[] = [];
+    sections.push(`question,${escapeCsv(question)}`);
+    sections.push("");
+    sections.push(
+        "section,id,createdAt,model,preset,fastMode,runs,modeCount,entropy,finalAnswerPreview",
+    );
+
+    for (const run of runs) {
+        sections.push(
+            row([
+                "run",
+                run.id,
+                run.metadata.createdAt,
+                run.metadata.model,
+                run.metadata.pipelinePreset,
+                run.metadata.fastMode,
+                "",
+                "",
+                "",
+                run.run.finalAnswer.slice(0, 200),
+            ]),
+        );
+    }
+
+    for (const benchmark of benchmarks) {
+        sections.push(
+            row([
+                "benchmark",
+                benchmark.id,
+                benchmark.metadata.createdAt,
+                benchmark.metadata.model,
+                benchmark.metadata.pipelinePreset,
+                benchmark.metadata.fastMode,
+                benchmark.payload.runs,
+                benchmark.payload.modeCount,
+                benchmark.payload.divergenceEntropy,
+                "",
+            ]),
+        );
+    }
+
+    return sections.join("\n");
+}
+
 export function catalogStatsToCsv(stats: CatalogStats): string {
     const sections: string[] = [];