From 050ae81b01950cb2cf4251e3d04544156b366b06 Mon Sep 17 00:00:00 2001
From: Seongho Bae <seonghobae@users.noreply.github.com>
Date: Sun, 23 Aug 2026 02:22:47 +0000
Subject: [PATCH 01/12] feat(workspace): name tonight's tempo, starting chord,
 and transpose setup

After analysis, the cockpit Tempo, Key, and Transpose metrics name a countable BPM, first-entrance chord shape, and transpose/setup plan when those owned fields exist, then Open/Lock scrolls the matching workspace surface.
---
 AGENTS.md                                     |   1 +
 ARCHITECTURE.md                               |   1 +
 CHANGELOG.md                                  |   1 +
 CLAUDE.md                                     |   2 +-
 apps/desktop/src/App.test.tsx                 |  81 ++++
 apps/desktop/src/App.tsx                      | 138 ++++++-
 .../src/features/workspace/Workspace.test.tsx |  12 +
 .../src/features/workspace/Workspace.tsx      |  12 +-
 ...ehearsalMetrics.inherited-metadata.test.ts |  65 +++
 .../workspace/rehearsalMetrics.scroll.test.ts |  98 +++++
 .../workspace/rehearsalMetrics.test.ts        | 380 ++++++++++++++++++
 .../features/workspace/rehearsalMetrics.ts    | 358 +++++++++++++++++
 apps/desktop/src/i18n/index.test.ts           |   7 +
 apps/desktop/src/locales/en/common.json       |  12 +-
 apps/desktop/src/locales/ko/common.json       |  12 +-
 apps/desktop/vite.config.ts                   |   3 +-
 docs/design-system/component-contract.md      |   2 +-
 .../rehearsal-cockpit-tempo-key-transpose.md  |  16 +
 18 files changed, 1189 insertions(+), 12 deletions(-)
 create mode 100644 apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts
 create mode 100644 apps/desktop/src/features/workspace/rehearsalMetrics.scroll.test.ts
 create mode 100644 apps/desktop/src/features/workspace/rehearsalMetrics.test.ts
 create mode 100644 apps/desktop/src/features/workspace/rehearsalMetrics.ts
 create mode 100644 docs/doctoring/rehearsal-cockpit-tempo-key-transpose.md

diff --git a/AGENTS.md b/AGENTS.md
index fca448ce9..db88136e8 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -83,6 +83,7 @@ This section applies to any agent (Claude, Codex, Cursor, opencode, ...) working
 - Keep UI and analysis engine decoupled through shared contracts.
 - Prefer minimal, test-first changes for production code.
 - Prefer practical, friendly, rehearsal-first wording over academic or authority-heavy language.
+- Name tonight's countable tempo, first-entrance chord shape, and transpose setup in the cockpit so the next rehearsal action is obvious. Do not present a pending metric as a detected song-wide key.
 - Do not reduce the product to a chord analyzer when form, timing, player coordination, simplification, and setup cues are the real rehearsal blockers.
 - Do not frame usability as a reason to accept weak analysis quality; BandScope should aim for both easy use and high accuracy.
 
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 3302a6fc3..444a47fe8 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -6,6 +6,7 @@ Last updated: 2026-03-11
 
 - Product identity, UX tone, copy rules, and prioritization tie-breakers live in `docs/brand-story.md`.
 - Future PRDs, TRDs, onboarding copy, empty states, error messages, and marketing copy should use that document as the single brand source of truth.
+- After analysis, the mounted cockpit Tempo, Key, and Transpose metrics must name a countable BPM, the first-entrance chord shape, and the first-entrance transpose setup when those owned fields exist. Keep missing values pending. Do not invent a song-wide key detector; the Key metric is the starting shape the room can check. Cockpit Open/Lock actions scroll renderer-owned workspace surfaces only.
 
 ## Security source
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index eea696893..30bfe069a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Added
 
 - Display the analyzed song tempo (BPM) as a badge in the rehearsal workspace.
+- Name tonight's countable tempo, first-entrance chord shape, and transpose setup in the cockpit so the next rehearsal action is Open/Lock on the matching workspace surface. Missing values stay pending; the Key metric is a starting shape, not a claimed song-wide key.
 - 각 합주 역할(Role)별 개인 연습 진행도를 0~100% 범위로 기록 및 시각화할 수 있는 연습 진척도(`practiceProgress`) 트래커 기능 추가. UI 컨트롤(슬라이더 및 +/- 버튼)과 한/영 다국어 지원 포함.
 
 ## [0.1.3] - 2026-04-29
diff --git a/CLAUDE.md b/CLAUDE.md
index 82c2c704a..42789f9c2 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -51,7 +51,7 @@ BandScope is a local-first desktop app for rehearsal prep: it turns a song into
 
 Three layers, decoupled through shared contracts:
 
-- `apps/desktop` — Tauri 2 + Vite + React 19 shell (Tailwind 4, Base UI, Storybook). Feature screens live in `src/features/` (home, workspace, chords, ranges, player, settings). `src/lib/analysis.ts` and `src/lib/job_runner.ts` call typed Tauri IPC commands, with a browser fallback that serves demo data when not running inside Tauri.
+- `apps/desktop` — Tauri 2 + Vite + React 19 shell (Tailwind 4, Base UI, Storybook). Feature screens live in `src/features/` (home, workspace, chords, ranges, player, settings). After analysis, the cockpit names tonight's countable tempo, first-entrance chord shape, and transpose setup and opens the matching workspace surface. Do not treat the Key metric as a song-wide key detector. `src/lib/analysis.ts` and `src/lib/job_runner.ts` call typed Tauri IPC commands, with a browser fallback that serves demo data when not running inside Tauri.
 - `apps/desktop/src-tauri/src/main.rs` — the Rust orchestration boundary. Tauri commands (`start_analysis_job`, `get_analysis_job_status`, `select_local_audio_source`, `import_youtube_url`) validate untrusted input (project IDs, file paths, URLs) and spawn the Python engine as a subprocess. There is no loopback HTTP listener and no network path for local analysis.
 - `services/analysis-engine` — Python package `bandscope_analysis` (librosa/numpy). Entry point `cli.py` reads a JSON job request on stdin and prints a structured job-status JSON envelope on stdout (`--progress-jsonl` streams progress lines). `api.py` orchestrates the pipeline across the `separation`, `sections`, `roles`, `chords`, `ranges`, `temporal`, `transcription`, and `youtube` modules.
 
diff --git a/apps/desktop/src/App.test.tsx b/apps/desktop/src/App.test.tsx
index 3eed386f8..8abbc8239 100644
--- a/apps/desktop/src/App.test.tsx
+++ b/apps/desktop/src/App.test.tsx
@@ -2,6 +2,7 @@ import { act, fireEvent, render, screen, waitFor, within } from "@testing-librar
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { App } from "./App";
 import { MAX_YOUTUBE_URL_LENGTH } from "./lib/analysis";
+import { createDemoRehearsalSong } from "@bandscope/shared-types";
 
 // The Score view pulls in ScoreViewer -> pdfjs-dist, which needs DOMMatrix
 // (absent in jsdom). Stub the pdf.js bridge so App can mount the real
@@ -340,6 +341,86 @@ describe("App", () => {
     expect(screen.getAllByText(/Pending/i).length).toBeGreaterThanOrEqual(2);
   });
 
+  it("names tonight's tempo, first-entrance chord, and transpose setup after analysis", async () => {
+    mockLoadProject.mockResolvedValueOnce(createDemoRehearsalSong());
+    render(<App />);
+
+    fireEvent.click(screen.getByRole("button", { name: /open project/i }));
+
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Open tonight's count-in" })).toBeTruthy();
+    });
+    expect(screen.getAllByText("120 BPM").length).toBeGreaterThan(0);
+    expect(screen.getByText("Count 120 in before the first entrance.")).toBeTruthy();
+    expect(screen.getAllByText("C#m7").length).toBeGreaterThan(0);
+    expect(screen.getByText("Bass Guitar starts in this shape. Check the first entrance.")).toBeTruthy();
+    expect(screen.getByRole("button", { name: "Open tonight's first chord" })).toBeTruthy();
+    expect(screen.getByRole("button", { name: "Lock Bass Guitar's setup" })).toBeTruthy();
+    expect(screen.queryByText(/^Pending$/)).toBeNull();
+  });
+
+  it("opens the matching workspace surface from the cockpit next action", async () => {
+    mockLoadProject.mockResolvedValueOnce(createDemoRehearsalSong());
+    render(<App />);
+    fireEvent.click(screen.getByRole("button", { name: /open project/i }));
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Open tonight's count-in" })).toBeTruthy();
+    });
+
+    const tempoTarget = document.getElementById("workspace-surface-tempo");
+    const harmonyTarget = document.getElementById("workspace-surface-harmony");
+    expect(tempoTarget).toBeTruthy();
+    expect(harmonyTarget).toBeTruthy();
+    const tempoScroll = vi.fn();
+    const harmonyScroll = vi.fn();
+    Object.defineProperty(tempoTarget!, "scrollIntoView", { configurable: true, value: tempoScroll });
+    Object.defineProperty(harmonyTarget!, "scrollIntoView", { configurable: true, value: harmonyScroll });
+
+    fireEvent.click(screen.getByRole("button", { name: "Open tonight's count-in" }));
+    expect(tempoScroll).toHaveBeenCalledWith({ block: "nearest", behavior: "smooth" });
+    expect(screen.getByText("Count 120 together. Start from the map.")).toBeTruthy();
+
+    fireEvent.click(screen.getByRole("button", { name: "Open tonight's first chord" }));
+    expect(harmonyScroll).toHaveBeenCalledWith({ block: "nearest", behavior: "smooth" });
+    expect(screen.getByText("Check C#m7 at the first entrance before the room starts.")).toBeTruthy();
+
+    fireEvent.click(screen.getByRole("button", { name: "Lock Bass Guitar's setup" }));
+    expect(harmonyScroll).toHaveBeenCalledTimes(2);
+    expect(screen.getByText("Lock Bass Guitar's setup, then count in from the map.")).toBeTruthy();
+  });
+
+  it("keeps a cockpit next action incomplete when the workspace surface is missing", async () => {
+    mockLoadProject.mockResolvedValueOnce(createDemoRehearsalSong());
+    render(<App />);
+    fireEvent.click(screen.getByRole("button", { name: /open project/i }));
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Open tonight's count-in" })).toBeTruthy();
+    });
+    document.getElementById("workspace-surface-tempo")?.remove();
+
+    fireEvent.click(screen.getByRole("button", { name: "Open tonight's count-in" }));
+    expect(screen.getByText("Count 120 in before the first entrance.")).toBeTruthy();
+    expect(screen.queryByText("Count 120 together. Start from the map.")).toBeNull();
+  });
+
+  it("localizes ready cockpit metric copy for Korean rehearsal", async () => {
+    const languageSpy = vi.spyOn(window.navigator, "language", "get").mockReturnValue("ko-KR");
+    mockLoadProject.mockResolvedValueOnce(createDemoRehearsalSong());
+
+    try {
+      render(<App />);
+      fireEvent.click(screen.getByRole("button", { name: /프로젝트 열기/i }));
+      await waitFor(() => {
+        expect(screen.getByRole("button", { name: "오늘 카운트 위치 열기" })).toBeTruthy();
+      });
+      expect(screen.getByText("첫 시작 전에 120으로 카운트하세요.")).toBeTruthy();
+      expect(screen.getByRole("button", { name: "오늘 첫 코드 열기" })).toBeTruthy();
+      expect(screen.getByRole("button", { name: "Bass Guitar 세팅 잠그기" })).toBeTruthy();
+    } finally {
+      languageSpy.mockRestore();
+    }
+  });
+
   it("summarizes confidence from the lowest-confidence loaded section", async () => {
     const loadedProject = succeededResult().result;
     loadedProject.sections.push({
diff --git a/apps/desktop/src/App.tsx b/apps/desktop/src/App.tsx
index f3d678454..b566589e7 100644
--- a/apps/desktop/src/App.tsx
+++ b/apps/desktop/src/App.tsx
@@ -47,6 +47,16 @@ import { createTranslator, detectPreferredLocale, type TranslationKey } from "./
 import { ScoreView } from "./features/score/ScoreView";
 import { Workspace } from "./features/workspace/Workspace";
 import { EmptyState, ErrorState, LoadingState } from "./features/workspace/WorkspaceStates";
+import {
+  formatMetricCopy,
+  resolveTonightStartingChord,
+  resolveTonightTempo,
+  resolveTonightTransposePlan,
+  scrollToWorkspaceSurface,
+  WORKSPACE_SURFACE_HARMONY,
+  WORKSPACE_SURFACE_TEMPO,
+  WORKSPACE_SURFACE_TRANSPOSE
+} from "./features/workspace/rehearsalMetrics";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Progress } from "@/components/ui/progress";
@@ -172,13 +182,17 @@ function MetricCard({
   label,
   value,
   detail,
-  accent = "text-cyan-300"
+  accent = "text-cyan-300",
+  actionLabel,
+  onAction
 }: {
   icon: ReactNode;
   label: string;
   value: string;
   detail: string;
   accent?: string;
+  actionLabel?: string;
+  onAction?: () => void;
 }) {
   return (
     <article className="group relative overflow-hidden rounded-lg border border-[color:var(--bandscope-border)] bg-[var(--bandscope-surface)] p-4 shadow-[0_18px_60px_rgba(0,0,0,0.24)] backdrop-blur-xl transition hover:-translate-y-0.5 hover:border-cyan-300/40">
@@ -189,6 +203,15 @@ function MetricCard({
           <p className="text-[0.68rem] font-semibold uppercase tracking-[0.22em] text-slate-400">{label}</p>
           <p className="mt-1 text-2xl font-semibold tracking-tight text-white">{value}</p>
           <p className="mt-1 text-sm text-slate-400">{detail}</p>
+          {actionLabel && onAction ? (
+            <Button
+              type="button"
+              className="relative mt-3 min-h-11 bg-gradient-to-r from-cyan-400 to-violet-500 font-black text-slate-950"
+              onClick={onAction}
+            >
+              {actionLabel}
+            </Button>
+          ) : null}
         </div>
       </div>
     </article>
@@ -264,6 +287,12 @@ export function App() {
   const [youtubeUrl, setYoutubeUrl] = useState("");
   const [isImporting, setIsImporting] = useState(false);
   const [activeView, setActiveView] = useState<RehearsalView>("workspace");
+  const [openedCockpitMetrics, setOpenedCockpitMetrics] = useState<{
+    songId: string;
+    tempo: boolean;
+    key: boolean;
+    transpose: boolean;
+  } | null>(null);
   const activeJobIdRef = useRef<string | null>(null);
   const youtubeInputRef = useRef<HTMLInputElement | null>(null);
 
@@ -518,6 +547,29 @@ export function App() {
   };
 
   const currentView: RehearsalView = jobResult && activeView === "score" ? "score" : "workspace";
+  const readySongId = typeof jobResult?.id === "string" ? jobResult.id : "";
+  const tonightTempo = resolveTonightTempo(jobResult);
+  const tonightChord = resolveTonightStartingChord(jobResult);
+  const tonightTranspose = resolveTonightTransposePlan(jobResult);
+  const openedMetrics =
+    openedCockpitMetrics?.songId === readySongId
+      ? openedCockpitMetrics
+      : { songId: readySongId, tempo: false, key: false, transpose: false };
+
+  /** Mark a cockpit next action complete only after the workspace surface actually moved. */
+  const handleCockpitMetricAction = (
+    metric: "tempo" | "key" | "transpose",
+    surfaceIds: readonly string[]
+  ) => {
+    if (!scrollToWorkspaceSurface(surfaceIds) || readySongId.length === 0) {
+      return;
+    }
+    setOpenedCockpitMetrics({
+      ...openedMetrics,
+      songId: readySongId,
+      [metric]: true
+    });
+  };
 
   /** Resolve label, enablement, and active state for one sidebar item. */
   const navButtonState = (item: (typeof NAV_ITEMS)[number]) => {
@@ -834,9 +886,87 @@ export function App() {
           </section>
 
           <header aria-label={t("analysisSummaryAriaLabel")} className="mb-4 grid gap-3 md:grid-cols-2 xl:grid-cols-5">
-            <MetricCard icon={<Clock3 className="size-5" aria-hidden="true" />} label={t("metricTempoLabel")} value={t("metricPendingValue")} detail={t("metricTempoPendingDetail")} accent="text-sky-300" />
-            <MetricCard icon={<KeyRound className="size-5" aria-hidden="true" />} label={t("metricKeyLabel")} value={t("metricPendingValue")} detail={t("metricKeyPendingDetail")} accent="text-cyan-300" />
-            <MetricCard icon={<Wand2 className="size-5" aria-hidden="true" />} label={t("metricTransposeLabel")} value={t("metricPendingValue")} detail={t("metricTransposePendingDetail")} accent="text-blue-300" />
+            <MetricCard
+              icon={<Clock3 className="size-5" aria-hidden="true" />}
+              label={t("metricTempoLabel")}
+              value={
+                tonightTempo
+                  ? formatMetricCopy(t("metricTempoReadyValue"), { bpm: String(tonightTempo.bpm) })
+                  : t("metricPendingValue")
+              }
+              detail={
+                tonightTempo
+                  ? formatMetricCopy(
+                      t(openedMetrics.tempo ? "metricTempoArmed" : "metricTempoReadyDetail"),
+                      { bpm: String(tonightTempo.bpm) }
+                    )
+                  : t("metricTempoPendingDetail")
+              }
+              actionLabel={
+                tonightTempo ? formatMetricCopy(t("metricTempoAction"), { bpm: String(tonightTempo.bpm) }) : undefined
+              }
+              onAction={
+                tonightTempo
+                  ? () => handleCockpitMetricAction("tempo", [WORKSPACE_SURFACE_TEMPO])
+                  : undefined
+              }
+              accent="text-sky-300"
+            />
+            <MetricCard
+              icon={<KeyRound className="size-5" aria-hidden="true" />}
+              label={t("metricKeyLabel")}
+              value={tonightChord ? tonightChord.chord : t("metricPendingValue")}
+              detail={
+                tonightChord
+                  ? formatMetricCopy(
+                      t(openedMetrics.key ? "metricKeyArmed" : "metricKeyReadyDetail"),
+                      { chord: tonightChord.chord, role: tonightChord.roleName }
+                    )
+                  : t("metricKeyPendingDetail")
+              }
+              actionLabel={
+                tonightChord
+                  ? formatMetricCopy(t("metricKeyAction"), {
+                      chord: tonightChord.chord,
+                      role: tonightChord.roleName
+                    })
+                  : undefined
+              }
+              onAction={
+                tonightChord
+                  ? () => handleCockpitMetricAction("key", [WORKSPACE_SURFACE_HARMONY])
+                  : undefined
+              }
+              accent="text-cyan-300"
+            />
+            <MetricCard
+              icon={<Wand2 className="size-5" aria-hidden="true" />}
+              label={t("metricTransposeLabel")}
+              value={tonightTranspose ? tonightTranspose.roleName : t("metricPendingValue")}
+              detail={
+                tonightTranspose
+                  ? formatMetricCopy(
+                      t(openedMetrics.transpose ? "metricTransposeArmed" : "metricTransposeReadyDetail"),
+                      { role: tonightTranspose.roleName, plan: tonightTranspose.plan }
+                    )
+                  : t("metricTransposePendingDetail")
+              }
+              actionLabel={
+                tonightTranspose
+                  ? formatMetricCopy(t("metricTransposeAction"), { role: tonightTranspose.roleName })
+                  : undefined
+              }
+              onAction={
+                tonightTranspose
+                  ? () =>
+                      handleCockpitMetricAction("transpose", [
+                        WORKSPACE_SURFACE_TRANSPOSE,
+                        WORKSPACE_SURFACE_HARMONY
+                      ])
+                  : undefined
+              }
+              accent="text-blue-300"
+            />
             <ConfidenceMetric song={jobResult} t={t} />
             <MetricCard icon={<Star className="size-5 fill-amber-300 text-amber-300" aria-hidden="true" />} label={t("metricPriorityLabel")} value={priorityLabel(jobResult, t)} detail={jobResult?.exportSummary?.headline ?? t("metricPriorityPendingDetail")} accent="text-amber-300" />
           </header>
diff --git a/apps/desktop/src/features/workspace/Workspace.test.tsx b/apps/desktop/src/features/workspace/Workspace.test.tsx
index a3da5ffe6..330539332 100644
--- a/apps/desktop/src/features/workspace/Workspace.test.tsx
+++ b/apps/desktop/src/features/workspace/Workspace.test.tsx
@@ -270,4 +270,16 @@ describe("Workspace", () => {
     expect(screen.getByText("합주 우선순위")).toBeTruthy();
     expect(screen.getByText("역할과 화성")).toBeTruthy();
   });
+
+  it("exposes renderer-owned surfaces for cockpit tempo, chord, and transpose actions", () => {
+    const song = createDemoRehearsalSong();
+    render(<Workspace song={song} />);
+
+    expect(document.getElementById("workspace-surface-tempo")).toBeTruthy();
+    expect(document.getElementById("workspace-surface-harmony")).toBeTruthy();
+    expect(document.getElementById("workspace-surface-transpose")).toBeNull();
+
+    fireEvent.click(screen.getByRole("tab", { name: "Bass Guitar" }));
+    expect(document.getElementById("workspace-surface-transpose")).toBeTruthy();
+  });
 });
diff --git a/apps/desktop/src/features/workspace/Workspace.tsx b/apps/desktop/src/features/workspace/Workspace.tsx
index 71546b524..3953be7c2 100644
--- a/apps/desktop/src/features/workspace/Workspace.tsx
+++ b/apps/desktop/src/features/workspace/Workspace.tsx
@@ -245,7 +245,10 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
               <div className="flex items-center gap-2">
                 <p className="text-xs font-black uppercase tracking-[0.3em] text-cyan-300">{t("workspaceRehearsalMapLabel")}</p>
                 {song.tempo && (
-                  <span className="rounded-full border border-cyan-300/30 bg-cyan-300/10 px-2.5 py-0.5 text-[0.65rem] font-bold text-cyan-100">
+                  <span
+                    id="workspace-surface-tempo"
+                    className="rounded-full border border-cyan-300/30 bg-cyan-300/10 px-2.5 py-0.5 text-[0.65rem] font-bold text-cyan-100"
+                  >
                     {t("workspaceTempoLabel")}: {song.tempo} BPM
                   </span>
                 )}
@@ -333,7 +336,7 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
 
           <SongStructure sections={song.sections} t={t} />
 
-          <section className="rounded-2xl border border-white/10 bg-white/[0.04] p-4">
+          <section className="rounded-2xl border border-white/10 bg-white/[0.04] p-4" id="workspace-surface-harmony">
             <div className="mb-4 flex flex-col gap-3 lg:flex-row lg:items-center lg:justify-between">
               <div>
                 <p className="text-xs font-black uppercase tracking-[0.24em] text-slate-300">{t("workspaceRolesHarmonyLabel")}</p>
@@ -416,7 +419,10 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
                       {roleHarmonicExplanation}
                     </p>
                   </div>
-                  <div className="rounded-xl border border-indigo-300/20 bg-indigo-300/[0.08] p-3">
+                  <div
+                    id="workspace-surface-transpose"
+                    className="rounded-xl border border-indigo-300/20 bg-indigo-300/[0.08] p-3"
+                  >
                     <div className="flex items-center gap-2 text-indigo-100">
                       <ClipboardList className="size-4" aria-hidden="true" />
                       <p className="text-[0.7rem] font-black uppercase tracking-[0.22em]">{t("workspaceTranspositionLabel")}</p>
diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts
new file mode 100644
index 000000000..37c7a3ffe
--- /dev/null
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts
@@ -0,0 +1,65 @@
+import { createDemoRehearsalSong } from "@bandscope/shared-types";
+import { describe, expect, it } from "vitest";
+import {
+  resolveTonightStartingChord,
+  resolveTonightTempo,
+  resolveTonightTransposePlan
+} from "./rehearsalMetrics";
+
+describe("rehearsal cockpit metrics inherited metadata", () => {
+  it("rejects a song whose required metadata is inherited", () => {
+    const song = createDemoRehearsalSong();
+    const inheritedSong = Object.create({
+      tempo: 120,
+      sections: song.sections
+    }) as typeof song;
+    expect(resolveTonightTempo(inheritedSong)).toBeNull();
+    expect(resolveTonightStartingChord(inheritedSong)).toBeNull();
+    expect(resolveTonightTransposePlan(inheritedSong)).toBeNull();
+  });
+
+  it("rejects inherited timing fields", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.timeRange = Object.create({ start: 10, end: 30 }) as typeof song.sections[0]["timeRange"];
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("does not let inherited role or graph metadata establish the first-entrance part", () => {
+    const song = createDemoRehearsalSong();
+    const role = song.sections[0]!.roles[0]!;
+    const node = song.sections[0]!.partGraph[0]!;
+    song.sections[0]!.roles = [Object.create(role) as typeof role];
+    song.sections[0]!.partGraph = [Object.create(node) as typeof node];
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("rejects arrays masquerading as section records", () => {
+    const song = createDemoRehearsalSong();
+    const arraySection = Object.assign([], song.sections[0]!) as unknown as (typeof song.sections)[number];
+    song.sections = [arraySection];
+    expect(resolveTonightStartingChord(song)).toBeNull();
+  });
+
+  it("rejects an inherited chord or transpose plan", () => {
+    const song = createDemoRehearsalSong();
+    const role = song.sections[0]!.roles[0]!;
+    const harmony = Object.create({ chord: "C#m7" }) as typeof role.harmony;
+    song.sections[0]!.roles = [
+      {
+        ...role,
+        harmony,
+        transpositionPlan: undefined
+      }
+    ];
+    song.sections[0]!.partGraph = [
+      { role_id: role.id, is_active: true, handoff_to: [], handoff_from: [] }
+    ];
+    Object.setPrototypeOf(song.sections[0]!.roles[0]!, {
+      transpositionPlan: "inherited plan"
+    });
+    expect(resolveTonightStartingChord(song)?.chord).not.toBe("C#m7");
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.scroll.test.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.scroll.test.ts
new file mode 100644
index 000000000..403dbf320
--- /dev/null
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.scroll.test.ts
@@ -0,0 +1,98 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  preferredMetricScrollBehavior,
+  scrollToWorkspaceSurface,
+  WORKSPACE_SURFACE_HARMONY,
+  WORKSPACE_SURFACE_TEMPO,
+  WORKSPACE_SURFACE_TRANSPOSE
+} from "./rehearsalMetrics";
+
+describe("scrollToWorkspaceSurface", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    document.body.replaceChildren();
+  });
+
+  it("scrolls the first renderer-owned surface and uses reduced-motion auto scrolling", () => {
+    vi.stubGlobal("matchMedia", (query: string) => ({
+      matches: query === "(prefers-reduced-motion: reduce)",
+      media: query,
+      onchange: null,
+      addListener: vi.fn(),
+      removeListener: vi.fn(),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn()
+    }));
+    expect(preferredMetricScrollBehavior()).toBe("auto");
+
+    const missing = document.createElement("div");
+    missing.id = WORKSPACE_SURFACE_TRANSPOSE;
+    const target = document.createElement("div");
+    target.id = WORKSPACE_SURFACE_HARMONY;
+    const scrollIntoView = vi.fn();
+    Object.defineProperty(target, "scrollIntoView", {
+      configurable: true,
+      value: scrollIntoView
+    });
+    document.body.append(missing, target);
+
+    expect(
+      scrollToWorkspaceSurface([
+        "   ",
+        WORKSPACE_SURFACE_TEMPO,
+        WORKSPACE_SURFACE_TRANSPOSE,
+        WORKSPACE_SURFACE_HARMONY
+      ])
+    ).toBe(true);
+    expect(scrollIntoView).toHaveBeenCalledWith({ block: "nearest", behavior: "auto" });
+  });
+
+  it("uses smooth scrolling when reduced motion is not requested", () => {
+    vi.stubGlobal("matchMedia", (query: string) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addListener: vi.fn(),
+      removeListener: vi.fn(),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn()
+    }));
+    expect(preferredMetricScrollBehavior()).toBe("smooth");
+
+    const target = document.createElement("div");
+    target.id = WORKSPACE_SURFACE_TEMPO;
+    const scrollIntoView = vi.fn();
+    Object.defineProperty(target, "scrollIntoView", {
+      configurable: true,
+      value: scrollIntoView
+    });
+    document.body.append(target);
+
+    expect(scrollToWorkspaceSurface([WORKSPACE_SURFACE_TEMPO])).toBe(true);
+    expect(scrollIntoView).toHaveBeenCalledWith({ block: "nearest", behavior: "smooth" });
+  });
+
+  it("returns false when no renderer-owned surface can scroll", () => {
+    expect(scrollToWorkspaceSurface([])).toBe(false);
+    expect(scrollToWorkspaceSurface([WORKSPACE_SURFACE_TEMPO])).toBe(false);
+    expect(preferredMetricScrollBehavior()).toBe("smooth");
+  });
+
+  it("skips a DOM node that cannot scroll", () => {
+    const target = document.createElement("div");
+    target.id = WORKSPACE_SURFACE_TEMPO;
+    Object.defineProperty(target, "scrollIntoView", {
+      configurable: true,
+      value: undefined
+    });
+    document.body.append(target);
+    expect(scrollToWorkspaceSurface([WORKSPACE_SURFACE_TEMPO])).toBe(false);
+  });
+
+  it("defaults to smooth scrolling when matchMedia is unavailable", () => {
+    vi.stubGlobal("matchMedia", undefined);
+    expect(preferredMetricScrollBehavior()).toBe("smooth");
+  });
+});
diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.test.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.test.ts
new file mode 100644
index 000000000..be3cf502e
--- /dev/null
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.test.ts
@@ -0,0 +1,380 @@
+import { describe, expect, it } from "vitest";
+import { MAX_SECTION_TIME_SECONDS, createDemoRehearsalSong } from "@bandscope/shared-types";
+import {
+  formatMetricCopy,
+  resolveTonightStartingChord,
+  resolveTonightTempo,
+  resolveTonightTransposePlan
+} from "./rehearsalMetrics";
+
+describe("formatMetricCopy", () => {
+  it("interpolates known placeholders once and leaves unknown tokens intact", () => {
+    expect(
+      formatMetricCopy("Count {bpm} in as {role} in {chord}. {plan} {missing}", {
+        bpm: "120",
+        role: "Bass Guitar",
+        chord: "C#m7",
+        plan: "Drop a whole step."
+      })
+    ).toBe("Count 120 in as Bass Guitar in C#m7. Drop a whole step. {missing}");
+    expect(formatMetricCopy("Count {bpm} in {chord}", {})).toBe("Count {bpm} in {chord}");
+  });
+});
+
+describe("resolveTonightTempo", () => {
+  it("returns null when no song is loaded", () => {
+    expect(resolveTonightTempo(null)).toBeNull();
+    expect(resolveTonightTempo(undefined)).toBeNull();
+  });
+
+  it("returns the demo song countable BPM", () => {
+    expect(resolveTonightTempo(createDemoRehearsalSong())).toEqual({ bpm: 120 });
+  });
+
+  it("rejects non-integer, non-positive, and out-of-range BPM values", () => {
+    const song = createDemoRehearsalSong();
+    song.tempo = 120.5;
+    expect(resolveTonightTempo(song)).toBeNull();
+    song.tempo = 0;
+    expect(resolveTonightTempo(song)).toBeNull();
+    song.tempo = -12;
+    expect(resolveTonightTempo(song)).toBeNull();
+    song.tempo = 401;
+    expect(resolveTonightTempo(song)).toBeNull();
+    song.tempo = Number.NaN;
+    expect(resolveTonightTempo(song)).toBeNull();
+    song.tempo = Number.POSITIVE_INFINITY;
+    expect(resolveTonightTempo(song)).toBeNull();
+  });
+
+  it("rejects a string tempo masquerading as a number", () => {
+    const song = createDemoRehearsalSong();
+    (song as unknown as { tempo: unknown }).tempo = "120";
+    expect(resolveTonightTempo(song)).toBeNull();
+  });
+});
+
+describe("resolveTonightStartingChord", () => {
+  it("names the first-entrance chord from the highest-priority active part", () => {
+    expect(resolveTonightStartingChord(createDemoRehearsalSong())).toEqual({
+      chord: "C#m7",
+      roleName: "Bass Guitar"
+    });
+  });
+
+  it("prefers a user harmony override on the selected part", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.roles[0]!.manualOverrides = [
+      {
+        field: "harmony",
+        value: {
+          chord: "C#m11",
+          functionLabel: "vi suspended lift",
+          source: "user"
+        },
+        source: "user"
+      }
+    ];
+    expect(resolveTonightStartingChord(song)).toEqual({
+      chord: "C#m11",
+      roleName: "Bass Guitar"
+    });
+  });
+
+  it("does not invent a chord from a later section when the first entrance has none", () => {
+    const song = createDemoRehearsalSong();
+    const verse = song.sections[0]!;
+    verse.roles = verse.roles.map((role) => ({
+      ...role,
+      harmony: { ...role.harmony, chord: "   " },
+      manualOverrides: []
+    }));
+    const chorus = structuredClone(verse);
+    chorus.id = "chorus-1";
+    chorus.label = "chorus";
+    chorus.timeRange = { start: 30, end: 46 };
+    chorus.roles = [
+      {
+        ...verse.roles[0]!,
+        harmony: { chord: "Emaj7", functionLabel: "I color", source: "model" }
+      }
+    ];
+    song.sections = [verse, chorus];
+    expect(resolveTonightStartingChord(song)).toBeNull();
+  });
+
+  it("returns null for a non-object song root", () => {
+    expect(resolveTonightStartingChord(null)).toBeNull();
+  });
+
+  it("returns null when the runtime section collection is sparse", () => {
+    const song = createDemoRehearsalSong();
+    const sparseSections: typeof song.sections = new Array(1);
+    sparseSections[0] = song.sections[0]!;
+    // make it sparse by deleting index 0 after allocating length 2
+    const holes: typeof song.sections = new Array(2);
+    holes[1] = song.sections[0]!;
+    song.sections = holes;
+    expect(resolveTonightStartingChord(song)).toBeNull();
+  });
+
+  it("keeps the first entrance unlabeled when role identities are duplicated", () => {
+    const song = createDemoRehearsalSong();
+    const role = song.sections[0]!.roles[0]!;
+    song.sections[0]!.roles = [role, { ...role }];
+    song.sections[0]!.partGraph = [
+      { role_id: role.id, is_active: true, handoff_to: [], handoff_from: [] },
+      { role_id: role.id, is_active: true, handoff_to: [], handoff_from: [] }
+    ];
+    expect(resolveTonightStartingChord(song)).toBeNull();
+  });
+
+  it("skips a first section whose rehearsal window is unbounded", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.timeRange = { start: Number.NaN, end: 30 };
+    expect(resolveTonightStartingChord(song)).toBeNull();
+  });
+
+  it("skips a first section whose endpoint overflows the shared timing bound", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.timeRange = {
+      start: MAX_SECTION_TIME_SECONDS,
+      end: MAX_SECTION_TIME_SECONDS + 1
+    };
+    expect(resolveTonightStartingChord(song)).toBeNull();
+  });
+
+  it("skips inactive parts and non-harmony overrides before using the owned model chord", () => {
+    const song = createDemoRehearsalSong();
+    const verse = song.sections[0]!;
+    verse.roles[0] = {
+      ...verse.roles[0]!,
+      manualOverrides: [
+        {
+          field: "harmony",
+          value: {
+            chord: "ignored-inactive",
+            functionLabel: "vi",
+            source: "user"
+          },
+          source: "user"
+        }
+      ]
+    };
+    verse.partGraph[0] = { ...verse.partGraph[0]!, is_active: false };
+    verse.roles[1] = {
+      ...verse.roles[1]!,
+      manualOverrides: [
+        { field: "harmony", value: { chord: "Emaj9", functionLabel: "I", source: "user" }, source: "model" } as never,
+        { field: "harmony", source: "user", value: "not-an-object" } as never,
+        {
+          field: "harmony",
+          source: "user",
+          value: { chord: "   ", functionLabel: "I", source: "user" }
+        }
+      ],
+      harmony: { chord: "Emaj7", functionLabel: "Imaj7 color", source: "model" }
+    };
+    expect(resolveTonightStartingChord(song)).toEqual({
+      chord: "Emaj7",
+      roleName: "Keyboard 1 Right Hand"
+    });
+  });
+
+  it("prefers the earlier of two labeled first-entrance windows", () => {
+    const song = createDemoRehearsalSong();
+    const verse = song.sections[0]!;
+    const intro = structuredClone(verse);
+    intro.id = "intro-1";
+    intro.label = "intro";
+    intro.timeRange = { start: 0, end: 8 };
+    intro.roles = [
+      {
+        ...verse.roles[0]!,
+        harmony: { chord: "B5", functionLabel: "v pedal", source: "model" },
+        manualOverrides: []
+      }
+    ];
+    intro.partGraph = [{ role_id: verse.roles[0]!.id, is_active: true, handoff_to: [], handoff_from: [] }];
+    song.sections = [verse, intro];
+    expect(resolveTonightStartingChord(song)).toEqual({
+      chord: "B5",
+      roleName: "Bass Guitar"
+    });
+  });
+
+  it("skips a zero-length first-entrance window", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.timeRange = { start: 10, end: 10 };
+    expect(resolveTonightStartingChord(song)).toBeNull();
+  });
+
+  it("returns null when the first entrance has no dense role graph", () => {
+    const song = createDemoRehearsalSong();
+    delete (song.sections[0] as { roles?: unknown }).roles;
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("falls through a non-harmony override and a missing harmony record", () => {
+    const song = createDemoRehearsalSong();
+    const verse = song.sections[0]!;
+    verse.roles = [
+      {
+        ...verse.roles[0]!,
+        manualOverrides: [{ field: "not-harmony", source: "user", value: { chord: "X", functionLabel: "x", source: "user" } } as never],
+        harmony: undefined as never
+      }
+    ];
+    verse.partGraph = [{ role_id: verse.roles[0]!.id, is_active: true, handoff_to: [], handoff_from: [] }];
+    expect(resolveTonightStartingChord(song)).toBeNull();
+  });
+
+  it("keeps equal first-entrance windows ordered when their ids match", () => {
+    const song = createDemoRehearsalSong();
+    const verse = song.sections[0]!;
+    const clone = structuredClone(verse);
+    clone.roles = [
+      {
+        ...verse.roles[0]!,
+        harmony: { chord: "F#m7", functionLabel: "ii", source: "model" },
+        manualOverrides: []
+      }
+    ];
+    clone.partGraph = [{ role_id: verse.roles[0]!.id, is_active: true, handoff_to: [], handoff_from: [] }];
+    song.sections = [verse, clone];
+    expect(resolveTonightStartingChord(song)?.chord).toBe("C#m7");
+  });
+
+  it("rejects a present non-array section collection", () => {
+    const song = createDemoRehearsalSong();
+    (song as unknown as { sections: unknown }).sections = { 0: song.sections[0] };
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("rejects section collections whose length is not a dense runtime bound", () => {
+    const song = createDemoRehearsalSong();
+    const withLength = (length: number) =>
+      new Proxy([] as typeof song.sections, {
+        get(target, prop, receiver) {
+          if (prop === "length") {
+            return length;
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
+    (song as { sections: typeof song.sections }).sections = withLength(Number.NaN);
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    (song as { sections: typeof song.sections }).sections = withLength(-1);
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    (song as { sections: typeof song.sections }).sections = withLength(0x100000000);
+    expect(resolveTonightStartingChord(song)).toBeNull();
+  });
+
+  it("skips a first section that does not own a rehearsal window", () => {
+    const song = createDemoRehearsalSong();
+    delete (song.sections[0] as { timeRange?: unknown }).timeRange;
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("skips a first section whose window is missing an owned endpoint", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.timeRange = { start: 0 } as typeof song.sections[0]["timeRange"];
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    song.sections[0]!.timeRange = { end: 16 } as typeof song.sections[0]["timeRange"];
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("rejects owned timing fields that are present but empty", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.timeRange = { start: undefined as never, end: 16 };
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    song.sections[0]!.timeRange = { start: 0, end: undefined as never };
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+    song.sections[0]!.timeRange = { start: null as never, end: 16 };
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    song.sections[0]!.timeRange = { start: 0, end: null as never };
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("falls through missing or non-dense manual override collections to the owned model chord", () => {
+    const song = createDemoRehearsalSong();
+    const verse = song.sections[0]!;
+    const role = verse.roles[0]!;
+    delete (role as { manualOverrides?: unknown }).manualOverrides;
+    verse.roles = [role];
+    verse.partGraph = [{ role_id: role.id, is_active: true, handoff_to: [], handoff_from: [] }];
+    expect(resolveTonightStartingChord(song)).toEqual({
+      chord: "C#m7",
+      roleName: "Bass Guitar"
+    });
+    (role as { manualOverrides?: unknown }).manualOverrides = { 0: { field: "harmony", source: "user", value: { chord: "X" } } };
+    expect(resolveTonightStartingChord(song)?.chord).toBe("C#m7");
+    const sparse: typeof role.manualOverrides = new Array(1);
+    (role as { manualOverrides: typeof role.manualOverrides }).manualOverrides = sparse;
+    expect(resolveTonightStartingChord(song)?.chord).toBe("C#m7");
+  });
+
+  it("returns null when the first entrance owns a non-array part graph", () => {
+    const song = createDemoRehearsalSong();
+    delete (song.sections[0] as { partGraph?: unknown }).partGraph;
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    (song.sections[0] as { partGraph?: unknown }).partGraph = { 0: { role_id: "bass-guitar", is_active: true } };
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+});
+
+describe("resolveTonightTransposePlan", () => {
+  it("names the first-entrance setup from the highest-priority part that has a plan", () => {
+    const resolved = resolveTonightTransposePlan(createDemoRehearsalSong());
+    expect(resolved?.roleName).toBe("Bass Guitar");
+    expect(resolved?.plan).toContain("whole step lower");
+  });
+
+  it("does not substitute simplification copy for a missing transpose plan", () => {
+    const song = createDemoRehearsalSong();
+    for (const role of song.sections[0]!.roles) {
+      delete role.transpositionPlan;
+    }
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("rejects a multiline or oversized plan instead of rendering a payload", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.roles[0]!.transpositionPlan = "first line\nsecret path";
+    song.sections[0]!.roles[1]!.transpositionPlan = "x".repeat(181);
+    song.sections[0]!.roles[2]!.transpositionPlan = "   ";
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("breaks equal-priority role ties with locale-independent id ordering", () => {
+    const song = createDemoRehearsalSong();
+    const verse = song.sections[0]!;
+    verse.roles = [
+      {
+        ...verse.roles[0]!,
+        id: "ä-role",
+        name: "Umlaut role",
+        rehearsalPriority: "high",
+        transpositionPlan: "Move the umlaut part down."
+      },
+      {
+        ...verse.roles[0]!,
+        id: "z-role",
+        name: "ASCII role",
+        rehearsalPriority: "high",
+        transpositionPlan: "Move the ASCII part down."
+      }
+    ];
+    verse.partGraph = [
+      { role_id: "ä-role", is_active: true, handoff_to: [], handoff_from: [] },
+      { role_id: "z-role", is_active: true, handoff_to: [], handoff_from: [] }
+    ];
+    expect(resolveTonightTransposePlan(song)).toEqual({
+      plan: "Move the ASCII part down.",
+      roleName: "ASCII role"
+    });
+  });
+});
diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
new file mode 100644
index 000000000..29b86b20d
--- /dev/null
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
@@ -0,0 +1,358 @@
+import {
+  MAX_SECTION_TIME_SECONDS,
+  SECTION_FORM_LABELS,
+  type RehearsalHarmony,
+  type RehearsalRole,
+  type RehearsalSection,
+  type RehearsalSong
+} from "@bandscope/shared-types";
+
+const PRIORITY_RANK = { high: 0, medium: 1, low: 2 } as const;
+const MAX_REHEARSAL_BPM = 400;
+const MAX_CHORD_LENGTH = 32;
+const MAX_ROLE_NAME_LENGTH = 80;
+const MAX_PLAN_LENGTH = 180;
+const SECTION_FORM_LABEL_OWNED: Readonly<Record<string, true>> = Object.freeze(
+  Object.fromEntries(SECTION_FORM_LABELS.map((label) => [label, true]))
+);
+
+/** Renderer-owned workspace targets for cockpit next actions. */
+export const WORKSPACE_SURFACE_TEMPO = "workspace-surface-tempo";
+/** Renderer-owned workspace target for the first-entrance chord. */
+export const WORKSPACE_SURFACE_HARMONY = "workspace-surface-harmony";
+/** Renderer-owned workspace target for tonight's transpose setup. */
+export const WORKSPACE_SURFACE_TRANSPOSE = "workspace-surface-transpose";
+
+/** Integer BPM the room can count in before the first entrance. */
+export type TonightTempo = {
+  bpm: number;
+};
+
+/** First-entrance chord shape, not a claimed song-wide key. */
+export type TonightStartingChord = {
+  chord: string;
+  roleName: string;
+};
+
+/** First-entrance transpose/setup plan for a ranked part. */
+export type TonightTransposePlan = {
+  plan: string;
+  roleName: string;
+};
+
+const METRIC_COPY_KEYS = ["bpm", "chord", "role", "plan"] as const;
+type MetricCopyKey = (typeof METRIC_COPY_KEYS)[number];
+
+/** Interpolate cockpit placeholders once so rehearsal data is never rescanned as template syntax. */
+export function formatMetricCopy(
+  template: string,
+  values: Readonly<Partial<Record<MetricCopyKey, string>>>
+): string {
+  return template.replace(/\{(bpm|chord|role|plan)\}/g, (placeholder) => {
+    const key = placeholder.slice(1, -1) as MetricCopyKey;
+    return values[key] ?? placeholder;
+  });
+}
+
+/** Use immediate scrolling when the operating system requests reduced motion. */
+export function preferredMetricScrollBehavior(): ScrollBehavior {
+  return typeof window.matchMedia === "function" &&
+    window.matchMedia("(prefers-reduced-motion: reduce)").matches
+    ? "auto"
+    : "smooth";
+}
+
+/** Scroll the first renderer-owned surface that actually exists. */
+export function scrollToWorkspaceSurface(surfaceIds: readonly string[]): boolean {
+  for (const surfaceId of surfaceIds) {
+    if (typeof surfaceId !== "string" || surfaceId.trim().length === 0) {
+      continue;
+    }
+    const target = document.getElementById(surfaceId);
+    if (typeof target?.scrollIntoView !== "function") {
+      continue;
+    }
+    target.scrollIntoView({
+      block: "nearest",
+      behavior: preferredMetricScrollBehavior()
+    });
+    return true;
+  }
+  return false;
+}
+
+/** Compare opaque ids by Unicode code units so tie-breaking never depends on host locale. */
+function compareStableId(left: string, right: string): number {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+
+/** Return whether an untrusted runtime value can be inspected as a record. */
+function isRuntimeObject(value: unknown): value is object {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** Return whether a runtime record owns the named field rather than inheriting it. */
+function hasOwn(value: object, key: PropertyKey): boolean {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+/** Return whether every numeric index is an own element in a bounded runtime array. */
+function isDenseRuntimeArray(value: unknown): value is unknown[] {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+  const length = Number(value.length);
+  if (!Number.isSafeInteger(length) || length < 0 || length > 0xffffffff) {
+    return false;
+  }
+  for (let index = 0; index < length; index += 1) {
+    if (!hasOwn(value, index)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/** Return a bounded non-empty own string, or null. */
+function readBoundedOwnString(record: object, key: PropertyKey, maxLength: number): string | null {
+  if (!hasOwn(record, key)) {
+    return null;
+  }
+  const value = (record as Record<PropertyKey, unknown>)[key];
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.length > maxLength || /[\r\n]/.test(trimmed)) {
+    return null;
+  }
+  return trimmed;
+}
+
+/** Return whether the role has safe owned identity/copy and ranked rehearsal priority. */
+function hasRankedPriority(role: RehearsalRole): boolean {
+  return (
+    readBoundedOwnString(role, "id", MAX_ROLE_NAME_LENGTH) !== null &&
+    readBoundedOwnString(role, "name", MAX_ROLE_NAME_LENGTH) !== null &&
+    hasOwn(role, "rehearsalPriority") &&
+    Object.prototype.hasOwnProperty.call(PRIORITY_RANK, role.rehearsalPriority)
+  );
+}
+
+/** Return whether a section owns a bounded, positive-length integer rehearsal window. */
+function hasBoundedTimeRange(section: RehearsalSection): boolean {
+  if (!hasOwn(section, "timeRange")) {
+    return false;
+  }
+  const timeRange = section.timeRange as Partial<RehearsalSection["timeRange"]> | null;
+  if (!isRuntimeObject(timeRange) || !hasOwn(timeRange, "start") || !hasOwn(timeRange, "end")) {
+    return false;
+  }
+
+  const start = timeRange.start ?? -1;
+  const end = timeRange.end ?? -1;
+  return (
+    Number.isInteger(start) &&
+    start >= 0 &&
+    start <= MAX_SECTION_TIME_SECONDS &&
+    Number.isInteger(end) &&
+    end > start &&
+    end <= MAX_SECTION_TIME_SECONDS
+  );
+}
+
+/** Return safe identities that appear more than once in one section-local collection. */
+function repeatedIds(ids: string[]): Set<string> {
+  const seen = new Set<string>();
+  const repeated = new Set<string>();
+  for (const id of ids) {
+    if (seen.has(id)) {
+      repeated.add(id);
+    } else {
+      seen.add(id);
+    }
+  }
+  return repeated;
+}
+
+/** Prefer the highest-priority ranked role, then a locale-independent stable id order. */
+function sortRankedRoles(roles: RehearsalRole[]): RehearsalRole[] {
+  return [...roles].sort((left, right) => {
+    const rankDelta = PRIORITY_RANK[left.rehearsalPriority] - PRIORITY_RANK[right.rehearsalPriority];
+    if (rankDelta !== 0) {
+      return rankDelta;
+    }
+    return compareStableId(left.id, right.id);
+  });
+}
+
+/** Return ranked roles whose unique graph node is explicitly active. */
+function rankedActiveRoles(section: RehearsalSection): RehearsalRole[] {
+  if (
+    !hasOwn(section, "roles") ||
+    !hasOwn(section, "partGraph") ||
+    !isDenseRuntimeArray(section.roles) ||
+    !isDenseRuntimeArray(section.partGraph)
+  ) {
+    return [];
+  }
+
+  const safeRoleIds = section.roles
+    .filter(
+      (role) =>
+        isRuntimeObject(role) && readBoundedOwnString(role, "id", MAX_ROLE_NAME_LENGTH) !== null
+    )
+    .map((role) => role.id);
+  const safeGraphRoleIds = section.partGraph
+    .filter(
+      (node) =>
+        isRuntimeObject(node) &&
+        hasOwn(node, "role_id") &&
+        typeof node.role_id === "string" &&
+        node.role_id.trim().length > 0
+    )
+    .map((node) => node.role_id);
+  const repeatedRoleIds = repeatedIds(safeRoleIds);
+  const repeatedGraphRoleIds = repeatedIds(safeGraphRoleIds);
+  const activeIds = new Set(
+    section.partGraph
+      .filter(
+        (node) =>
+          isRuntimeObject(node) &&
+          hasOwn(node, "is_active") &&
+          node.is_active === true &&
+          hasOwn(node, "role_id") &&
+          typeof node.role_id === "string" &&
+          node.role_id.trim().length > 0 &&
+          !repeatedGraphRoleIds.has(node.role_id)
+      )
+      .map((node) => node.role_id)
+  );
+
+  return sortRankedRoles(
+    section.roles.filter(
+      (role) =>
+        isRuntimeObject(role) &&
+        hasRankedPriority(role) &&
+        !repeatedRoleIds.has(role.id) &&
+        activeIds.has(role.id)
+    )
+  );
+}
+
+/** Return a safe chord symbol from an owned harmony record. */
+function readChord(harmony: object): string | null {
+  return readBoundedOwnString(harmony, "chord", MAX_CHORD_LENGTH);
+}
+
+/** Prefer a user harmony override, then the role's owned model chord. */
+function roleChord(role: RehearsalRole): string | null {
+  if (hasOwn(role, "manualOverrides") && isDenseRuntimeArray(role.manualOverrides)) {
+    for (const item of role.manualOverrides) {
+      if (!isRuntimeObject(item) || !hasOwn(item, "field") || item.field !== "harmony") {
+        continue;
+      }
+      if (!hasOwn(item, "source") || item.source !== "user") {
+        continue;
+      }
+      if (!hasOwn(item, "value") || !isRuntimeObject(item.value)) {
+        continue;
+      }
+      const overridden = readChord(item.value as RehearsalHarmony);
+      if (overridden) {
+        return overridden;
+      }
+    }
+  }
+  if (!hasOwn(role, "harmony") || !isRuntimeObject(role.harmony)) {
+    return null;
+  }
+  return readChord(role.harmony);
+}
+
+/** Return the first safe first-entrance section, or null. */
+function firstEntranceSection(song: RehearsalSong): RehearsalSection | null {
+  if (!isRuntimeObject(song) || !hasOwn(song, "sections") || !isDenseRuntimeArray(song.sections)) {
+    return null;
+  }
+
+  const sections = song.sections
+    .filter(
+      (section) =>
+        isRuntimeObject(section) &&
+        readBoundedOwnString(section, "id", MAX_ROLE_NAME_LENGTH) !== null &&
+        hasOwn(section, "label") &&
+        typeof section.label === "string" &&
+        Object.prototype.hasOwnProperty.call(SECTION_FORM_LABEL_OWNED, section.label) &&
+        hasBoundedTimeRange(section)
+    )
+    .sort((left, right) => {
+      if (left.timeRange.start !== right.timeRange.start) {
+        return left.timeRange.start - right.timeRange.start;
+      }
+      return compareStableId(left.id, right.id);
+    });
+
+  return sections[0] ?? null;
+}
+
+/** Return tonight's countable BPM, or null when the value is not a rehearsal tempo. */
+export function resolveTonightTempo(song: RehearsalSong | null | undefined): TonightTempo | null {
+  if (!isRuntimeObject(song) || !hasOwn(song, "tempo")) {
+    return null;
+  }
+  const bpm = (song as RehearsalSong).tempo;
+  if (
+    typeof bpm !== "number" ||
+    !Number.isInteger(bpm) ||
+    bpm <= 0 ||
+    bpm > MAX_REHEARSAL_BPM
+  ) {
+    return null;
+  }
+  return { bpm };
+}
+
+/** Return the first-entrance chord shape, or null when no safe chord remains. */
+export function resolveTonightStartingChord(
+  song: RehearsalSong | null | undefined
+): TonightStartingChord | null {
+  const section = firstEntranceSection(song as RehearsalSong);
+  if (!section) {
+    return null;
+  }
+  for (const role of rankedActiveRoles(section)) {
+    const chord = roleChord(role);
+    const roleName = readBoundedOwnString(role, "name", MAX_ROLE_NAME_LENGTH);
+    if (chord && roleName) {
+      return { chord, roleName };
+    }
+  }
+  return null;
+}
+
+/** Return the first-entrance transpose plan, or null when no setup note remains. */
+export function resolveTonightTransposePlan(
+  song: RehearsalSong | null | undefined
+): TonightTransposePlan | null {
+  const section = firstEntranceSection(song as RehearsalSong);
+  if (!section) {
+    return null;
+  }
+  for (const role of rankedActiveRoles(section)) {
+    const plan = readBoundedOwnString(role, "transpositionPlan", MAX_PLAN_LENGTH);
+    const roleName = readBoundedOwnString(role, "name", MAX_ROLE_NAME_LENGTH);
+    if (plan && roleName) {
+      return { plan, roleName };
+    }
+  }
+  return null;
+}
+
+
diff --git a/apps/desktop/src/i18n/index.test.ts b/apps/desktop/src/i18n/index.test.ts
index dc49a0a25..c3103f613 100644
--- a/apps/desktop/src/i18n/index.test.ts
+++ b/apps/desktop/src/i18n/index.test.ts
@@ -74,5 +74,12 @@ describe("i18n", () => {
         koDictionary.appSubtitle = originalSubtitle;
       }
     });
+
+    it("keeps Korean cockpit next-action copy for tempo, chord, and transpose", () => {
+      const t = createTranslator("ko");
+      expect(t("metricTempoAction")).toBe("오늘 카운트 위치 열기");
+      expect(t("metricKeyAction")).toBe("오늘 첫 코드 열기");
+      expect(t("metricTransposeAction")).toBe("{role} 세팅 잠그기");
+    });
   });
 });
diff --git a/apps/desktop/src/locales/en/common.json b/apps/desktop/src/locales/en/common.json
index 39f716d50..ebb604136 100644
--- a/apps/desktop/src/locales/en/common.json
+++ b/apps/desktop/src/locales/en/common.json
@@ -148,5 +148,15 @@
   "practiceProgressRegionLabel": "Practice Progress",
   "practiceProgressLabel": "Practice Progress",
   "decreasePracticeProgressLabel": "Decrease progress",
-  "increasePracticeProgressLabel": "Increase progress"
+  "increasePracticeProgressLabel": "Increase progress",
+  "metricTempoReadyValue": "{bpm} BPM",
+  "metricTempoReadyDetail": "Count {bpm} in before the first entrance.",
+  "metricTempoAction": "Open tonight's count-in",
+  "metricTempoArmed": "Count {bpm} together. Start from the map.",
+  "metricKeyReadyDetail": "{role} starts in this shape. Check the first entrance.",
+  "metricKeyAction": "Open tonight's first chord",
+  "metricKeyArmed": "Check {chord} at the first entrance before the room starts.",
+  "metricTransposeReadyDetail": "{role}: {plan}",
+  "metricTransposeAction": "Lock {role}'s setup",
+  "metricTransposeArmed": "Lock {role}'s setup, then count in from the map."
 }
diff --git a/apps/desktop/src/locales/ko/common.json b/apps/desktop/src/locales/ko/common.json
index 371884abb..b283e24c7 100644
--- a/apps/desktop/src/locales/ko/common.json
+++ b/apps/desktop/src/locales/ko/common.json
@@ -148,5 +148,15 @@
   "practiceProgressRegionLabel": "연습 진척도",
   "practiceProgressLabel": "연습 진척도",
   "decreasePracticeProgressLabel": "진척도 감소",
-  "increasePracticeProgressLabel": "진척도 증가"
+  "increasePracticeProgressLabel": "진척도 증가",
+  "metricTempoReadyValue": "{bpm} BPM",
+  "metricTempoReadyDetail": "첫 시작 전에 {bpm}으로 카운트하세요.",
+  "metricTempoAction": "오늘 카운트 위치 열기",
+  "metricTempoArmed": "{bpm}으로 같이 세고 지도에서 들어가세요.",
+  "metricKeyReadyDetail": "{role} 파트가 이 모양으로 시작합니다. 첫 시작을 확인하세요.",
+  "metricKeyAction": "오늘 첫 코드 열기",
+  "metricKeyArmed": "방에 들어가기 전에 첫 시작에서 {chord} 모양을 확인하세요.",
+  "metricTransposeReadyDetail": "{role}: {plan}",
+  "metricTransposeAction": "{role} 세팅 잠그기",
+  "metricTransposeArmed": "{role} 세팅을 잠그고 지도에서 카운트하세요."
 }
diff --git a/apps/desktop/vite.config.ts b/apps/desktop/vite.config.ts
index f1db6f2b8..d587c3219 100644
--- a/apps/desktop/vite.config.ts
+++ b/apps/desktop/vite.config.ts
@@ -25,7 +25,8 @@ export default defineConfig({
         "src/i18n/index.ts",
         "src/features/score/ScoreViewer.tsx",
         "src/features/score/ScoreView.tsx",
-        "src/features/score/scoreStorage.ts"
+        "src/features/score/scoreStorage.ts",
+        "src/features/workspace/rehearsalMetrics.ts"
       ],
       thresholds: {
         lines: 90,
diff --git a/docs/design-system/component-contract.md b/docs/design-system/component-contract.md
index 22602c313..8c73653d1 100644
--- a/docs/design-system/component-contract.md
+++ b/docs/design-system/component-contract.md
@@ -25,7 +25,7 @@ The authoritative Figma view is `31 Component Contract Catalog`. This file mirro
 | Progress | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=18-602 | `apps/desktop/src/components/ui/progress.tsx` | Use `value` for progress; add indicator color classes only for semantic tone. |
 | Console Panel | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=18-632 | `apps/desktop/src/components/ui/card.tsx` | Use `Card`, `CardHeader`, `CardTitle`, and `CardContent`; `size="sm"` is the compact state. |
 | BandScope Mark | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-163 | `apps/desktop/src/App.tsx` | Feature-local `BandScopeMark()` currently has no props; Figma size variants are visual guidance only. |
-| Metric Card | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-216 | `apps/desktop/src/App.tsx` | Feature-local `MetricCard({ icon, label, value, detail, accent? })`. Metrics follow source controls on mobile. |
+| Metric Card | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-216 | `apps/desktop/src/App.tsx` | Feature-local `MetricCard({ icon, label, value, detail, accent?, actionLabel?, onAction? })`. After analysis, Tempo/Key/Transpose name a countable BPM, first-entrance chord shape, and transpose setup when owned fields exist; otherwise they stay pending. Optional `actionLabel`/`onAction` scroll renderer-owned workspace surfaces. Metrics follow source controls on mobile. |
 | Confidence Badge | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-239 | `apps/desktop/src/features/workspace/ConfidenceBadge.tsx` | Use `level: ConfidenceLevel`; no `score` or `label` prop exists in current code. |
 | Status Pill | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-283 | `apps/desktop/src/features/workspace/Workspace.tsx` | Design pattern only. Current code uses `formatStatusLabel(status)` inside local badge-like markup. |
 | Role Switcher | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-337 | `apps/desktop/src/features/workspace/RoleSwitcher.tsx` | Use `roles`, `activeRole`, and `onRoleChange`; `null` means all roles. |
diff --git a/docs/doctoring/rehearsal-cockpit-tempo-key-transpose.md b/docs/doctoring/rehearsal-cockpit-tempo-key-transpose.md
new file mode 100644
index 000000000..908e239a8
--- /dev/null
+++ b/docs/doctoring/rehearsal-cockpit-tempo-key-transpose.md
@@ -0,0 +1,16 @@
+# Rehearsal cockpit tempo, starting chord, and transpose next actions
+
+The analysis-summary Tempo, Key, and Transpose metrics stay pending until owned rehearsal fields can name a next action.
+
+- Tempo uses an own integer `song.tempo` in `1..=400`. The next action is counting that BPM in before the first entrance.
+- Key uses the first bounded entrance section's highest-priority unique active part. A user harmony override wins over the owned model chord. The metric shows a starting shape, not a claimed song-wide key.
+- Transpose uses that same first-entrance section and the highest-priority unique active part that owns a single-line `transpositionPlan`. Simplification copy is not a transpose plan.
+
+Cockpit Open/Lock actions scroll renderer-owned workspace surfaces (`workspace-surface-tempo`, `workspace-surface-harmony`, then `workspace-surface-transpose`). Completion copy is armed only after `scrollIntoView` succeeds. Reduced-motion requests use `behavior: "auto"`.
+
+## Security Notes
+
+- Untrusted input: song, section, time-range, role, graph, harmony, override, and transpose-plan metadata are runtime data; inherited properties and arrays masquerading as records are not authority.
+- Trust boundary: cockpit metrics accept required fields only when the inspected record owns them. Navigation targets are renderer-owned element ids, never analysis ids or payload strings.
+- Mitigations: dense collections require own indexed elements; chord/plan/role strings are bounded and reject newlines; BPM must be a positive integer; missing values stay pending; scroll no-ops when the surface cannot move.
+- Test points: inherited song/section/timing/role/graph/harmony metadata is rejected; duplicate role identities stay band-wide/pending; user overrides beat model chords; simplification is not a transpose plan; reduced-motion scroll uses `auto`.

From d48cba12c0c059a938d103f22d32848da3f16153 Mon Sep 17 00:00:00 2001
From: Seongho Bae <me@seonghobae.me>
Date: Sat, 22 Aug 2026 19:26:38 -0700
Subject: [PATCH 02/12] fix(workspace): satisfy rehearsal metric lint contract

---
 .../src/features/workspace/rehearsalMetrics.ts  | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
index 29b86b20d..6776ddace 100644
--- a/apps/desktop/src/features/workspace/rehearsalMetrics.ts
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
@@ -16,12 +16,12 @@ const SECTION_FORM_LABEL_OWNED: Readonly<Record<string, true>> = Object.freeze(
   Object.fromEntries(SECTION_FORM_LABELS.map((label) => [label, true]))
 );
 
-/** Renderer-owned workspace targets for cockpit next actions. */
-export const WORKSPACE_SURFACE_TEMPO = "workspace-surface-tempo";
-/** Renderer-owned workspace target for the first-entrance chord. */
-export const WORKSPACE_SURFACE_HARMONY = "workspace-surface-harmony";
-/** Renderer-owned workspace target for tonight's transpose setup. */
-export const WORKSPACE_SURFACE_TRANSPOSE = "workspace-surface-transpose";
+export /** Renderer-owned workspace targets for cockpit next actions. */
+const WORKSPACE_SURFACE_TEMPO = "workspace-surface-tempo";
+export /** Renderer-owned workspace target for the first-entrance chord. */
+const WORKSPACE_SURFACE_HARMONY = "workspace-surface-harmony";
+export /** Renderer-owned workspace target for tonight's transpose setup. */
+const WORKSPACE_SURFACE_TRANSPOSE = "workspace-surface-transpose";
 
 /** Integer BPM the room can count in before the first entrance. */
 export type TonightTempo = {
@@ -40,8 +40,7 @@ export type TonightTransposePlan = {
   roleName: string;
 };
 
-const METRIC_COPY_KEYS = ["bpm", "chord", "role", "plan"] as const;
-type MetricCopyKey = (typeof METRIC_COPY_KEYS)[number];
+type MetricCopyKey = "bpm" | "chord" | "role" | "plan";
 
 /** Interpolate cockpit placeholders once so rehearsal data is never rescanned as template syntax. */
 export function formatMetricCopy(
@@ -354,5 +353,3 @@ export function resolveTonightTransposePlan(
   }
   return null;
 }
-
-

From 4f62e44206d1cc2d1a6b6eef7996de49c67e35d7 Mon Sep 17 00:00:00 2001
From: Seongho Bae <me@seonghobae.me>
Date: Sat, 22 Aug 2026 19:29:27 -0700
Subject: [PATCH 03/12] fix(workspace): preserve section-label literal type

---
 apps/desktop/src/features/workspace/rehearsalMetrics.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
index 6776ddace..38012f382 100644
--- a/apps/desktop/src/features/workspace/rehearsalMetrics.ts
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
@@ -13,7 +13,7 @@ const MAX_CHORD_LENGTH = 32;
 const MAX_ROLE_NAME_LENGTH = 80;
 const MAX_PLAN_LENGTH = 180;
 const SECTION_FORM_LABEL_OWNED: Readonly<Record<string, true>> = Object.freeze(
-  Object.fromEntries(SECTION_FORM_LABELS.map((label) => [label, true]))
+  Object.fromEntries(SECTION_FORM_LABELS.map((label) => [label, true] as const))
 );
 
 export /** Renderer-owned workspace targets for cockpit next actions. */

From c508bb903867ff0ea5cbe71e80ab646ea1e2506f Mon Sep 17 00:00:00 2001
From: Seongho Bae <me@seonghobae.me>
Date: Sat, 22 Aug 2026 19:37:04 -0700
Subject: [PATCH 04/12] test(workspace): reject exceptional rehearsal metric
 metadata

---
 ...ehearsalMetrics.inherited-metadata.test.ts | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts
index 37c7a3ffe..8784a928e 100644
--- a/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts
@@ -62,4 +62,51 @@ describe("rehearsal cockpit metrics inherited metadata", () => {
     expect(resolveTonightStartingChord(song)?.chord).not.toBe("C#m7");
     expect(resolveTonightTransposePlan(song)).toBeNull();
   });
+
+  it("contains an own tempo accessor that throws", () => {
+    const song = createDemoRehearsalSong();
+    Object.defineProperty(song, "tempo", {
+      configurable: true,
+      enumerable: true,
+      get() {
+        throw new Error("tempo getter must stay data");
+      }
+    });
+
+    expect(() => resolveTonightTempo(song)).not.toThrow();
+    expect(resolveTonightTempo(song)).toBeNull();
+  });
+
+  it("contains an own timeRange accessor that throws", () => {
+    const song = createDemoRehearsalSong();
+    Object.defineProperty(song.sections[0]!, "timeRange", {
+      configurable: true,
+      enumerable: true,
+      get() {
+        throw new Error("timeRange getter must stay data");
+      }
+    });
+
+    expect(() => resolveTonightStartingChord(song)).not.toThrow();
+    expect(() => resolveTonightTransposePlan(song)).not.toThrow();
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("contains a nested timeRange Proxy whose descriptor trap throws", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.timeRange = new Proxy(
+      { start: 0, end: 8 },
+      {
+        getOwnPropertyDescriptor() {
+          throw new Error("timeRange descriptor trap");
+        }
+      }
+    ) as typeof song.sections[0]["timeRange"];
+
+    expect(() => resolveTonightStartingChord(song)).not.toThrow();
+    expect(() => resolveTonightTransposePlan(song)).not.toThrow();
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
 });

From db87b7af38b109a66cbab7d17e3bfc1923658aaa Mon Sep 17 00:00:00 2001
From: Seongho Bae <me@seonghobae.me>
Date: Sat, 22 Aug 2026 19:38:54 -0700
Subject: [PATCH 05/12] fix(workspace): contain exceptional rehearsal metric
 metadata

---
 .../features/workspace/rehearsalMetrics.ts    | 42 ++++++++++++-------
 1 file changed, 26 insertions(+), 16 deletions(-)

diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
index 38012f382..d1615d085 100644
--- a/apps/desktop/src/features/workspace/rehearsalMetrics.ts
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
@@ -96,9 +96,23 @@ function isRuntimeObject(value: unknown): value is object {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-/** Return whether a runtime record owns the named field rather than inheriting it. */
+/** Return whether a runtime record owns the named field without letting Proxy traps escape. */
 function hasOwn(value: object, key: PropertyKey): boolean {
-  return Object.prototype.hasOwnProperty.call(value, key);
+  try {
+    return Object.prototype.hasOwnProperty.call(value, key);
+  } catch {
+    return false;
+  }
+}
+
+/** Read an own data property without invoking accessors or letting Proxy descriptor traps escape. */
+function readOwnDataProperty(value: object, key: PropertyKey): unknown {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+  } catch {
+    return undefined;
+  }
 }
 
 /** Return whether every numeric index is an own element in a bounded runtime array. */
@@ -118,12 +132,9 @@ function isDenseRuntimeArray(value: unknown): value is unknown[] {
   return true;
 }
 
-/** Return a bounded non-empty own string, or null. */
+/** Return a bounded non-empty own data string, or null. */
 function readBoundedOwnString(record: object, key: PropertyKey, maxLength: number): string | null {
-  if (!hasOwn(record, key)) {
-    return null;
-  }
-  const value = (record as Record<PropertyKey, unknown>)[key];
+  const value = readOwnDataProperty(record, key);
   if (typeof value !== "string") {
     return null;
   }
@@ -146,20 +157,19 @@ function hasRankedPriority(role: RehearsalRole): boolean {
 
 /** Return whether a section owns a bounded, positive-length integer rehearsal window. */
 function hasBoundedTimeRange(section: RehearsalSection): boolean {
-  if (!hasOwn(section, "timeRange")) {
-    return false;
-  }
-  const timeRange = section.timeRange as Partial<RehearsalSection["timeRange"]> | null;
-  if (!isRuntimeObject(timeRange) || !hasOwn(timeRange, "start") || !hasOwn(timeRange, "end")) {
+  const timeRange = readOwnDataProperty(section, "timeRange");
+  if (!isRuntimeObject(timeRange)) {
     return false;
   }
 
-  const start = timeRange.start ?? -1;
-  const end = timeRange.end ?? -1;
+  const start = readOwnDataProperty(timeRange, "start");
+  const end = readOwnDataProperty(timeRange, "end");
   return (
+    typeof start === "number" &&
     Number.isInteger(start) &&
     start >= 0 &&
     start <= MAX_SECTION_TIME_SECONDS &&
+    typeof end === "number" &&
     Number.isInteger(end) &&
     end > start &&
     end <= MAX_SECTION_TIME_SECONDS
@@ -303,10 +313,10 @@ function firstEntranceSection(song: RehearsalSong): RehearsalSection | null {
 
 /** Return tonight's countable BPM, or null when the value is not a rehearsal tempo. */
 export function resolveTonightTempo(song: RehearsalSong | null | undefined): TonightTempo | null {
-  if (!isRuntimeObject(song) || !hasOwn(song, "tempo")) {
+  if (!isRuntimeObject(song)) {
     return null;
   }
-  const bpm = (song as RehearsalSong).tempo;
+  const bpm = readOwnDataProperty(song, "tempo");
   if (
     typeof bpm !== "number" ||
     !Number.isInteger(bpm) ||

From 920d39bd918b6c4cc9250eddff4411b18d4d65f2 Mon Sep 17 00:00:00 2001
From: Seongho Bae <me@seonghobae.me>
Date: Sat, 22 Aug 2026 20:12:09 -0700
Subject: [PATCH 06/12] test(metrics): bound synthetic section collection scans

---
 ...ehearsalMetrics.runtime-collection.test.ts | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 apps/desktop/src/features/workspace/rehearsalMetrics.runtime-collection.test.ts

diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.runtime-collection.test.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.runtime-collection.test.ts
new file mode 100644
index 000000000..ecb94dd36
--- /dev/null
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.runtime-collection.test.ts
@@ -0,0 +1,44 @@
+import { createDemoRehearsalSong, type RehearsalSection } from "@bandscope/shared-types";
+import { describe, expect, it } from "vitest";
+import { resolveTonightStartingChord, resolveTonightTransposePlan } from "./rehearsalMetrics";
+
+function syntheticLengthSections() {
+  const target: RehearsalSection[] = [];
+  target.length = 256;
+  let numericDescriptorReads = 0;
+
+  const sections = new Proxy(target, {
+    getOwnPropertyDescriptor(current, property) {
+      if (typeof property === "string" && /^(0|[1-9]\d*)$/.test(property)) {
+        numericDescriptorReads += 1;
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: true,
+          value: undefined
+        };
+      }
+      return Reflect.getOwnPropertyDescriptor(current, property);
+    },
+    ownKeys() {
+      return ["length"];
+    }
+  });
+
+  return {
+    sections,
+    numericDescriptorReads: () => numericDescriptorReads
+  };
+}
+
+describe("rehearsal metric runtime collection bounds", () => {
+  it("does not scan a synthetic section length while resolving first-entrance metrics", () => {
+    const song = createDemoRehearsalSong();
+    const hostile = syntheticLengthSections();
+    song.sections = hostile.sections;
+
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+    expect(hostile.numericDescriptorReads()).toBeLessThan(8);
+  });
+});

From f379407b305fc05ea9d601b6d851904987988093 Mon Sep 17 00:00:00 2001
From: Seongho Bae <me@seonghobae.me>
Date: Sat, 22 Aug 2026 20:12:43 -0700
Subject: [PATCH 07/12] fix(metrics): bound runtime collection density scans

---
 .../src/features/workspace/rehearsalMetrics.ts   | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
index d1615d085..71faeaf27 100644
--- a/apps/desktop/src/features/workspace/rehearsalMetrics.ts
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
@@ -115,21 +115,21 @@ function readOwnDataProperty(value: object, key: PropertyKey): unknown {
   }
 }
 
-/** Return whether every numeric index is an own element in a bounded runtime array. */
+/** Return whether materialized enumerable keys exactly cover a runtime array's numeric indices. */
 function isDenseRuntimeArray(value: unknown): value is unknown[] {
   if (!Array.isArray(value)) {
     return false;
   }
-  const length = Number(value.length);
-  if (!Number.isSafeInteger(length) || length < 0 || length > 0xffffffff) {
-    return false;
-  }
-  for (let index = 0; index < length; index += 1) {
-    if (!hasOwn(value, index)) {
+  try {
+    const length = Number(value.length);
+    if (!Number.isSafeInteger(length) || length < 0 || length > 0xffffffff) {
       return false;
     }
+    const keys = Object.keys(value);
+    return keys.length === length && keys.every((key, index) => key === String(index));
+  } catch {
+    return false;
   }
-  return true;
 }
 
 /** Return a bounded non-empty own data string, or null. */

From e42b903c330802ce5781aa9b47b4f26ccb7e41d5 Mon Sep 17 00:00:00 2001
From: Seongho Bae <me@seonghobae.me>
Date: Sat, 22 Aug 2026 20:15:24 -0700
Subject: [PATCH 08/12] test(workspace): align tempo badge readiness

---
 .../workspace/Workspace.tempo.test.tsx        | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 apps/desktop/src/features/workspace/Workspace.tempo.test.tsx

diff --git a/apps/desktop/src/features/workspace/Workspace.tempo.test.tsx b/apps/desktop/src/features/workspace/Workspace.tempo.test.tsx
new file mode 100644
index 000000000..4814c7ee3
--- /dev/null
+++ b/apps/desktop/src/features/workspace/Workspace.tempo.test.tsx
@@ -0,0 +1,24 @@
+import { createDemoRehearsalSong } from "@bandscope/shared-types";
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import { Workspace } from "./Workspace";
+
+function songWithTempo(tempo: number) {
+  const song = createDemoRehearsalSong();
+  song.tempo = tempo;
+  return song;
+}
+
+describe("Workspace tempo readiness", () => {
+  it.each([90.5, 500])("does not present an uncountable %s BPM as a ready tempo", (tempo) => {
+    render(<Workspace song={songWithTempo(tempo)} />);
+
+    expect(screen.queryByText(`${tempo} BPM`, { exact: false })).toBeNull();
+  });
+
+  it("keeps the badge for a countable integer tempo", () => {
+    render(<Workspace song={songWithTempo(120)} />);
+
+    expect(screen.getByText("120 BPM", { exact: false })).toBeTruthy();
+  });
+});

From d20341715bd45eff14605eda990eb6c51dd54887 Mon Sep 17 00:00:00 2001
From: Seongho Bae <me@seonghobae.me>
Date: Sat, 22 Aug 2026 20:16:57 -0700
Subject: [PATCH 09/12] fix(workspace): align tempo badge readiness

---
 apps/desktop/src/features/workspace/Workspace.tsx | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/apps/desktop/src/features/workspace/Workspace.tsx b/apps/desktop/src/features/workspace/Workspace.tsx
index 3953be7c2..c5b47cb33 100644
--- a/apps/desktop/src/features/workspace/Workspace.tsx
+++ b/apps/desktop/src/features/workspace/Workspace.tsx
@@ -4,6 +4,7 @@ import { RoleSwitcher } from "./RoleSwitcher";
 import { SectionRoadmap } from "./SectionRoadmap";
 import { GrooveMap } from "./GrooveMap";
 import { PracticeProgress } from "./PracticeProgress";
+import { resolveTonightTempo } from "./rehearsalMetrics";
 import { createTranslator, detectPreferredLocale } from "../../i18n";
 import { generateCueSheetCsv, generateChartSummaryJson, generateMetadataHandoffJson, sanitizeFilename } from "../../lib/export";
 import { Button } from "@/components/ui/button";
@@ -121,6 +122,7 @@ const SongStructure = memo(function SongStructure({ sections, t }: { sections: R
 export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: WorkspaceProps) {
   const [activeRole, setActiveRole] = useState<string | null>(null);
   const t = useMemo(() => createTranslator(detectPreferredLocale()), []);
+  const tonightTempo = resolveTonightTempo(song);
 
   // Extract all unique roles from the song's sections
   const roleMap = useMemo(() => {
@@ -244,12 +246,12 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
           <div className="space-y-1.5">
               <div className="flex items-center gap-2">
                 <p className="text-xs font-black uppercase tracking-[0.3em] text-cyan-300">{t("workspaceRehearsalMapLabel")}</p>
-                {song.tempo && (
+                {tonightTempo && (
                   <span
                     id="workspace-surface-tempo"
                     className="rounded-full border border-cyan-300/30 bg-cyan-300/10 px-2.5 py-0.5 text-[0.65rem] font-bold text-cyan-100"
                   >
-                    {t("workspaceTempoLabel")}: {song.tempo} BPM
+                    {t("workspaceTempoLabel")}: {tonightTempo.bpm} BPM
                   </span>
                 )}
               </div>

From ec87428f4ef976d3a71570b5ef60c29a315f1c35 Mon Sep 17 00:00:00 2001
From: Seongho Bae <me@seonghobae.me>
Date: Sat, 22 Aug 2026 20:21:48 -0700
Subject: [PATCH 10/12] test(metrics): contain hostile runtime metadata traps

---
 ...ehearsalMetrics.runtime-collection.test.ts | 25 ++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.runtime-collection.test.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.runtime-collection.test.ts
index ecb94dd36..c281236c3 100644
--- a/apps/desktop/src/features/workspace/rehearsalMetrics.runtime-collection.test.ts
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.runtime-collection.test.ts
@@ -1,4 +1,4 @@
-import { createDemoRehearsalSong, type RehearsalSection } from "@bandscope/shared-types";
+import { createDemoRehearsalSong, type RehearsalSection, type RehearsalSong } from "@bandscope/shared-types";
 import { describe, expect, it } from "vitest";
 import { resolveTonightStartingChord, resolveTonightTransposePlan } from "./rehearsalMetrics";
 
@@ -41,4 +41,27 @@ describe("rehearsal metric runtime collection bounds", () => {
     expect(resolveTonightTransposePlan(song)).toBeNull();
     expect(hostile.numericDescriptorReads()).toBeLessThan(8);
   });
+
+  it("fails closed when the song ownership check hits a descriptor trap", () => {
+    const song = new Proxy(createDemoRehearsalSong(), {
+      getOwnPropertyDescriptor() {
+        throw new Error("descriptor trap");
+      }
+    }) as RehearsalSong;
+
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
+
+  it("fails closed when runtime section enumeration hits a proxy trap", () => {
+    const song = createDemoRehearsalSong();
+    song.sections = new Proxy(song.sections, {
+      ownKeys() {
+        throw new Error("ownKeys trap");
+      }
+    });
+
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
 });

From 4092362ba0724b52553d6c5e995aae033e838578 Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Wed, 26 Aug 2026 13:23:21 +0900
Subject: [PATCH 11/12] fix(review): suppress cockpit next actions while the
 Score view is active

The Tempo/Key/Transpose header buttons rendered unconditionally, but their
scroll targets live inside the Workspace which is not mounted in the Score
view, so clicks were silent no-ops there. Gate the action affordances on the
workspace view so the header stays honest, and restore them on switching
back.
---
 apps/desktop/src/App.test.tsx | 20 ++++++++++++++++++++
 apps/desktop/src/App.tsx      | 16 ++++++++++------
 2 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/apps/desktop/src/App.test.tsx b/apps/desktop/src/App.test.tsx
index 8abbc8239..efb0f9285 100644
--- a/apps/desktop/src/App.test.tsx
+++ b/apps/desktop/src/App.test.tsx
@@ -1676,6 +1676,26 @@ describe("App", () => {
     expect(screen.queryByText(/Song Timeline/i)).toBeNull();
   });
 
+  it("hides cockpit next actions in the Score view and restores them back in the Workspace", async () => {
+    mockLoadProject.mockResolvedValueOnce(createDemoRehearsalSong());
+    render(<App />);
+
+    fireEvent.click(screen.getByRole("button", { name: /open project/i }));
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Open tonight's count-in" })).toBeTruthy();
+    });
+
+    fireEvent.click(screen.getAllByRole("button", { name: /^Score$/i })[0]);
+    expect(await screen.findByRole("heading", { name: /Score · Late Night Set/i })).toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: "Open tonight's count-in" })).toBeNull();
+    expect(screen.queryByRole("button", { name: "Open tonight's first chord" })).toBeNull();
+
+    fireEvent.click(screen.getAllByRole("button", { name: /^Workspace$/i })[0]);
+    await waitFor(() => {
+      expect(screen.getByRole("button", { name: "Open tonight's count-in" })).toBeTruthy();
+    });
+  });
+
   it("switches to the Score view from the compact mobile navigation", async () => {
     mockLoadProject.mockResolvedValueOnce(succeededResult().result);
     render(<App />);
diff --git a/apps/desktop/src/App.tsx b/apps/desktop/src/App.tsx
index b566589e7..c8c6bec04 100644
--- a/apps/desktop/src/App.tsx
+++ b/apps/desktop/src/App.tsx
@@ -547,6 +547,10 @@ export function App() {
   };
 
   const currentView: RehearsalView = jobResult && activeView === "score" ? "score" : "workspace";
+  // Cockpit next actions scroll to surfaces that only exist inside the mounted
+  // Workspace, so the affordances are suppressed in the Score view instead of
+  // rendering visible buttons whose click would be a silent no-op.
+  const cockpitActionsAvailable = currentView === "workspace";
   const readySongId = typeof jobResult?.id === "string" ? jobResult.id : "";
   const tonightTempo = resolveTonightTempo(jobResult);
   const tonightChord = resolveTonightStartingChord(jobResult);
@@ -903,10 +907,10 @@ export function App() {
                   : t("metricTempoPendingDetail")
               }
               actionLabel={
-                tonightTempo ? formatMetricCopy(t("metricTempoAction"), { bpm: String(tonightTempo.bpm) }) : undefined
+                tonightTempo && cockpitActionsAvailable ? formatMetricCopy(t("metricTempoAction"), { bpm: String(tonightTempo.bpm) }) : undefined
               }
               onAction={
-                tonightTempo
+                tonightTempo && cockpitActionsAvailable
                   ? () => handleCockpitMetricAction("tempo", [WORKSPACE_SURFACE_TEMPO])
                   : undefined
               }
@@ -925,7 +929,7 @@ export function App() {
                   : t("metricKeyPendingDetail")
               }
               actionLabel={
-                tonightChord
+                tonightChord && cockpitActionsAvailable
                   ? formatMetricCopy(t("metricKeyAction"), {
                       chord: tonightChord.chord,
                       role: tonightChord.roleName
@@ -933,7 +937,7 @@ export function App() {
                   : undefined
               }
               onAction={
-                tonightChord
+                tonightChord && cockpitActionsAvailable
                   ? () => handleCockpitMetricAction("key", [WORKSPACE_SURFACE_HARMONY])
                   : undefined
               }
@@ -952,12 +956,12 @@ export function App() {
                   : t("metricTransposePendingDetail")
               }
               actionLabel={
-                tonightTranspose
+                tonightTranspose && cockpitActionsAvailable
                   ? formatMetricCopy(t("metricTransposeAction"), { role: tonightTranspose.roleName })
                   : undefined
               }
               onAction={
-                tonightTranspose
+                tonightTranspose && cockpitActionsAvailable
                   ? () =>
                       handleCockpitMetricAction("transpose", [
                         WORKSPACE_SURFACE_TRANSPOSE,

From 98dab4fa2c171c70d36daf412955367b783a821b Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sat, 29 Aug 2026 05:06:35 +0900
Subject: [PATCH 12/12] fix(desktop): fail closed on hostile rehearsal metadata

---
 ...ehearsalMetrics.inherited-metadata.test.ts | 16 +++++++
 .../features/workspace/rehearsalMetrics.ts    | 48 +++++++++++--------
 2 files changed, 44 insertions(+), 20 deletions(-)

diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts
index 8784a928e..63fa58e01 100644
--- a/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.inherited-metadata.test.ts
@@ -109,4 +109,20 @@ describe("rehearsal cockpit metrics inherited metadata", () => {
     expect(resolveTonightStartingChord(song)).toBeNull();
     expect(resolveTonightTransposePlan(song)).toBeNull();
   });
+
+  it("fails closed when role metadata throws during ranking", () => {
+    const song = createDemoRehearsalSong();
+    Object.defineProperty(song.sections[0]!.roles[0]!, "rehearsalPriority", {
+      configurable: true,
+      enumerable: true,
+      get() {
+        throw new Error("priority getter must stay data");
+      }
+    });
+
+    expect(() => resolveTonightStartingChord(song)).not.toThrow();
+    expect(() => resolveTonightTransposePlan(song)).not.toThrow();
+    expect(resolveTonightStartingChord(song)).toBeNull();
+    expect(resolveTonightTransposePlan(song)).toBeNull();
+  });
 });
diff --git a/apps/desktop/src/features/workspace/rehearsalMetrics.ts b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
index 71faeaf27..e69a69d43 100644
--- a/apps/desktop/src/features/workspace/rehearsalMetrics.ts
+++ b/apps/desktop/src/features/workspace/rehearsalMetrics.ts
@@ -332,34 +332,42 @@ export function resolveTonightTempo(song: RehearsalSong | null | undefined): Ton
 export function resolveTonightStartingChord(
   song: RehearsalSong | null | undefined
 ): TonightStartingChord | null {
-  const section = firstEntranceSection(song as RehearsalSong);
-  if (!section) {
-    return null;
-  }
-  for (const role of rankedActiveRoles(section)) {
-    const chord = roleChord(role);
-    const roleName = readBoundedOwnString(role, "name", MAX_ROLE_NAME_LENGTH);
-    if (chord && roleName) {
-      return { chord, roleName };
+  try {
+    const section = firstEntranceSection(song as RehearsalSong);
+    if (!section) {
+      return null;
+    }
+    for (const role of rankedActiveRoles(section)) {
+      const chord = roleChord(role);
+      const roleName = readBoundedOwnString(role, "name", MAX_ROLE_NAME_LENGTH);
+      if (chord && roleName) {
+        return { chord, roleName };
+      }
     }
+    return null;
+  } catch {
+    return null;
   }
-  return null;
 }
 
 /** Return the first-entrance transpose plan, or null when no setup note remains. */
 export function resolveTonightTransposePlan(
   song: RehearsalSong | null | undefined
 ): TonightTransposePlan | null {
-  const section = firstEntranceSection(song as RehearsalSong);
-  if (!section) {
-    return null;
-  }
-  for (const role of rankedActiveRoles(section)) {
-    const plan = readBoundedOwnString(role, "transpositionPlan", MAX_PLAN_LENGTH);
-    const roleName = readBoundedOwnString(role, "name", MAX_ROLE_NAME_LENGTH);
-    if (plan && roleName) {
-      return { plan, roleName };
+  try {
+    const section = firstEntranceSection(song as RehearsalSong);
+    if (!section) {
+      return null;
+    }
+    for (const role of rankedActiveRoles(section)) {
+      const plan = readBoundedOwnString(role, "transpositionPlan", MAX_PLAN_LENGTH);
+      const roleName = readBoundedOwnString(role, "name", MAX_ROLE_NAME_LENGTH);
+      if (plan && roleName) {
+        return { plan, roleName };
+      }
     }
+    return null;
+  } catch {
+    return null;
   }
-  return null;
 }