diff --git a/dashboard/src/App.tsx b/dashboard/src/App.tsx
index e751ab7..dc26d7b 100644
--- a/dashboard/src/App.tsx
+++ b/dashboard/src/App.tsx
@@ -24,8 +24,8 @@ export function App() {
   return (
     <div className="dashboard-app">
       <AppHeader section={section} />
-      <main className="dashboard-main" data-layout={section === "differential-testing" || section === "streaming-diff" || selected ? "full" : "index"} data-section={section}>
-        {section === "differential-testing" ? <DifferentialTestingPage /> : section === "streaming-diff" ? <StreamingDiff projects={projects} projectsLoading={loading} /> : section === "new-oven" ? <NewOvenPage /> : section === "run-burn" ? <RunBurnPage /> : selected ? (
+      <main className="dashboard-main" data-layout={section === "differential-testing" || section === "performance-tracing" || section === "streaming-diff" || selected ? "full" : "index"} data-section={section}>
+        {section === "differential-testing" ? <DifferentialTestingPage /> : section === "performance-tracing" ? <DifferentialTestingPage ovenId="performance-tracing" /> : section === "streaming-diff" ? <StreamingDiff projects={projects} projectsLoading={loading} /> : section === "new-oven" ? <NewOvenPage /> : section === "run-burn" ? <RunBurnPage /> : selected ? (
           error ? <DashboardError message={error} /> : loading && !progress ? <EmptyState title="Loading progress" detail="Reading the selected Burnlist." /> : progress ? (
             <ChecklistDashboard backHref={listHref(filter)} data={progress} />
           ) : <EmptyState title="Choose a Burnlist" detail="Select an item from the list to inspect its progress." icon={ListChecks} />
diff --git a/dashboard/src/components/AppHeader/AppHeader.tsx b/dashboard/src/components/AppHeader/AppHeader.tsx
index 5a978fc..6d6b21c 100644
--- a/dashboard/src/components/AppHeader/AppHeader.tsx
+++ b/dashboard/src/components/AppHeader/AppHeader.tsx
@@ -13,9 +13,10 @@ export function AppHeader({ section }: { section: string }) {
           <span className="dashboard-brand-name">Burnlist</span>
         </a>
         {section === "differential-testing" && <div className="dashboard-oven-title">Differential Testing</div>}
+        {section === "performance-tracing" && <div className="dashboard-oven-title">Performance Tracing</div>}
         {section === "streaming-diff" && <div className="dashboard-oven-title">Streaming Diff</div>}
         <nav aria-label="Primary navigation" className="dashboard-primary-nav">
-          {section !== "differential-testing" && section !== "streaming-diff" && HEADER_LINKS.map((link, index) => (
+          {section !== "differential-testing" && section !== "performance-tracing" && section !== "streaming-diff" && HEADER_LINKS.map((link, index) => (
             <span className="dashboard-primary-nav-item" key={link.href}>
               {index > 0 && <span aria-hidden="true" className="dashboard-primary-nav-separator">·</span>}
               <a aria-label={link.label} aria-current={section === link.section ? "page" : undefined} className="dashboard-primary-nav-link" href={link.href} title={link.label}>
diff --git a/dashboard/src/components/DifferentialTesting/DifferentialTesting.tsx b/dashboard/src/components/DifferentialTesting/DifferentialTesting.tsx
index f3c5a99..3b8c517 100644
--- a/dashboard/src/components/DifferentialTesting/DifferentialTesting.tsx
+++ b/dashboard/src/components/DifferentialTesting/DifferentialTesting.tsx
@@ -1,21 +1,40 @@
 import { useEffect, useRef } from "react";
-import { ovenRepoKey } from "@lib";
+import { adaptPerformanceTracingReport, ovenRepoKey } from "@lib";
 // @ts-expect-error The canonical renderer is plain ESM so React and the direct Oven route share one implementation.
 import { startDifferentialTestingLiveUpdates } from "../../../../ovens/differential-testing/renderer/differential-testing-renderer.js";
 
-export function DifferentialTestingPage() {
+export function DifferentialTestingPage({ ovenId = "differential-testing" }: { ovenId?: "differential-testing" | "performance-tracing" }) {
   const root = useRef<HTMLDivElement>(null);
 
   useEffect(() => {
     document.body.classList.add("driving-parity-view");
-    return () => document.body.classList.remove("driving-parity-view");
-  }, []);
+    if (ovenId === "performance-tracing") document.body.classList.add("performance-tracing-oven");
+    return () => {
+      document.body.classList.remove("driving-parity-view");
+      document.body.classList.remove("performance-tracing-oven");
+    };
+  }, [ovenId]);
 
   useEffect(() => {
     if (!root.current) return;
-    const controller = startDifferentialTestingLiveUpdates(root.current, { repoKey: ovenRepoKey() });
+    const performanceTracing = ovenId === "performance-tracing";
+    const controller = startDifferentialTestingLiveUpdates(root.current, {
+      repoKey: ovenRepoKey(),
+      dataOvenId: ovenId,
+      ...(performanceTracing ? {
+        adaptPayload: adaptPerformanceTracingReport,
+        mountOptions: { initialChart: "current", initialProgressChart: "delta" },
+        onError: (error: unknown) => {
+          if (!root.current) return;
+          const message = document.createElement("div");
+          message.className = "empty";
+          message.textContent = error instanceof Error ? error.message : String(error);
+          root.current.replaceChildren(message);
+        },
+      } : {}),
+    });
     return () => controller.stop();
-  }, []);
+  }, [ovenId]);
 
-  return <div ref={root} className="shell driving-parity-view" />;
+  return <div ref={root} className={`shell driving-parity-view${ovenId === "performance-tracing" ? " performance-tracing-oven" : ""}`} />;
 }
diff --git a/dashboard/src/lib/hrefs.ts b/dashboard/src/lib/hrefs.ts
index ac76856..c909f40 100644
--- a/dashboard/src/lib/hrefs.ts
+++ b/dashboard/src/lib/hrefs.ts
@@ -3,13 +3,14 @@ import type { Burnlist, Filter, SelectedBurnlist } from "./types";
 export function currentSection() {
   if (window.location.pathname === "/ovens/new") return "new-oven";
   if (window.location.pathname === "/ovens/differential-testing/view") return "differential-testing";
+  if (window.location.pathname === "/ovens/performance-tracing/view") return "performance-tracing";
   if (window.location.pathname === "/ovens/streaming-diff/view") return "streaming-diff";
   if (window.location.pathname === "/runs/new") return "run-burn";
   return "burnlists";
 }
 
 export function ovenRepoKey() {
-  return ["differential-testing", "streaming-diff"].includes(currentSection())
+  return ["differential-testing", "performance-tracing", "streaming-diff"].includes(currentSection())
     ? new URLSearchParams(window.location.search).get("repoKey")
     : null;
 }
diff --git a/dashboard/src/lib/index.ts b/dashboard/src/lib/index.ts
index 432a15a..7fc8192 100644
--- a/dashboard/src/lib/index.ts
+++ b/dashboard/src/lib/index.ts
@@ -1,5 +1,6 @@
 export { formatTime } from "./format";
 export { burnlistHref, currentSection, filterFromUrl, listHref, ovenRepoKey, selectedBurnlist, streamingDiffSelection } from "./hrefs";
+export { adaptPerformanceTracingReport } from "./performance-tracing.mjs";
 export { applyStreamingDiffUpdate, fileKindChip, groupStreamingDiffCard, isTextFileKind, mapStreamingDiffFeeds, mapStreamingDiffLandingFeeds, parseStreamingDiffCard, streamingDiffAutoOpenHref, streamingDiffFeedHref, streamingDiffFeedKey, streamingDiffRepositories } from "./streaming-diff.mjs";
 export type { Burnlist, ChecklistProgressData, ChecklistItem, CompletedItem, Filter, HistoryPoint, ProgressData, Project, SelectedBurnlist, StreamingDiffCard, StreamingDiffFeed, StreamingDiffFile, StreamingDiffFileKind, StreamingDiffIdentity, Warning } from "./types";
 export { cn, joinClasses } from "./utils";
diff --git a/dashboard/src/lib/performance-tracing.mjs b/dashboard/src/lib/performance-tracing.mjs
new file mode 100644
index 0000000..b6d3a90
--- /dev/null
+++ b/dashboard/src/lib/performance-tracing.mjs
@@ -0,0 +1,127 @@
+const metricDefinitions = [
+  { id: "startup.ready", label: "startup.ready", metric: "startupReadyMs", budget: "startupReadyMs" },
+  { id: "frame.p95", label: "frame.p95", metric: "p95FrameMs", budget: "p95FrameMs" },
+  { id: "frame.p99", label: "frame.p99", metric: "p99FrameMs", budget: "p99FrameMs" },
+  { id: "frame.max", label: "frame.max", metric: "maxFrameMs", budget: "maxFrameMs" },
+  { id: "frame.over33", label: "frame.over33", metric: "over33msRatio", budget: "over33msRatio" },
+  { id: "step.p95", label: "step.p95", metric: "p95StepCallMs", budget: "p95StepCallMs" },
+];
+
+function finite(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function reportHistory(report) {
+  const fallback = [{
+    runId: report.runId,
+    generatedAt: report.generatedAt,
+    status: report.status,
+    comparisonKey: "current-report",
+    metrics: report.metrics ?? {},
+    budgets: report.budgets ?? {},
+  }];
+  if (!Array.isArray(report.history) || !report.history.length) return fallback;
+  const current = [...report.history].reverse().find((point) => point.runId === report.runId
+    && point.generatedAt === report.generatedAt) ?? report.history.at(-1);
+  if (!current?.comparisonKey) return fallback;
+  const comparable = report.history.filter((point) => point.comparisonKey === current.comparisonKey);
+  return comparable.length ? comparable : fallback;
+}
+
+function passCount(point) {
+  return metricDefinitions.reduce((total, definition) => {
+    const actual = finite(point.metrics?.[definition.metric]);
+    const limit = finite(point.budgets?.[definition.budget]);
+    return total + (actual !== null && limit !== null && actual <= limit ? 1 : 0);
+  }, 0);
+}
+
+export function adaptPerformanceTracingReport(report) {
+  const history = reportHistory(report);
+  const fields = metricDefinitions.map((definition) => {
+    const samples = history.map((point, index) => {
+      const actual = finite(point.metrics?.[definition.metric]);
+      const limit = finite(point.budgets?.[definition.budget]);
+      if (actual === null || limit === null) return [index, limit, actual, 3];
+      return [index, limit, actual, actual <= limit ? 0 : 1];
+    });
+    const failedSampleCount = samples.filter((sample) => sample[3] === 1).length;
+    const missingSampleCount = samples.filter((sample) => sample[3] !== 0 && sample[3] !== 1).length;
+    const deltas = samples
+      .map((sample) => sample[1] === null || sample[2] === null ? null : Math.abs(Number(sample[2]) - Number(sample[1])))
+      .filter((value) => value !== null);
+    return {
+      id: definition.id,
+      label: definition.label,
+      samples,
+      sampleLabels: history.map((point) => new Date(point.generatedAt).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })),
+      failedSampleCount,
+      missingSampleCount,
+      trustStatus: missingSampleCount ? "blocked" : "pass",
+      maxDelta: deltas.length ? Math.max(...deltas) : null,
+      sourceOwner: `performance trace / ${definition.metric}`,
+      semantics: { kind: "number", meaning: `${definition.metric} measured against ${definition.budget}` },
+    };
+  });
+
+  const progress = history.map((point, index) => {
+    const frame = passCount(point);
+    const previous = index > 0 ? passCount(history[index - 1]) : null;
+    return {
+      timestamp: point.generatedAt,
+      frame,
+      frames: metricDefinitions.length,
+      frameDelta: previous === null ? null : frame - previous,
+    };
+  });
+  const log = history.map((point, index) => {
+    const frame = passCount(point);
+    const previous = index > 0 ? passCount(history[index - 1]) : null;
+    const frameDelta = previous === null ? null : frame - previous;
+    return {
+      timestamp: point.generatedAt,
+      frame,
+      frames: metricDefinitions.length,
+      frameDelta,
+      firstFailingTick: null,
+      result: frameDelta === null ? point.status === "pass" ? "pass" : "blocked" : frameDelta > 0 ? "improved" : frameDelta < 0 ? "worsened" : "unchanged",
+    };
+  }).reverse();
+  const failedFields = fields.filter((field) => field.failedSampleCount > 0).length;
+  const blockedFields = fields.filter((field) => field.missingSampleCount > 0).length;
+  const frameTimingSeries = Array.isArray(report.runs?.[0]?.frameTiming?.series) ? report.runs[0].frameTiming.series : [];
+  const frameLimit = finite(report.budgets?.p95FrameMs);
+  const primaryChartSamples = frameTimingSeries.map((sample, index) => {
+    const actual = finite(sample.frameMs);
+    return [Number(sample.frame ?? index), frameLimit, actual, frameLimit === null || actual === null || actual <= frameLimit ? 0 : 1];
+  });
+
+  return {
+    subtitle: report.runId ?? "retained performance trace",
+    publishedAt: report.generatedAt,
+    scenarioCatalog: {
+      selectedScenarioId: report.scenario?.id ?? "performance-tracing",
+      scenarios: [{ id: report.scenario?.id ?? "performance-tracing" }],
+    },
+    refresh: null,
+    primaryChartTitle: "Frame timing",
+    historyTitle: "History log",
+    primaryChartField: {
+      id: "frame.p95.history",
+      label: "frame.timing",
+      samples: primaryChartSamples,
+    },
+    progress,
+    log,
+    fields,
+    summary: {
+      fields: { total: fields.length, failed: failedFields, blocked: blockedFields },
+      frames: {
+        total: history.length,
+        failed: history.filter((point) => point.status !== "pass").length,
+        blocked: 0,
+      },
+    },
+  };
+}
diff --git a/ovens/differential-testing/renderer/differential-testing-renderer.js b/ovens/differential-testing/renderer/differential-testing-renderer.js
index 8dd5b4c..03cc733 100644
--- a/ovens/differential-testing/renderer/differential-testing-renderer.js
+++ b/ovens/differential-testing/renderer/differential-testing-renderer.js
@@ -157,6 +157,8 @@ export function mountDifferentialTestingDashboard(root, oven, payload, {
   onFieldViewChange = () => {},
   fieldPage = null,
   frameDeltaMetrics = null,
+  initialChart = "delta",
+  initialProgressChart = "delta",
   templateOnly = false,
 } = {}) {
   if (templateOnly) return templateHtml();
@@ -166,8 +168,8 @@ export function mountDifferentialTestingDashboard(root, oven, payload, {
   const RED = "#ef4444";
   const telemetryAvailability = differentialTelemetryAvailability(payload);
   const state = {
-    chart: "delta",
-    progressChart: "delta",
+    chart: initialChart === "current" ? "current" : "delta",
+    progressChart: initialProgressChart,
     sort: fieldPage?.sort ?? (telemetryAvailability.status === "comparable" ? "changed" : "default"),
     filter: fieldPage?.filter ?? "all",
     search: fieldPage?.search ?? "",
@@ -413,7 +415,7 @@ export function mountDifferentialTestingDashboard(root, oven, payload, {
     if (current) result.push(current);
     return result;
   }
-  function chart(field, showFrameLabels = false) {
+  function chart(field, showFrameLabels = false, chartMode = state.chart) {
     const categories = new Map();
     const rows = field.samples.map(([tick, reference, candidate, sampleState]) => ({ tick, reference: plotValue(reference, categories), candidate: plotValue(candidate, categories), state: sampleState }));
     const x = (index) => rows.length <= 1 ? 0 : index / (rows.length - 1) * WIDTH;
@@ -437,7 +439,7 @@ export function mountDifferentialTestingDashboard(root, oven, payload, {
     for (let index = frameStep; index < rows.length - 1; index += frameStep * 2) tickIndexes.push(index);
     const tickMarks = tickIndexes.map((index) => `<line class="frame-tick" x1="${x(index).toFixed(1)}" x2="${x(index).toFixed(1)}" y1="${showFrameLabels ? 13 : 0}" y2="${HEIGHT}" stroke="rgba(168, 168, 168, 0.075)" stroke-width="1" vector-effect="non-scaling-stroke" shape-rendering="crispEdges"/>`).join("");
     const tickLabels = showFrameLabels
-      ? tickIndexes.map((index) => `<span class="frame-tick-label" style="left:${(index / Math.max(1, rows.length - 1) * 100).toFixed(4)}%">${escapeHtml(Math.round(rows[index].tick))}</span>`).join("")
+      ? tickIndexes.map((index) => `<span class="frame-tick-label" style="left:${(index / Math.max(1, rows.length - 1) * 100).toFixed(4)}%">${escapeHtml(field.sampleLabels?.[index] || Math.round(rows[index].tick))}</span>`).join("")
       : "";
     const segment = (start, end, trimStart = 0, trimEnd = 0) => {
       let [x1, y1] = start, [x2, y2] = end;
@@ -457,7 +459,7 @@ export function mountDifferentialTestingDashboard(root, oven, payload, {
       }
       return result.join("");
     };
-    if (state.chart === "delta") {
+    if (chartMode === "delta") {
       const values = rows.map((row) => row.reference === null || row.candidate === null ? null : row.candidate - row.reference);
       const finite = values.filter(Number.isFinite);
       if (!finite.length) return '<div class="plot"></div>';
@@ -581,6 +583,7 @@ export function mountDifferentialTestingDashboard(root, oven, payload, {
   function renderProgressChart() {
     const progressChart = root.querySelector("#progress-chart");
     if (!progressChart) return;
+    if (state.payload.primaryChartField) return;
     if (state.progressChart === "delta") {
       const exactMetrics = differentialExactPrefixFrameDeltaMetrics(state.payload, state.frameDeltaMetrics);
       if (!exactMetrics) {
@@ -1617,14 +1620,21 @@ export function mountDifferentialTestingDashboard(root, oven, payload, {
       value: scenarioSelector(),
     });
     const kpiHtml = `${scenarioKpi}${progressDonut(state.payload.progress)}${burnDonut(state.payload.log)}${waffleMetric(state.payload.summary.fields, "Fields")}${waffleMetric(state.payload.summary.frames, "Frames")}`;
+    const primaryChartField = state.payload.primaryChartField;
+    const primaryChartTitle = String(state.payload.primaryChartTitle || "Parity Progress");
+    const historyTitle = String(state.payload.historyTitle || "Parity Progress");
+    const primaryChartMarkup = primaryChartField
+      ? `<div class="chart hybrid-chart" id="progress-chart" role="img" aria-label="${escapeHtml(primaryChartTitle)} over time">${chart(primaryChartField, true, state.progressChart === "delta" ? "delta" : "value")}</div>`
+      : progress(state.payload.progress);
     let html = templateHtml()
       .replace('<main id="burnlist-detail" class="detail-view" hidden>', '<main id="burnlist-detail" class="detail-view">')
       .replace('<section class="differential-overview" id="differential-overview" hidden>', '<section class="differential-overview" id="differential-overview">')
       .replace('<span id="differential-refresh-status" class="differential-refresh-status" hidden></span>', refreshStatus())
       .replace('<time id="differential-overview-time"></time>', `<time id="differential-overview-time" class="label-toggle differential-tabs" datetime="${escapeHtml(state.payload.publishedAt)}">${overviewTime(state.payload.publishedAt)}</time>`)
       .replace('<div class="driving-parity-kpi-strip" id="driving-parity-kpi-strip" aria-label="Differential Testing field KPIs"></div>', `<div class="driving-parity-kpi-strip has-burns" id="driving-parity-kpi-strip" aria-label="Differential Testing field KPIs">${kpiHtml}</div>`)
-      .replace('<h2 id="progress-panel-title">Progress</h2>', '<h2 id="progress-panel-title">Parity Progress</h2>')
-      .replace('<svg class="chart" id="progress-chart" viewBox="0 0 640 200" role="img" aria-label="Completion percentage over time"></svg>', progress(state.payload.progress))
+      .replace('<h2 id="progress-panel-title">Progress</h2>', `<h2 id="progress-panel-title">${escapeHtml(primaryChartTitle)}</h2>`)
+      .replace('<svg class="chart" id="progress-chart" viewBox="0 0 640 200" role="img" aria-label="Completion percentage over time"></svg>', primaryChartMarkup)
+      .replace('<div class="work-panel-title">Parity Progress</div>', `<div class="work-panel-title">${escapeHtml(historyTitle)}</div>`)
       .replace('<div class="checklist-log" id="checklist-log"></div>', `<div class="checklist-log" id="checklist-log">${log(state.payload.log)}</div>`)
       .replace('<main id="driving-parity-page" class="driving-parity-page" hidden>', '<main id="driving-parity-page" class="driving-parity-page">')
       .replace('<h2 id="driving-parity-summary" class="driving-parity-summary" hidden></h2>', `<h2 id="driving-parity-summary" class="driving-parity-summary">Fields List<span class="field-list-count">(${count(state.payload.summary?.fields?.total ?? state.payload.fields.length)})</span></h2>`)
@@ -1793,6 +1803,10 @@ export function startDifferentialTestingLiveUpdates(root, {
   historyImpl = globalThis.history,
   mount = mountDifferentialTestingDashboard,
   repoKey = null,
+  dataOvenId = "differential-testing",
+  adaptOven = (value) => value,
+  adaptPayload = (value) => value,
+  mountOptions = {},
   refreshMs = DIFFERENTIAL_TESTING_REFRESH_MS,
   onError = (error, hasDashboard) => {
     if (!hasDashboard) root.innerHTML = `<div class="empty">${escapeHtml(String(error?.message || error))}</div>`;
@@ -1828,7 +1842,7 @@ export function startDifferentialTestingLiveUpdates(root, {
       searchParams.set("pageSize", String(fieldViewQuery.pageSize));
     }
     const query = searchParams.toString();
-    return `/api/oven-data/differential-testing${query ? `?${query}` : ""}`;
+    return `/api/oven-data/${encodeURIComponent(dataOvenId)}${query ? `?${query}` : ""}`;
   };
 
   const read = async (url, key, fallbackMessage) => {
@@ -1851,7 +1865,7 @@ export function startDifferentialTestingLiveUpdates(root, {
     const json = await response.json();
     if (!response.ok) throw new Error(json.error || "Could not load Differential Testing data.");
     const result = {
-      payload: differentialPagedPayload(json.payload, json.fieldPage),
+      payload: differentialPagedPayload(adaptPayload(json.payload), json.fieldPage),
       transport: json.transport ?? null,
       fieldPage: json.fieldPage ?? null,
       frameDeltaMetrics: json.frameDeltaMetrics ?? null,
@@ -1878,7 +1892,7 @@ export function startDifferentialTestingLiveUpdates(root, {
     const requestPayloadUrl = payloadUrl(requestScenarioId);
     try {
       const [nextOven, payloadResult] = await Promise.all([
-        oven ?? read("/api/ovens/differential-testing", "oven", "Could not load Differential Testing Oven."),
+        oven ?? read(`/api/ovens/${encodeURIComponent(dataOvenId)}`, "oven", `Could not load ${dataOvenId} Oven.`),
         readPayload(requestPayloadUrl),
       ]);
       if (stopped || requestGeneration !== scenarioGeneration) return;
@@ -1888,9 +1902,10 @@ export function startDifferentialTestingLiveUpdates(root, {
         return;
       }
       const nextRevision = payloadResult.etag || differentialPayloadRevision(payload);
-      oven = nextOven;
+      oven = adaptOven(nextOven);
       if (!dashboard) {
         dashboard = mount(root, oven, payload, {
+          ...mountOptions,
           onScenarioChange: selectScenario,
           onFieldViewChange: selectFieldView,
           fieldPage: payloadResult.fieldPage,
diff --git a/ovens/performance-tracing/detail.json b/ovens/performance-tracing/detail.json
new file mode 100644
index 0000000..6d1040a
--- /dev/null
+++ b/ovens/performance-tracing/detail.json
@@ -0,0 +1,85 @@
+{
+  "version": 1,
+  "columns": 12,
+  "rows": 14,
+  "rowHeight": 64,
+  "cells": [
+    {
+      "id": "title",
+      "title": "Performance Tracing",
+      "widget": "status",
+      "source": "/",
+      "format": "plain",
+      "column": 1,
+      "row": 1,
+      "columnSpan": 4,
+      "rowSpan": 1
+    },
+    {
+      "id": "burns",
+      "title": "Results",
+      "widget": "pie-chart",
+      "source": "/log",
+      "format": "plain",
+      "column": 5,
+      "row": 1,
+      "columnSpan": 2,
+      "rowSpan": 1
+    },
+    {
+      "id": "fields",
+      "title": "Fields",
+      "widget": "metric",
+      "source": "/summary/fields",
+      "format": "plain",
+      "column": 7,
+      "row": 1,
+      "columnSpan": 3,
+      "rowSpan": 1
+    },
+    {
+      "id": "frames",
+      "title": "Frames",
+      "widget": "metric",
+      "source": "/summary/frames",
+      "format": "plain",
+      "column": 10,
+      "row": 1,
+      "columnSpan": 3,
+      "rowSpan": 1
+    },
+    {
+      "id": "progress",
+      "title": "Trace Progress",
+      "widget": "line-chart",
+      "source": "/progress",
+      "format": "number",
+      "column": 5,
+      "row": 2,
+      "columnSpan": 8,
+      "rowSpan": 5
+    },
+    {
+      "id": "log",
+      "title": "Run History",
+      "widget": "log",
+      "source": "/log",
+      "format": "plain",
+      "column": 1,
+      "row": 2,
+      "columnSpan": 4,
+      "rowSpan": 5
+    },
+    {
+      "id": "field-details",
+      "title": "Budget Details",
+      "widget": "comparison",
+      "source": "/fields",
+      "format": "plain",
+      "column": 1,
+      "row": 7,
+      "columnSpan": 12,
+      "rowSpan": 7
+    }
+  ]
+}
diff --git a/ovens/performance-tracing/engine/performance-tracing-contract.mjs b/ovens/performance-tracing/engine/performance-tracing-contract.mjs
new file mode 100644
index 0000000..8745f4d
--- /dev/null
+++ b/ovens/performance-tracing/engine/performance-tracing-contract.mjs
@@ -0,0 +1,209 @@
+export const PERFORMANCE_TRACING_DATA_SCHEMA = "performance-tracing-oven@1";
+export const PERFORMANCE_TRACING_HISTORY_SCHEMA = "performance-history-point@1";
+export const PERFORMANCE_TRACING_DIAGNOSTICS_SCHEMA = "performance-diagnostics@1";
+const MAX_HISTORY_POINTS = 120;
+
+const METRIC_KEYS = Object.freeze([
+  "runCount",
+  "startupReadyMs",
+  "p95FrameMs",
+  "p99FrameMs",
+  "maxFrameMs",
+  "over33msRatio",
+  "p95StepCallMs",
+  "pageErrorCount",
+  "nativeRequestCount",
+  "runtimeConstructionCount",
+]);
+
+export function assertPerformanceTracingData(value, label = "Performance Tracing data") {
+  if (!value || value.schema !== PERFORMANCE_TRACING_DATA_SCHEMA) {
+    throw new Error(label + " must use " + PERFORMANCE_TRACING_DATA_SCHEMA + ".");
+  }
+  if (!value.runId || !isIsoTimestamp(value.generatedAt) || !["pass", "fail"].includes(value.status)) {
+    throw new Error(label + " must identify one timestamped pass/fail run.");
+  }
+  if (value.trust?.classification !== "browser-output-performance-evidence"
+    || value.trust.preparedRoute !== true || value.trust.nativeParityClaim !== false
+    || value.trust.visualParityClaim !== false) {
+    throw new Error(label + " must retain its browser-output-only trust boundary.");
+  }
+  for (const key of METRIC_KEYS) {
+    if (!Number.isFinite(value.metrics?.[key]) || value.metrics[key] < 0) {
+      throw new Error(label + ".metrics." + key + " must be finite and non-negative.");
+    }
+  }
+  if (!value.browser?.engine || !value.browser?.version || !value.scenario?.id
+    || typeof value.scenario.route !== "string" || !value.scenario.route.startsWith("/")) {
+    throw new Error(label + " must bind browser and canonical scenario identity.");
+  }
+  const checks = value.verdict?.checks;
+  if (!Array.isArray(checks) || checks.length === 0 || value.verdict.status !== value.status) {
+    throw new Error(label + " must publish one reconciled budget verdict.");
+  }
+  const ids = new Set();
+  for (const check of checks) {
+    if (!check?.id || ids.has(check.id) || !Number.isFinite(check.actual) || !Number.isFinite(check.limit)
+      || check.operator !== "<=" || !["pass", "fail"].includes(check.status)
+      || check.status !== (check.actual <= check.limit ? "pass" : "fail")) {
+      throw new Error(label + " contains an invalid or contradictory budget check.");
+    }
+    ids.add(check.id);
+  }
+  const expectedStatus = checks.every((check) => check.status === "pass") ? "pass" : "fail";
+  if (value.status !== expectedStatus
+    || value.verdict.passCount !== checks.filter((check) => check.status === "pass").length
+    || value.verdict.failCount !== checks.filter((check) => check.status === "fail").length) {
+    throw new Error(label + " budget counts and status do not reconcile.");
+  }
+  if (!value.artifacts?.report || !value.provenance?.files || typeof value.provenance.files !== "object") {
+    throw new Error(label + " must bind retained artifacts and source provenance.");
+  }
+  if (value.runs !== undefined) assertRuns(value.runs, label + ".runs");
+  if (value.history !== undefined) assertHistory(value.history, value, label + ".history");
+  assertDiagnostics(value.diagnostics, value, label + ".diagnostics");
+  return value;
+}
+
+function assertDiagnostics(diagnostics, current, label) {
+  if (!diagnostics || diagnostics.schema !== PERFORMANCE_TRACING_DIAGNOSTICS_SCHEMA
+    || diagnostics.runId !== current.runId || diagnostics.generatedAt !== current.generatedAt) {
+    throw new Error(label + " must identify the current report with " + PERFORMANCE_TRACING_DIAGNOSTICS_SCHEMA + ".");
+  }
+  if (!Array.isArray(diagnostics.actionItems)
+    || (diagnostics.actionItems.length === 0 && diagnostics.primaryTarget !== null)
+    || (diagnostics.actionItems.length > 0 && diagnostics.primaryTarget?.id !== diagnostics.actionItems[0].id)) {
+    throw new Error(label + " must reconcile its optional measured primary target with the action plan.");
+  }
+  for (const [index, item] of diagnostics.actionItems.entries()) {
+    if (!item?.id || item.priority !== index + 1 || !item.target || !item.producer || !item.signal
+      || !item.nextAction || !item.evidence || typeof item.evidence !== "object"
+      || !Array.isArray(item.verifyMetrics) || item.verifyMetrics.length === 0) {
+      throw new Error(label + " contains an action item without measured evidence, a source producer, or verification metrics.");
+    }
+  }
+  if (!Array.isArray(diagnostics.budgetGaps) || !diagnostics.comparison || typeof diagnostics.comparison !== "object"
+    || !Array.isArray(diagnostics.phaseBottlenecks) || !Array.isArray(diagnostics.cameraPhaseBottlenecks)
+    || !Array.isArray(diagnostics.traceGroups)
+    || !Array.isArray(diagnostics.residencySpikes) || !Array.isArray(diagnostics.runs) || diagnostics.runs.length === 0) {
+    throw new Error(label + " must retain budget gaps, comparison context, bottlenecks, and per-run evidence.");
+  }
+  for (const gap of diagnostics.budgetGaps) {
+    if (!gap?.id || !Number.isFinite(gap.actual) || !Number.isFinite(gap.limit) || !Number.isFinite(gap.excess)) {
+      throw new Error(label + " contains an invalid budget gap.");
+    }
+  }
+  for (const run of diagnostics.runs) {
+    if (!run?.runId || !Array.isArray(run.frameSpikes) || !Array.isArray(run.stepSpikes)
+      || !Array.isArray(run.phaseBottlenecks) || !Array.isArray(run.traceGroups)
+      || !Array.isArray(run.cameraPhaseBottlenecks)
+      || !Array.isArray(run.hotWindows) || !Array.isArray(run.topEvents)
+      || !run.structure?.integrity || typeof run.structure.integrity !== "object") {
+      throw new Error(label + " contains incomplete per-run spike, phase, trace-window, or integrity evidence.");
+    }
+    for (const phase of run.phaseBottlenecks) assertPhase(phase, label + ".runs phase");
+    for (const phase of run.cameraPhaseBottlenecks) assertPhase(phase, label + ".runs camera phase");
+    for (const window of run.hotWindows) {
+      if (!Number.isFinite(window?.startMs) || !Number.isFinite(window.endMs)
+        || !Number.isFinite(window.classifiedThreadTimeMs) || !Array.isArray(window.contributors)) {
+        throw new Error(label + " contains an invalid hot trace window.");
+      }
+    }
+  }
+  const rerun = diagnostics.rerun;
+  const latestComparisonKey = current.history?.at(-1)?.comparisonKey;
+  if (typeof rerun?.command !== "string" || !rerun.command.trim() || rerun.compareAgainstRunId !== current.runId
+    || !rerun.comparisonKey || (latestComparisonKey && rerun.comparisonKey !== latestComparisonKey)
+    || !Array.isArray(rerun.protocol) || rerun.protocol.length === 0
+    || rerun.requiredIntegrity?.pageErrorCount !== 0 || rerun.requiredIntegrity?.nativeRequestCount !== 0
+    || rerun.requiredIntegrity?.runtimeConstructionCount !== 0 || !Array.isArray(rerun.successCriteria)
+    || !Array.isArray(diagnostics.caveats) || diagnostics.caveats.length < 3) {
+    throw new Error(label + " must retain the exact comparable rerun, integrity gate, success criteria, and caveats.");
+  }
+}
+
+function assertHistory(history, current, label) {
+  if (!Array.isArray(history) || history.length === 0 || history.length > MAX_HISTORY_POINTS) {
+    throw new Error(label + " must contain 1-" + MAX_HISTORY_POINTS + " retained trace points.");
+  }
+  const identities = new Set();
+  let priorTime = -Infinity;
+  for (const point of history) {
+    const time = Date.parse(point?.generatedAt);
+    const identity = point?.runId + "\n" + point?.generatedAt;
+    if (point?.schema !== PERFORMANCE_TRACING_HISTORY_SCHEMA || !point.runId || !Number.isFinite(time)
+      || !["pass", "fail"].includes(point.status) || !point.comparisonKey
+      || !point.context || typeof point.context !== "object" || identities.has(identity)
+      || time < priorTime) {
+      throw new Error(label + " contains invalid, duplicate, or unordered points.");
+    }
+    identities.add(identity);
+    priorTime = time;
+    for (const key of ["startupReadyMs", "p95FrameMs", "p99FrameMs", "maxFrameMs", "over33msRatio", "p95StepCallMs", "maxStepCallMs", "residencyTransitionStepCount"]) {
+      if (!Number.isFinite(point.metrics?.[key]) || point.metrics[key] < 0) {
+        throw new Error(label + " contains an invalid " + key + " metric.");
+      }
+    }
+    if (!point.budgets || !Number.isFinite(point.budgets.p95FrameMs)
+      || !point.traceGroups || typeof point.traceGroups !== "object") {
+      throw new Error(label + " must retain budgets and trace groups.");
+    }
+    for (const group of Object.values(point.traceGroups)) {
+      if (!group?.label || !Number.isFinite(group.durationMs) || group.durationMs < 0
+        || !Number.isFinite(group.count) || group.count < 0 || !Number.isFinite(group.maxMs) || group.maxMs < 0) {
+        throw new Error(label + " contains an invalid trace group.");
+      }
+    }
+  }
+  const latest = history.at(-1);
+  if (latest.runId !== current.runId || latest.generatedAt !== current.generatedAt
+    || latest.status !== current.status || latest.metrics.p95FrameMs !== current.metrics.p95FrameMs) {
+    throw new Error(label + " latest point must reconcile with the current report.");
+  }
+}
+
+function assertRuns(runs, label) {
+  if (!Array.isArray(runs) || runs.length === 0) throw new Error(label + " must contain retained browser runs.");
+  for (const run of runs) {
+    if (run?.status !== "passed" || !Number.isFinite(run.frameTiming?.p95FrameMs)
+      || !Array.isArray(run.frameTiming?.series) || run.frameTiming.series.length === 0
+      || !Number.isFinite(run.stepTiming?.p95StepCallMs) || !Array.isArray(run.stepTiming?.slowestSteps)
+      || !Array.isArray(run.stepTiming?.series) || run.stepTiming.series.length === 0
+      || run.stepTiming?.phaseTiming?.schema !== "runtime-dispatch-phase-summary@1"
+      || !Number.isSafeInteger(run.stepTiming.phaseTiming.sampleCount) || run.stepTiming.phaseTiming.sampleCount < 1
+      || !run.stepTiming.phaseTiming.phases || typeof run.stepTiming.phaseTiming.phases !== "object"
+      || run.stepTiming?.cameraPhaseTiming?.schema !== "camera-publication-phase-summary@1"
+      || !Number.isSafeInteger(run.stepTiming.cameraPhaseTiming.sampleCount) || run.stepTiming.cameraPhaseTiming.sampleCount < 1
+      || !run.stepTiming.cameraPhaseTiming.phases || typeof run.stepTiming.cameraPhaseTiming.phases !== "object"
+      || run.trace?.schema !== "browser-performance-trace-summary@2"
+      || run.trace?.attributionMode !== "exclusive-classified-thread-time@1"
+      || run.trace?.measurementWindow?.status !== "bounded"
+      || !run.trace?.groups || typeof run.trace.groups !== "object") {
+      throw new Error(label + " contains an incomplete retained browser run.");
+    }
+    for (const phase of Object.entries(run.stepTiming.phaseTiming.phases).map(([id, value]) => ({ id, ...value }))) {
+      assertPhase(phase, label + " phase");
+    }
+    for (const phase of Object.entries(run.stepTiming.cameraPhaseTiming.phases).map(([id, value]) => ({ id, ...value }))) {
+      assertPhase(phase, label + " camera phase");
+    }
+    for (const group of Object.values(run.trace.groups)) {
+      if (!Array.isArray(group?.timeline?.values) || group.timeline.mode !== "exclusive-classified-thread-time"
+        || !Number.isFinite(group.timeline.bucketDurationMs) || !Number.isFinite(group.inclusiveDurationMs)) {
+        throw new Error(label + " contains a trace group without a source timeline.");
+      }
+    }
+  }
+}
+
+function assertPhase(phase, label) {
+  if (!phase?.id || !phase.label || !phase.producer || !phase.nextProbe || !Number.isSafeInteger(phase.sampleCount)
+    || phase.sampleCount < 0 || !Number.isFinite(phase.totalMs) || phase.totalMs < 0
+    || !Number.isFinite(phase.p95Ms) || phase.p95Ms < 0 || !Number.isFinite(phase.maxMs) || phase.maxMs < 0) {
+    throw new Error(label + " is missing bounded timing, source producer, or next-probe evidence.");
+  }
+}
+
+function isIsoTimestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value)) && /T/u.test(value);
+}
diff --git a/ovens/performance-tracing/engine/performance-tracing-contract.test.mjs b/ovens/performance-tracing/engine/performance-tracing-contract.test.mjs
new file mode 100644
index 0000000..3b4cbc9
--- /dev/null
+++ b/ovens/performance-tracing/engine/performance-tracing-contract.test.mjs
@@ -0,0 +1,240 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { adaptPerformanceTracingReport } from "../../../dashboard/src/lib/performance-tracing.mjs";
+import { startDifferentialTestingLiveUpdates } from "../../differential-testing/renderer/differential-testing-renderer.js";
+import { assertPerformanceTracingData } from "./performance-tracing-contract.mjs";
+import { assertPerformanceTracingProvenanceCurrent } from "./performance-tracing-handler.mjs";
+import { createHash } from "node:crypto";
+
+test("Performance Tracing validates reconciled browser-output reports", () => {
+  assert.equal(assertPerformanceTracingData(fixture()).status, "fail");
+  const genericProject = fixture();
+  genericProject.scenario.route = "/benchmark";
+  genericProject.diagnostics.rerun.command = "npm run benchmark";
+  assert.equal(assertPerformanceTracingData(genericProject).scenario.route, "/benchmark");
+});
+
+test("Performance Tracing rejects weakened trust and contradictory budgets", () => {
+  const weakened = fixture();
+  weakened.trust.nativeParityClaim = true;
+  assert.throws(() => assertPerformanceTracingData(weakened), /browser-output-only trust boundary/u);
+  const contradictory = fixture();
+  contradictory.verdict.checks[0].status = "pass";
+  assert.throws(() => assertPerformanceTracingData(contradictory), /invalid or contradictory budget/u);
+});
+
+test("Performance Tracing rejects unordered or unreconciled history", () => {
+  const unordered = fixture();
+  unordered.history.unshift({ ...structuredClone(unordered.history[0]), runId: "older", generatedAt: "2026-07-15T13:00:00.000Z" });
+  assert.throws(() => assertPerformanceTracingData(unordered), /unordered points/u);
+  const unreconciled = fixture();
+  unreconciled.history[0].metrics.p95FrameMs = 39;
+  assert.throws(() => assertPerformanceTracingData(unreconciled), /latest point must reconcile/u);
+});
+
+test("Performance Tracing blocks a report after a measured input changes", () => {
+  const root = mkdtempSync(join(tmpdir(), "performance-provenance-"));
+  try {
+    const binding = join(root, ".local", "performance", "report.json");
+    const source = join(root, "source.mjs");
+    mkdirSync(join(root, ".local", "performance"), { recursive: true });
+    writeFileSync(binding, "{}\n");
+    writeFileSync(source, "export const value = 1;\n");
+    const bytes = Buffer.from("export const value = 1;\n");
+    const payload = { provenance: { files: { "source.mjs": { bytes: bytes.length, sha256: createHash("sha256").update(bytes).digest("hex") } } } };
+    assert.equal(assertPerformanceTracingProvenanceCurrent(payload, binding), payload);
+    writeFileSync(source, "export const value = 2;\n");
+    assert.throws(() => assertPerformanceTracingProvenanceCurrent(payload, binding), /report is stale/u);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("Performance Tracing live view reads its own Oven and adapts its report", async () => {
+  const requests = [];
+  const oven = { id: "performance-tracing", name: "Performance Tracing", detail: { cells: [] } };
+  let mounted = null;
+  const controller = startDifferentialTestingLiveUpdates({ innerHTML: "" }, {
+    dataOvenId: "performance-tracing",
+    repoKey: "repo-key",
+    adaptPayload: adaptPerformanceTracingReport,
+    mountOptions: { initialChart: "current", initialProgressChart: "delta" },
+    fetchImpl: async (url) => {
+      requests.push(url);
+      return {
+        ok: true,
+        status: 200,
+        headers: { get: () => null },
+        async json() {
+          return url === "/api/ovens/performance-tracing" ? { oven } : { payload: fixture() };
+        },
+      };
+    },
+    setIntervalImpl: () => 17,
+    clearIntervalImpl() {},
+    mount: (_root, mountedOven, payload, options) => {
+      mounted = { mountedOven, payload, options };
+      return { update() {} };
+    },
+  });
+
+  await controller.ready;
+  controller.stop();
+  assert.deepEqual(requests, [
+    "/api/ovens/performance-tracing",
+    "/api/oven-data/performance-tracing?repoKey=repo-key",
+  ]);
+  assert.equal(mounted.mountedOven, oven);
+  assert.equal(mounted.payload.subtitle, "fixture");
+  assert.equal(mounted.payload.fields.length, 6);
+  assert.equal(mounted.options.initialChart, "current");
+});
+
+function fixture() {
+  const value = {
+    schema: "performance-tracing-oven@1",
+    status: "fail",
+    runId: "fixture",
+    generatedAt: "2026-07-15T12:00:00.000Z",
+    trust: {
+      classification: "browser-output-performance-evidence",
+      preparedRoute: true,
+      nativeParityClaim: false,
+      visualParityClaim: false,
+    },
+    browser: { engine: "chromium", version: "1" },
+    scenario: { id: "prepared", route: "/" },
+    metrics: {
+      runCount: 1,
+      startupReadyMs: 1000,
+      p95FrameMs: 40,
+      p99FrameMs: 50,
+      maxFrameMs: 100,
+      over33msRatio: 0.1,
+      p95StepCallMs: 1,
+      pageErrorCount: 0,
+      nativeRequestCount: 0,
+      runtimeConstructionCount: 0,
+    },
+    verdict: {
+      status: "fail",
+      passCount: 0,
+      failCount: 1,
+      checks: [{ id: "p95FrameMs", actual: 40, limit: 25, operator: "<=", status: "fail" }],
+    },
+    artifacts: { report: "report.json" },
+    provenance: { files: { "source.mjs": { sha256: "a", bytes: 1 } } },
+    runs: [{
+      id: "run-01",
+      status: "passed",
+      frameTiming: { p95FrameMs: 40, series: [{ frame: 0, elapsedMs: 40, frameMs: 40 }] },
+      stepTiming: {
+        p95StepCallMs: 1,
+        slowestSteps: [],
+        series: [{ tick: 0, stepCallMs: 1 }],
+        phaseTiming: {
+          schema: "runtime-dispatch-phase-summary@1",
+          sampleCount: 1,
+          phases: { cameraResidency: phase() },
+        },
+        cameraPhaseTiming: {
+          schema: "camera-publication-phase-summary@1",
+          sampleCount: 1,
+          phases: { assetResidencyDiscovery: phase() },
+        },
+      },
+      trace: {
+        schema: "browser-performance-trace-summary@2",
+        attributionMode: "exclusive-classified-thread-time@1",
+        measurementWindow: { status: "bounded" },
+        groups: { scripting: { label: "JS / scripting", durationMs: 100, inclusiveDurationMs: 120, count: 10, maxMs: 4, timeline: { mode: "exclusive-classified-thread-time", bucketDurationMs: 50, values: [1] } } },
+      },
+      integrity: { pageErrorCount: 0, nativeRequestCount: 0, runtimeConstructionCount: 0 },
+    }],
+  };
+  value.history = [{
+    schema: "performance-history-point@1",
+    runId: value.runId,
+    generatedAt: value.generatedAt,
+    status: value.status,
+    comparisonKey: "fixture-context",
+    context: { browserTarget: "fixture", scenarioId: "prepared" },
+    metrics: {
+      startupReadyMs: 1000,
+      p95FrameMs: 40,
+      p99FrameMs: 50,
+      maxFrameMs: 100,
+      over33msRatio: 0.1,
+      p95StepCallMs: 1,
+      maxStepCallMs: 4,
+      residencyTransitionStepCount: 1,
+    },
+    budgets: { p95FrameMs: 25 },
+    traceGroups: { scripting: { label: "JS / scripting", durationMs: 100, count: 10, maxMs: 4 } },
+  }];
+  value.diagnostics = {
+    schema: "performance-diagnostics@1",
+    runId: value.runId,
+    generatedAt: value.generatedAt,
+    primaryTarget: action(),
+    budgetGaps: [{ id: "p95FrameMs", actual: 40, limit: 25, excess: 15, ratioToLimit: 1.6, percentOverLimit: 60 }],
+    comparison: { comparable: false, previousRunId: null, previousGeneratedAt: null, metricChanges: {} },
+    runs: [{
+      runId: "run-01",
+      frameSpikes: [{ frame: 0, elapsedMs: 40, frameMs: 40, overBudgetMs: 15 }],
+      stepSpikes: [],
+      phaseBottlenecks: [{ id: "cameraResidency", ...phase() }],
+      cameraPhaseBottlenecks: [{ id: "assetResidencyDiscovery", ...phase() }],
+      traceGroups: [],
+      hotWindows: [{ bucket: 0, startMs: 0, endMs: 50, classifiedThreadTimeMs: 1, contributors: [] }],
+      topEvents: [],
+      structure: { integrity: value.runs[0].integrity },
+    }],
+    phaseBottlenecks: [{ id: "cameraResidency", ...phase(), runId: "run-01" }],
+    cameraPhaseBottlenecks: [{ id: "assetResidencyDiscovery", ...phase(), runId: "run-01" }],
+    traceGroups: [],
+    residencySpikes: [],
+    actionItems: [action()],
+    rerun: {
+      command: "pnpm perf:trace -- --runs 1 --no-fail-on-budget",
+      comparisonKey: value.history[0].comparisonKey,
+      compareAgainstRunId: value.runId,
+      protocol: ["Change one producer."],
+      requiredIntegrity: { pageErrorCount: 0, nativeRequestCount: 0, runtimeConstructionCount: 0 },
+      successCriteria: [{ id: "p95FrameMs", operator: "<=", limit: 25 }],
+    },
+    caveats: ["inclusive", "instrumented", "browser output"],
+  };
+  return value;
+}
+
+function phase() {
+  return {
+    label: "camera / city residency",
+    producer: "src/runtime/scene.mjs",
+    nextProbe: "Separate camera and residency work.",
+    sampleCount: 1,
+    totalMs: 4,
+    averageMs: 4,
+    p50Ms: 4,
+    p95Ms: 4,
+    maxMs: 4,
+    attributedShare: 1,
+  };
+}
+
+function action() {
+  return {
+    id: "dispatch-phase-cameraResidency",
+    priority: 1,
+    target: "camera / city residency",
+    producer: "src/runtime/scene.mjs",
+    signal: "dispatch phase max 4 ms",
+    evidence: { maxMs: 4 },
+    nextAction: "Separate camera and residency work.",
+    verifyMetrics: ["p95StepCallMs"],
+  };
+}
diff --git a/ovens/performance-tracing/engine/performance-tracing-handler.mjs b/ovens/performance-tracing/engine/performance-tracing-handler.mjs
new file mode 100644
index 0000000..fc0c341
--- /dev/null
+++ b/ovens/performance-tracing/engine/performance-tracing-handler.mjs
@@ -0,0 +1,76 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { registerOvenHandler } from "../../../src/ovens/oven-registry.mjs";
+import { readTextFileWithLimit, safeStat } from "../../../src/server/fs-safe.mjs";
+import { assertPerformanceTracingData } from "./performance-tracing-contract.mjs";
+
+export const performanceTracingHandler = Object.freeze({
+  id: "performance-tracing",
+
+  serveData({ bindingPath, maxOvenDataBytes }) {
+    if (!safeStat(bindingPath)?.isFile()) {
+      throw Object.assign(new Error("configured Performance Tracing data is missing"), { status: 404 });
+    }
+    const payload = JSON.parse(readTextFileWithLimit(
+      bindingPath,
+      maxOvenDataBytes,
+      "Performance Tracing Oven data",
+    ));
+    assertPerformanceTracingProvenanceCurrent(payload, bindingPath, maxOvenDataBytes);
+    assertPerformanceTracingData(payload);
+    return { ovenId: "performance-tracing", path: bindingPath, payload, validated: true };
+  },
+});
+
+export function assertPerformanceTracingProvenanceCurrent(payload, bindingPath, maxBytes = 512 * 1024 * 1024) {
+  const files = payload?.provenance?.files;
+  if (!files || typeof files !== "object" || !Object.keys(files).length) {
+    throw staleError("Performance Tracing report has no source provenance to validate.");
+  }
+  const paths = Object.keys(files);
+  for (const path of paths) {
+    if (!path || isAbsolute(path) || path.split(/[\\/]/u).includes("..")) {
+      throw staleError("Performance Tracing provenance contains an unsafe project path: " + path);
+    }
+  }
+  const projectRoot = findProjectRoot(bindingPath, paths);
+  if (!projectRoot) throw staleError("Performance Tracing report is stale: its project inputs cannot be found beside the bound report.");
+  const changed = [];
+  for (const path of paths) {
+    const absolute = resolve(projectRoot, path);
+    const stat = safeStat(absolute);
+    const expected = files[path];
+    if (!stat?.isFile()) {
+      changed.push(path + " (missing)");
+      continue;
+    }
+    if (stat.size > maxBytes) throw staleError("Performance Tracing provenance input exceeds the read limit: " + path);
+    const digest = createHash("sha256").update(readFileSync(absolute)).digest("hex");
+    if (stat.size !== Number(expected?.bytes) || digest !== expected?.sha256) changed.push(path);
+  }
+  if (changed.length) {
+    throw staleError("Performance Tracing report is stale; rerun the configured trace command. Changed inputs: " + changed.join(", "));
+  }
+  return payload;
+}
+
+function findProjectRoot(bindingPath, paths) {
+  let candidate = dirname(resolve(bindingPath));
+  while (true) {
+    if (paths.every((path) => {
+      const absolute = resolve(candidate, path);
+      const inside = relative(candidate, absolute);
+      return inside && !inside.startsWith("..") && !isAbsolute(inside) && safeStat(absolute)?.isFile();
+    })) return candidate;
+    const parent = dirname(candidate);
+    if (parent === candidate) return null;
+    candidate = parent;
+  }
+}
+
+function staleError(message) {
+  return Object.assign(new Error(message), { status: 409 });
+}
+
+registerOvenHandler("performance-tracing", performanceTracingHandler);
diff --git a/ovens/performance-tracing/instructions.md b/ovens/performance-tracing/instructions.md
new file mode 100644
index 0000000..5edef77
--- /dev/null
+++ b/ovens/performance-tracing/instructions.md
@@ -0,0 +1,26 @@
+# Performance Tracing
+
+Performance Tracing renders retained browser-output timing evidence from a project-owned trace run. It shows frame pacing, synchronous step cost, budget checks, renderer trace groups, slow steps, browser identity, and source provenance without treating instrumentation as gameplay or visual-equivalence authority.
+
+## State Contract
+
+The project publishes one atomic `performance-tracing-oven@1` JSON report. The report owns capture, deterministic replay, raw Chrome trace retention, samples, machine and browser provenance, and budget evaluation. Burnlist validates and renders that normalized report; it does not execute the trace command or rewrite project evidence.
+
+The report must preserve:
+
+- canonical prepared route and scenario identity
+- browser, viewport, machine, and source-file provenance
+- startup, frame, synchronous step, trace-group, and residency measurements
+- bounded per-dispatch phase attribution with source producer and next-probe metadata
+- ranked frame spikes, residency-changing step spikes, trace hot windows, and top complete events
+- a measured optimization queue whose items name the producer, evidence, next action, and verification metrics
+- comparable-history context plus the exact command and integrity gate for the next rerun
+- every declared budget with its actual value and pass/fail result
+- raw trace and sample artifact bindings
+- explicit browser-output trust that makes no native-execution or visual-equivalence claim
+
+Missing, malformed, partially written, contradictory, or unactionable evidence is blocked. Never guess a producer and never loosen a budget to make a run green. Fix the capture boundary when observer overhead dominates; otherwise change one measured source producer, run the retained comparable command again, require the same comparison key and zero integrity violations, and keep the change only when the named acceptance metrics improve without structural regressions.
+
+## Execution Boundary
+
+The Oven is read-only. Project tooling runs traces and atomically publishes the report. Burnlist only validates and displays it.
diff --git a/package.json b/package.json
index b989bf0..80a95da 100644
--- a/package.json
+++ b/package.json
@@ -29,6 +29,7 @@
   "scripts": {
     "build:dashboard": "vite build --config dashboard/vite.config.mjs",
     "test:differential-testing": "node --test ovens/differential-testing/engine/differential-testing-adapter-sdk.test.mjs ovens/differential-testing/engine/differential-testing-contract.test.mjs ovens/differential-testing/engine/differential-testing-data-contract.test.mjs ovens/differential-testing/engine/differential-testing-transport-renderer.test.mjs ovens/differential-testing/engine/differential-testing-transport-server.test.mjs",
+    "test:performance-tracing": "node --test ovens/performance-tracing/engine/performance-tracing-contract.test.mjs",
     "verify": "node scripts/verify.mjs",
     "verify:clean": "node scripts/verify-clean.mjs",
     "verify:package": "node scripts/verify-package.mjs",
diff --git a/scripts/verify-package.mjs b/scripts/verify-package.mjs
index 733854d..9025ca1 100755
--- a/scripts/verify-package.mjs
+++ b/scripts/verify-package.mjs
@@ -54,6 +54,10 @@ const required = [
   "ovens/differential-testing/renderer/differential-testing.css",
   "ovens/differential-testing/renderer/differential-testing-progress-chart.js",
   "ovens/differential-testing/renderer/differential-testing-renderer.js",
+  "ovens/performance-tracing/instructions.md",
+  "ovens/performance-tracing/detail.json",
+  "ovens/performance-tracing/engine/performance-tracing-contract.mjs",
+  "ovens/performance-tracing/engine/performance-tracing-handler.mjs",
   "dashboard/dist/index.html",
 ];
 
diff --git a/scripts/verify-test-files.mjs b/scripts/verify-test-files.mjs
index 28007b3..ffedb2f 100644
--- a/scripts/verify-test-files.mjs
+++ b/scripts/verify-test-files.mjs
@@ -12,6 +12,7 @@ export const verificationTestFiles = [
   "ovens/differential-testing/engine/differential-testing-contract.test.mjs",
   "ovens/differential-testing/engine/differential-testing-data-contract.test.mjs",
   "ovens/differential-testing/engine/differential-testing-transport-server.test.mjs",
+  "ovens/performance-tracing/engine/performance-tracing-contract.test.mjs",
   "ovens/streaming-diff/engine/streaming-diff-data-contract.test.mjs",
   "ovens/streaming-diff/engine/streaming-diff-capture.test.mjs",
   "ovens/streaming-diff/engine/streaming-diff-capture-git.test.mjs",
diff --git a/scripts/verify.mjs b/scripts/verify.mjs
index 8ca6788..9b3e338 100755
--- a/scripts/verify.mjs
+++ b/scripts/verify.mjs
@@ -219,6 +219,7 @@ const jsFiles = [...new Set([
   ...walkFiles(resolve(repoRoot, "scripts"), (path) => path.endsWith(".mjs")),
   ...walkFiles(resolve(repoRoot, "src"), (path) => path.endsWith(".mjs")),
   ...walkFiles(resolve(repoRoot, "ovens/differential-testing/engine"), (path) => path.endsWith(".mjs")),
+  ...walkFiles(resolve(repoRoot, "ovens/performance-tracing/engine"), (path) => path.endsWith(".mjs")),
   ...walkFiles(resolve(repoRoot, "ovens/streaming-diff/engine"), (path) => path.endsWith(".mjs")),
   resolve(repoRoot, "src/ovens/oven-registry.mjs"),
   resolve(repoRoot, "src/ovens/built-in-handlers.mjs"),
@@ -250,6 +251,7 @@ assertSourceIncludes(".github/workflows/publish.yml", "git fetch origin main", "
 assertSourceIncludes(".github/workflows/publish.yml", '"refs/tags/${VERSION}^{}"', "Publish tag verification must request annotated-tag peeled refs.");
 assertSourceIncludes("src/server/burnlist-dashboard-server.mjs", "ovenId(record.ovenId);", "Burn run reads do not require the canonical ovenId.");
 assertSourceIncludes("ovens/differential-testing/engine/differential-testing-handler.mjs", "assertDifferentialTestingData(payload)", "Differential Testing data is not validated at the server boundary.");
+assertSourceIncludes("ovens/performance-tracing/engine/performance-tracing-handler.mjs", "assertPerformanceTracingData(payload)", "Performance Tracing data is not validated at the server boundary.");
 assertSourceIncludes("ovens/differential-testing/engine/differential-testing-handler.mjs", 'ovenName: "Differential Testing"', "Differential Testing scenarios are missing from the shared dashboard table.");
 assertSourceIncludes("ovens/differential-testing/engine/differential-testing-handler.mjs", "queryDifferentialTestingFieldPage", "Differential Testing server is missing bounded field-page transport.");
 assertSourceExcludes("src/server/burnlist-dashboard-server.mjs", 'id === "differential-testing"', "Dashboard server still hardcodes the Differential Testing Oven.");
@@ -370,9 +372,10 @@ assertSourceExcludes("src/server/burnlist-dashboard-server.mjs", '"/targets"', "
 assertSourceExcludes("dashboard/src/App.tsx", '"/targets"', "React dashboard still exposes the removed Targets route.");
 assertSourceExcludes("src/ovens/oven-contract.mjs", '"target"', "Oven contract still accepts the removed Target widget.");
 assertSkillSet(repoRoot, ["burnlist"]);
-assertBuiltInOvenSet(repoRoot, ["checklist", "differential-testing", "streaming-diff"]);
+assertBuiltInOvenSet(repoRoot, ["checklist", "differential-testing", "performance-tracing", "streaming-diff"]);
 assertBuiltInOven(repoRoot, "checklist", "Checklist");
 assertBuiltInOven(repoRoot, "differential-testing", "Differential Testing");
+assertBuiltInOven(repoRoot, "performance-tracing", "Performance Tracing");
 assertBuiltInOven(repoRoot, "streaming-diff", "Streaming Diff");
 assertDifferentialTestingContractAssets();
 assertPublishablePackage();
diff --git a/src/ovens/built-in-handlers.mjs b/src/ovens/built-in-handlers.mjs
index 5d0ee77..84c56cc 100644
--- a/src/ovens/built-in-handlers.mjs
+++ b/src/ovens/built-in-handlers.mjs
@@ -1,3 +1,4 @@
 import "./handlers/checklist.mjs";
 import "../../ovens/differential-testing/engine/differential-testing-handler.mjs";
+import "../../ovens/performance-tracing/engine/performance-tracing-handler.mjs";
 import "../../ovens/streaming-diff/engine/streaming-diff-handler.mjs";