feat(web): runs filters, activity compare, CSV exports

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}
+                            </>
                         )}
                     />
                 )}

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);
 

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"`,

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,
+    });
+}