From 8ab7e7db3e31393d736db7ea0a8dcd35431ef628 Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 03:03:22 +0900
Subject: [PATCH 01/13] feat(player): add bounded rehearsal playback rates

---
 .../workspace/RehearsalPlayer.test.tsx        | 60 +++++++++++++++++++
 .../features/workspace/RehearsalPlayer.tsx    | 52 ++++++++++++++++
 .../workspace/rehearsalTransport.test.ts      | 26 ++++++++
 .../features/workspace/rehearsalTransport.ts  | 33 ++++++++++
 apps/desktop/src/locales/en/common.json       |  2 +
 apps/desktop/src/locales/ko/common.json       |  2 +
 6 files changed, 175 insertions(+)

diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index 3ac05a7f6..22bab447b 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -10,6 +10,10 @@ const originalTauriInternals = Object.getOwnPropertyDescriptor(
   window,
   "__TAURI_INTERNALS__",
 );
+const originalPreservesPitch = Object.getOwnPropertyDescriptor(
+  HTMLMediaElement.prototype,
+  "preservesPitch",
+);
 const tauriConfigPath = resolve(process.cwd(), "src-tauri/tauri.conf.json");
 const audioSourcePath = "/Users/test/Music/rehearsal.wav";
 
@@ -28,6 +32,11 @@ function installPlayableAudioMocks() {
   });
   vi.spyOn(HTMLMediaElement.prototype, "load").mockImplementation(() => {});
   vi.spyOn(HTMLMediaElement.prototype, "pause").mockImplementation(() => {});
+  Object.defineProperty(HTMLMediaElement.prototype, "preservesPitch", {
+    configurable: true,
+    writable: true,
+    value: false,
+  });
   const play = vi
     .spyOn(HTMLMediaElement.prototype, "play")
     .mockResolvedValue(undefined);
@@ -49,6 +58,17 @@ describe("RehearsalPlayer", () => {
       delete (window as Window & { __TAURI_INTERNALS__?: unknown })
         .__TAURI_INTERNALS__;
     }
+    if (originalPreservesPitch) {
+      Object.defineProperty(
+        HTMLMediaElement.prototype,
+        "preservesPitch",
+        originalPreservesPitch,
+      );
+    } else {
+      delete (HTMLMediaElement.prototype as HTMLMediaElement & {
+        preservesPitch?: boolean;
+      }).preservesPitch;
+    }
   });
 
   it("allows both platform Tauri asset origins in the media CSP", () => {
@@ -323,6 +343,46 @@ describe("RehearsalPlayer", () => {
     );
   });
 
+  it("applies supported playback speed while preserving pitch when available", () => {
+    setNavigatorLanguage("en-US");
+    const { play } = installPlayableAudioMocks();
+    const song = createDemoRehearsalSong();
+
+    const { rerender } = render(
+      <RehearsalPlayer
+        song={song}
+        hasLocalAudio={true}
+        audioSourcePath={audioSourcePath}
+      />,
+    );
+
+    const audio = screen.getByTestId(
+      "rehearsal-loop-audio",
+    ) as HTMLAudioElement;
+    const rateSelect = screen.getByRole("combobox", {
+      name: /Playback speed/i,
+    }) as HTMLSelectElement;
+    expect(rateSelect.value).toBe("1");
+
+    fireEvent.change(rateSelect, { target: { value: "0.75" } });
+
+    expect(audio.playbackRate).toBe(0.75);
+    expect(audio.preservesPitch).toBe(true);
+    expect(
+      screen.getByText(/Pitch stays natural when the audio engine supports it/i),
+    ).toBeTruthy();
+    expect(play).not.toHaveBeenCalled();
+
+    rerender(
+      <RehearsalPlayer
+        song={song}
+        hasLocalAudio={true}
+        audioSourcePath="/Users/test/Music/second-rehearsal.wav"
+      />,
+    );
+    expect(audio.playbackRate).toBe(0.75);
+  });
+
   it("keeps a live loop running across unrelated song metadata updates", () => {
     setNavigatorLanguage("en-US");
     vi.useFakeTimers();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index 53bdc3be9..2e597a140 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -21,6 +21,8 @@ import {
   formatRehearsalClock,
   nextActionTemplateKey,
   nextActionValues,
+  isRehearsalPlaybackRate,
+  rehearsalPlaybackRates,
   reduceRehearsalTransport,
   resolveLoopWindows,
   type RehearsalLoopWindow,
@@ -188,6 +190,21 @@ export function RehearsalPlayer({
     });
   }, [playableLoops, selectedRendererIndex]);
 
+  useEffect(() => {
+    const audio = audioRef.current;
+    if (!audio) {
+      return;
+    }
+    try {
+      audio.playbackRate = transport.playbackRate;
+      if ("preservesPitch" in audio) {
+        audio.preservesPitch = true;
+      }
+    } catch {
+      handlePlaybackError();
+    }
+  }, [audioSourceUrl, handlePlaybackError, transport.playbackRate]);
+
   useEffect(() => {
     if (startNonce <= lastHandledStartNonce.current) {
       return;
@@ -420,6 +437,41 @@ export function RehearsalPlayer({
           })}
         </div>
       ) : null}
+      <div className="mt-3 flex flex-wrap items-center gap-3">
+        <label className="flex min-h-11 items-center gap-2 text-xs font-semibold uppercase tracking-[0.16em] text-slate-300">
+          <span>{t("workspaceLoopPlaybackRateLabel")}</span>
+          <select
+            aria-describedby="rehearsal-loop-playback-rate-hint"
+            aria-label={t("workspaceLoopPlaybackRateLabel")}
+            className="min-h-11 rounded-lg border border-white/10 bg-slate-950 px-3 text-sm font-semibold normal-case tracking-normal text-slate-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-cyan-300"
+            data-testid="rehearsal-loop-playback-rate"
+            value={transport.playbackRate}
+            onChange={(event) => {
+              const nextRate = Number(event.currentTarget.value);
+              if (isRehearsalPlaybackRate(nextRate)) {
+                setTransport((current) =>
+                  reduceRehearsalTransport(current, {
+                    type: "set-playback-rate",
+                    rate: nextRate,
+                  }),
+                );
+              }
+            }}
+          >
+            {rehearsalPlaybackRates().map((rate) => (
+              <option key={rate} value={rate}>
+                {rate}×
+              </option>
+            ))}
+          </select>
+        </label>
+        <p
+          className="text-xs text-slate-400"
+          id="rehearsal-loop-playback-rate-hint"
+        >
+          {t("workspaceLoopPlaybackRateHint")}
+        </p>
+      </div>
       <div
         className="mt-4 h-2 overflow-hidden rounded-full bg-white/10"
         aria-hidden="true"
diff --git a/apps/desktop/src/features/workspace/rehearsalTransport.test.ts b/apps/desktop/src/features/workspace/rehearsalTransport.test.ts
index 76405d57b..c07c41fc5 100644
--- a/apps/desktop/src/features/workspace/rehearsalTransport.test.ts
+++ b/apps/desktop/src/features/workspace/rehearsalTransport.test.ts
@@ -6,9 +6,11 @@ import {
   createLoopWindow,
   fillRehearsalCopy,
   formatRehearsalClock,
+  isRehearsalPlaybackRate,
   isPlayableLoopSection,
   nextActionTemplateKey,
   nextActionValues,
+  rehearsalPlaybackRates,
   reduceRehearsalTransport,
   resolveLoopWindow,
   resolveRehearsalTempo,
@@ -80,6 +82,30 @@ describe("rehearsalTransport", () => {
     expect(beatDurationMs(120)).toBe(500);
   });
 
+  it("keeps playback speed inside the supported media contract", () => {
+    const loop = resolveLoopWindow(createDemoRehearsalSong());
+    const armed = reduceRehearsalTransport(createIdleTransportState(), {
+      type: "arm",
+      loop,
+    });
+
+    expect(rehearsalPlaybackRates()).toEqual([0.75, 1, 1.25]);
+    expect(isRehearsalPlaybackRate(0.75)).toBe(true);
+    expect(isRehearsalPlaybackRate(2)).toBe(false);
+    expect(
+      reduceRehearsalTransport(armed, {
+        type: "set-playback-rate",
+        rate: 0.75,
+      }).playbackRate,
+    ).toBe(0.75);
+    expect(
+      reduceRehearsalTransport(armed, {
+        type: "set-playback-rate",
+        rate: 2 as never,
+      }),
+    ).toBe(armed);
+  });
+
   it("counts in four beats then wraps the playhead inside the section", () => {
     const song = createDemoRehearsalSong();
     const loop = resolveLoopWindow(song);
diff --git a/apps/desktop/src/features/workspace/rehearsalTransport.ts b/apps/desktop/src/features/workspace/rehearsalTransport.ts
index b1a205ed7..e8a465c98 100644
--- a/apps/desktop/src/features/workspace/rehearsalTransport.ts
+++ b/apps/desktop/src/features/workspace/rehearsalTransport.ts
@@ -8,6 +8,18 @@ const DEFAULT_REHEARSAL_TEMPO_BPM = 120;
 const DEFAULT_COUNT_IN_BEATS = 4;
 const MIN_REHEARSAL_TEMPO_BPM = 30;
 const MAX_REHEARSAL_TEMPO_BPM = 300;
+const DEFAULT_REHEARSAL_PLAYBACK_RATE = 1;
+
+/** Documented playback-rate choices supported by the rehearsal media contract. */
+const REHEARSAL_PLAYBACK_RATES = [0.75, 1, 1.25] as const;
+
+/** Playback-rate value accepted by the rehearsal media contract. */
+export type RehearsalPlaybackRate = (typeof REHEARSAL_PLAYBACK_RATES)[number];
+
+/** Return the supported playback-rate choices for the rehearsal control. */
+export function rehearsalPlaybackRates(): readonly RehearsalPlaybackRate[] {
+  return REHEARSAL_PLAYBACK_RATES;
+}
 
 /** Documented rehearsal transport phases for the first section loop. */
 export type RehearsalTransportPhase =
@@ -30,6 +42,7 @@ export interface RehearsalTransportState {
   loop: RehearsalLoopWindow | null;
   countInRemainingBeats: number;
   playheadSeconds: number;
+  playbackRate: RehearsalPlaybackRate;
 }
 
 /** Discrete transport commands that never inspect the filesystem. */
@@ -39,6 +52,7 @@ export type RehearsalTransportEvent =
   | { type: "beat" }
   | { type: "sync"; playheadSeconds: number }
   | { type: "tick"; deltaSeconds: number }
+  | { type: "set-playback-rate"; rate: RehearsalPlaybackRate }
   | { type: "pause" }
   | { type: "stop" };
 
@@ -54,6 +68,16 @@ export function isFiniteNonNegativeNumber(value: unknown): value is number {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 
+/** Return true only for playback rates supported by the rehearsal contract. */
+export function isRehearsalPlaybackRate(
+  value: unknown,
+): value is RehearsalPlaybackRate {
+  return (
+    typeof value === "number" &&
+    REHEARSAL_PLAYBACK_RATES.includes(value as RehearsalPlaybackRate)
+  );
+}
+
 /** Read one own data-property value without activating accessors or Proxy get traps. */
 function ownDataValue(value: object, key: PropertyKey): unknown {
   try {
@@ -254,6 +278,7 @@ export function createIdleTransportState(): RehearsalTransportState {
     loop: null,
     countInRemainingBeats: 0,
     playheadSeconds: 0,
+    playbackRate: DEFAULT_REHEARSAL_PLAYBACK_RATE,
   };
 }
 
@@ -286,6 +311,7 @@ export function reduceRehearsalTransport(
         loop: event.loop,
         countInRemainingBeats: event.loop.countInBeats,
         playheadSeconds: event.loop.startSeconds,
+        playbackRate: state.playbackRate,
       };
     }
     case "start": {
@@ -348,6 +374,12 @@ export function reduceRehearsalTransport(
         ),
       };
     }
+    case "set-playback-rate": {
+      if (!isRehearsalPlaybackRate(event.rate)) {
+        return state;
+      }
+      return { ...state, playbackRate: event.rate };
+    }
     case "pause": {
       if (state.phase !== "looping" && state.phase !== "counting-in") {
         return state;
@@ -363,6 +395,7 @@ export function reduceRehearsalTransport(
         loop: state.loop,
         countInRemainingBeats: state.loop.countInBeats,
         playheadSeconds: state.loop.startSeconds,
+        playbackRate: state.playbackRate,
       };
     }
     default:
diff --git a/apps/desktop/src/locales/en/common.json b/apps/desktop/src/locales/en/common.json
index c520ef61a..2c0308977 100644
--- a/apps/desktop/src/locales/en/common.json
+++ b/apps/desktop/src/locales/en/common.json
@@ -158,6 +158,8 @@
   "workspaceLoopPause": "Pause rehearsal clock",
   "workspaceLoopStop": "Stop and reset rehearsal clock",
   "workspaceLoopAudioError": "Could not play this local audio. Choose the song again and retry.",
+  "workspaceLoopPlaybackRateLabel": "Playback speed",
+  "workspaceLoopPlaybackRateHint": "Pitch stays natural when the audio engine supports it.",
   "workspaceLoopIdle": "Add a section with a start and end time, then loop it here.",
   "workspaceLoopArmedNoAudio": "Map {section} from {start}–{end}. Choose a local song first to start the rehearsal clock.",
   "workspaceLoopArmedWithAudio": "Map {section} from {start}–{end}. Start the count-in to run the rehearsal clock.",
diff --git a/apps/desktop/src/locales/ko/common.json b/apps/desktop/src/locales/ko/common.json
index e0d52893c..6f78ff5b5 100644
--- a/apps/desktop/src/locales/ko/common.json
+++ b/apps/desktop/src/locales/ko/common.json
@@ -158,6 +158,8 @@
   "workspaceLoopPause": "합주 시계 일시정지",
   "workspaceLoopStop": "합주 시계 멈추고 초기화",
   "workspaceLoopAudioError": "이 로컬 오디오를 재생할 수 없습니다. 곡을 다시 선택한 뒤 재시도하세요.",
+  "workspaceLoopPlaybackRateLabel": "재생 속도",
+  "workspaceLoopPlaybackRateHint": "오디오 엔진이 지원하면 음정은 자연스럽게 유지됩니다.",
   "workspaceLoopIdle": "시작·끝 시각이 있는 구간을 만든 다음, 여기서 루프하세요.",
   "workspaceLoopArmedNoAudio": "{section} 구간 {start}–{end}의 합주 시계를 준비했습니다. 시작하려면 먼저 로컬 곡을 고르세요.",
   "workspaceLoopArmedWithAudio": "{section} 구간 {start}–{end}의 합주 시계를 준비했습니다. 카운트인을 시작하세요.",

From e517a9875d9eae13113c56d7b2b433ed9a3a7888 Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 03:16:11 +0900
Subject: [PATCH 02/13] fix(player): align loop timing with playback rate

---
 .../workspace/RehearsalPlayer.test.tsx        | 77 +++++++++++++++++++
 .../features/workspace/RehearsalPlayer.tsx    | 20 ++++-
 2 files changed, 93 insertions(+), 4 deletions(-)

diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index 22bab447b..80ac13db2 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -343,6 +343,83 @@ describe("RehearsalPlayer", () => {
     );
   });
 
+  it.each([
+    { rate: "0.75", beforeLoopMs: 2000, remainingMs: 700 },
+    { rate: "1.25", beforeLoopMs: 1500, remainingMs: 200 },
+  ])(
+    "keeps the count-in aligned with playback rate $rate",
+    ({ rate, beforeLoopMs, remainingMs }) => {
+      setNavigatorLanguage("en-US");
+      vi.useFakeTimers();
+      installPlayableAudioMocks();
+      const song = createDemoRehearsalSong();
+
+      render(
+        <RehearsalPlayer
+          song={song}
+          hasLocalAudio={true}
+          audioSourcePath={audioSourcePath}
+        />,
+      );
+      fireEvent.change(screen.getByRole("combobox", { name: /Playback speed/i }), {
+        target: { value: rate },
+      });
+      fireEvent.click(
+        screen.getByRole("button", { name: /Start the count-in/i }),
+      );
+
+      act(() => {
+        vi.advanceTimersByTime(beforeLoopMs);
+      });
+      expect(
+        screen.getByTestId("rehearsal-loop-next-action").textContent,
+      ).not.toMatch(/looping/i);
+
+      act(() => {
+        vi.advanceTimersByTime(remainingMs);
+      });
+      expect(
+        screen.getByTestId("rehearsal-loop-next-action").textContent,
+      ).toMatch(/looping/i);
+    },
+  );
+
+  it("scales and reschedules section boundaries when playback rate changes", () => {
+    setNavigatorLanguage("en-US");
+    vi.useFakeTimers();
+    installPlayableAudioMocks();
+    const song = createDemoRehearsalSong();
+    const setTimeoutSpy = vi.spyOn(window, "setTimeout");
+
+    render(
+      <RehearsalPlayer
+        song={song}
+        hasLocalAudio={true}
+        audioSourcePath={audioSourcePath}
+      />,
+    );
+    fireEvent.change(screen.getByRole("combobox", { name: /Playback speed/i }), {
+      target: { value: "1.25" },
+    });
+    fireEvent.click(
+      screen.getByRole("button", { name: /Start the count-in/i }),
+    );
+    act(() => {
+      vi.advanceTimersByTime(1600);
+    });
+
+    expect(setTimeoutSpy.mock.calls.at(-1)?.[1]).toBeCloseTo(16_000, 5);
+
+    fireEvent.change(screen.getByRole("combobox", { name: /Playback speed/i }), {
+      target: { value: "0.75" },
+    });
+
+    expect(setTimeoutSpy.mock.calls.at(-1)?.[1]).toBeCloseTo(
+      20_000 / 0.75,
+      5,
+    );
+  });
+
   it("applies supported playback speed while preserving pitch when available", () => {
     setNavigatorLanguage("en-US");
     const { play } = installPlayableAudioMocks();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index b95de46c7..cb438d19c 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -266,9 +266,9 @@ export function RehearsalPlayer({
       setTransport((current) =>
         reduceRehearsalTransport(current, { type: "beat" }),
       );
-    }, beatDurationMs(transport.loop.tempoBpm));
+    }, beatDurationMs(transport.loop.tempoBpm) / transport.playbackRate);
     return () => window.clearInterval(timer);
-  }, [transport.phase, transport.loop]);
+  }, [transport.phase, transport.loop, transport.playbackRate]);
 
   useEffect(() => {
     if (!audioSourceUrl || !transport.loop) {
@@ -314,6 +314,7 @@ export function RehearsalPlayer({
       return undefined;
     }
     const loop = transport.loop;
+    const playbackRate = transport.playbackRate;
     let boundaryTimer: number | undefined;
     /** Cancel the pending media-clock boundary check. */
     const clearBoundaryTimer = () => {
@@ -354,7 +355,12 @@ export function RehearsalPlayer({
         } else {
           scheduleLoopBoundary();
         }
-      }, Math.min(remainingSeconds * 1000, 2_147_483_647));
+      },
+        Math.min(
+          (remainingSeconds / playbackRate) * 1000,
+          2_147_483_647,
+        ),
+      );
     };
     /** Keep the map playhead aligned with the scoped audio element. */
     const syncPlayhead = () => {
@@ -382,7 +388,13 @@ export function RehearsalPlayer({
       audio.removeEventListener("error", failPlayback);
       audio.removeEventListener("ended", failPlayback);
     };
-  }, [audioSourceUrl, handlePlaybackError, transport.phase, transport.loop]);
+  }, [
+    audioSourceUrl,
+    handlePlaybackError,
+    transport.phase,
+    transport.loop,
+    transport.playbackRate,
+  ]);
 
   const actionKey = nextActionTemplateKey(transport, hasPlayableAudio);
   const nextAction = fillRehearsalCopy(

From 39927fbbaf0c4f7fb5d84d5ba6086f6c5f748064 Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 04:52:43 +0900
Subject: [PATCH 03/13] feat(player): filter loops by rehearsal role

---
 CHANGELOG.md                                  |  4 +-
 .../workspace/RehearsalPlayer.test.tsx        | 47 +++++++++++++++++++
 .../features/workspace/RehearsalPlayer.tsx    | 39 ++++++++++++---
 .../src/features/workspace/Workspace.test.tsx | 22 ++++++++-
 .../src/features/workspace/Workspace.tsx      |  2 +
 .../workspace/rehearsalTransport.test.ts      | 22 +++++++++
 .../features/workspace/rehearsalTransport.ts  | 20 ++++++++
 apps/desktop/src/locales/en/common.json       |  3 ++
 apps/desktop/src/locales/ko/common.json       |  3 ++
 9 files changed, 154 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index de75b99cf..64e4c894a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,8 @@
 
 ### Fixed
 
+- Kept the rehearsal player section picker aligned with the selected player or
+  vocal role while preserving the full song-form roadmap.
 - Upgraded the local score PDF parser to `pdfjs-dist` 6.2.108, pinned Undici 7.29.0 across the workspace, and constrained PDF loading to copied in-memory bytes with a same-origin bundled worker and npm-generated lock provenance.
 
 ## [0.1.3] - 2026-04-29
@@ -75,4 +77,4 @@
 
 - `ChordsFeature` (코드 분석) 화면에서 각 파트(Role)의 `transpositionPlan`(이조/조옮김 계획)을 표시하는 기능을 추가했습니다.
 - `RangesFeature` (음역대 분석) 화면에서 겹침 경고(Overlap warning) 외에 해당 파트의 채보(Transcription) 가능 노드 수를 요약하여 보여주는 기능을 추가했습니다.
-- 신규 UI 요소에 대한 단위 테스트를 추가했습니다 (`apps/desktop/src/features/chords/index.test.tsx`, `apps/desktop/src/features/ranges/index.test.tsx`).
\ No newline at end of file
+- 신규 UI 요소에 대한 단위 테스트를 추가했습니다 (`apps/desktop/src/features/chords/index.test.tsx`, `apps/desktop/src/features/ranges/index.test.tsx`).
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index 80ac13db2..202da786f 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -128,6 +128,53 @@ describe("RehearsalPlayer", () => {
     ).not.toMatch(/Count in 4 beats/i);
   });
 
+  it("limits the section picker to sections containing the active role", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const chorus = structuredClone(song.sections[0]!);
+    chorus.id = "chorus-1";
+    chorus.label = "chorus";
+    chorus.timeRange = { start: 40, end: 64 };
+    chorus.roles = chorus.roles.filter((role) => role.id !== "lead-vocal");
+    song.sections.push(chorus);
+
+    render(
+      <RehearsalPlayer
+        song={song}
+        activeRole="lead-vocal"
+        activeRoleName="Lead Vocal"
+      />,
+    );
+
+    expect(
+      screen.getByRole("group", { name: "Playable sections for Lead Vocal" }),
+    ).toBeTruthy();
+    expect(screen.getByRole("button", { name: /verse/i })).toBeTruthy();
+    expect(screen.queryByRole("button", { name: /chorus/i })).toBeNull();
+    expect(screen.getByTestId("rehearsal-loop-role-filter")).toHaveTextContent(
+      "Showing sections that include Lead Vocal.",
+    );
+  });
+
+  it("explains when the active role has no playable sections", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.roles = [];
+
+    render(
+      <RehearsalPlayer
+        song={song}
+        activeRole="lead-vocal"
+        activeRoleName="Lead Vocal"
+      />,
+    );
+
+    expect(screen.getByTestId("rehearsal-loop-next-action")).toHaveTextContent(
+      "No playable sections include Lead Vocal yet.",
+    );
+    expect(screen.queryByRole("group")).toBeNull();
+  });
+
   it("stops active count-in and loop ticking when local-audio authority is revoked", () => {
     setNavigatorLanguage("en-US");
     vi.useFakeTimers();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index cb438d19c..db8453ce5 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -33,6 +33,8 @@ interface RehearsalPlayerProps {
   song: RehearsalSong;
   hasLocalAudio?: boolean;
   audioSourcePath?: string | null;
+  activeRole?: string | null;
+  activeRoleName?: string | null;
   startNonce?: number;
 }
 
@@ -94,10 +96,15 @@ export function RehearsalPlayer({
   song,
   hasLocalAudio = false,
   audioSourcePath = null,
+  activeRole = null,
+  activeRoleName = null,
   startNonce = 0,
 }: RehearsalPlayerProps): ReactElement {
   const t = useMemo(() => createTranslator(detectPreferredLocale()), []);
-  const playableLoops = useMemo(() => resolveLoopWindows(song), [song]);
+  const playableLoops = useMemo(
+    () => resolveLoopWindows(song, activeRole),
+    [activeRole, song],
+  );
   const [selectedSectionIndex, setSelectedSectionIndex] = useState(0);
   const selectedRendererIndex = playableLoops[selectedSectionIndex]
     ? selectedSectionIndex
@@ -397,10 +404,20 @@ export function RehearsalPlayer({
   ]);
 
   const actionKey = nextActionTemplateKey(transport, hasPlayableAudio);
-  const nextAction = fillRehearsalCopy(
-    t(actionKey as TranslationKey),
-    nextActionValues(transport),
-  );
+  const nextAction =
+    activeRoleName && playableLoops.length === 0
+      ? fillRehearsalCopy(t("workspaceLoopNoRoleSections"), {
+          roleName: activeRoleName,
+        })
+      : fillRehearsalCopy(
+          t(actionKey as TranslationKey),
+          nextActionValues(transport),
+        );
+  const sectionPickerLabel = activeRoleName
+    ? fillRehearsalCopy(t("workspaceLoopSectionPickerForRole"), {
+        roleName: activeRoleName,
+      })
+    : t("workspaceLoopSectionPickerLabel");
   const canStart =
     transport.loop !== null &&
     hasPlayableAudio &&
@@ -429,11 +446,21 @@ export function RehearsalPlayer({
       >
         {nextAction}
       </p>
+      {activeRoleName && playableLoops.length > 0 ? (
+        <p
+          className="mt-3 text-xs font-semibold text-cyan-100"
+          data-testid="rehearsal-loop-role-filter"
+        >
+          {fillRehearsalCopy(t("workspaceLoopRoleFilterHint"), {
+            roleName: activeRoleName,
+          })}
+        </p>
+      ) : null}
       {playableLoops.length > 0 ? (
         <div
           className="mt-3 flex flex-wrap gap-2"
           role="group"
-          aria-label={t("workspaceLoopSectionPickerLabel")}
+          aria-label={sectionPickerLabel}
         >
           {playableLoops.map((loop, index) => {
             const selected = index === selectedRendererIndex;
diff --git a/apps/desktop/src/features/workspace/Workspace.test.tsx b/apps/desktop/src/features/workspace/Workspace.test.tsx
index b36a13bc2..1aebd0116 100644
--- a/apps/desktop/src/features/workspace/Workspace.test.tsx
+++ b/apps/desktop/src/features/workspace/Workspace.test.tsx
@@ -1,4 +1,4 @@
-import { fireEvent, render, screen } from "@testing-library/react";
+import { fireEvent, render, screen, within } from "@testing-library/react";
 import {
   createDemoRehearsalSong,
   type ProjectBootstrapSummary,
@@ -231,6 +231,26 @@ describe("Workspace", () => {
     ).toBeNull();
   });
 
+  it("passes the selected role into the player section filter", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const chorus = structuredClone(song.sections[0]!);
+    chorus.id = "chorus-1";
+    chorus.label = "chorus";
+    chorus.timeRange = { start: 40, end: 64 };
+    chorus.roles = chorus.roles.filter((role) => role.id !== "lead-vocal");
+    song.sections.push(chorus);
+
+    render(<Workspace song={song} />);
+    fireEvent.click(screen.getByRole("tab", { name: "Lead Vocal" }));
+
+    const playerSections = screen.getByRole("group", {
+      name: "Playable sections for Lead Vocal",
+    });
+    expect(within(playerSections).getByRole("button", { name: /verse/i })).toBeTruthy();
+    expect(within(playerSections).queryByRole("button", { name: /chorus/i })).toBeNull();
+  });
+
   it("enables bass transcription from selected role metadata rather than role id text", () => {
     const song = createDemoRehearsalSong();
     song.sections[0]!.roles[0] = {
diff --git a/apps/desktop/src/features/workspace/Workspace.tsx b/apps/desktop/src/features/workspace/Workspace.tsx
index 80612ad8c..b4f5b6617 100644
--- a/apps/desktop/src/features/workspace/Workspace.tsx
+++ b/apps/desktop/src/features/workspace/Workspace.tsx
@@ -369,6 +369,8 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
             song={song}
             hasLocalAudio={hasLocalAudio}
             audioSourcePath={parsedSourceBootstrap?.source.sourcePath ?? null}
+            activeRole={activeRole}
+            activeRoleName={activeRole ? activeRoleDetails?.name ?? activeRole : null}
             startNonce={loopStartNonce}
           />
 
diff --git a/apps/desktop/src/features/workspace/rehearsalTransport.test.ts b/apps/desktop/src/features/workspace/rehearsalTransport.test.ts
index c07c41fc5..0310d4e0c 100644
--- a/apps/desktop/src/features/workspace/rehearsalTransport.test.ts
+++ b/apps/desktop/src/features/workspace/rehearsalTransport.test.ts
@@ -13,6 +13,7 @@ import {
   rehearsalPlaybackRates,
   reduceRehearsalTransport,
   resolveLoopWindow,
+  resolveLoopWindows,
   resolveRehearsalTempo,
   wrapPlayhead,
 } from "./rehearsalTransport";
@@ -59,6 +60,27 @@ describe("rehearsalTransport", () => {
     expect(window?.endSeconds).toBe(64);
   });
 
+  it("filters loop windows to sections containing the selected role", () => {
+    const song = createDemoRehearsalSong();
+    const chorus = structuredClone(song.sections[0]!);
+    chorus.id = "chorus-1";
+    chorus.label = "chorus";
+    chorus.timeRange = { start: 40, end: 64 };
+    chorus.roles = chorus.roles.filter((role) => role.id !== "lead-vocal");
+    song.sections.push(chorus);
+
+    expect(
+      resolveLoopWindows(song, "lead-vocal").map((window) => window.sectionId),
+    ).toEqual(["verse-1"]);
+    expect(
+      resolveLoopWindows(song, "bass-guitar").map((window) => window.sectionId),
+    ).toEqual(["verse-1", "chorus-1"]);
+    expect(resolveLoopWindows(song).map((window) => window.sectionId)).toEqual([
+      "verse-1",
+      "chorus-1",
+    ]);
+  });
+
   it("rejects a sparse hostile section array without scanning its declared length", () => {
     const song = createDemoRehearsalSong();
     song.sections = new Array(0xffffffff) as typeof song.sections;
diff --git a/apps/desktop/src/features/workspace/rehearsalTransport.ts b/apps/desktop/src/features/workspace/rehearsalTransport.ts
index e8a465c98..5cc0e9899 100644
--- a/apps/desktop/src/features/workspace/rehearsalTransport.ts
+++ b/apps/desktop/src/features/workspace/rehearsalTransport.ts
@@ -166,6 +166,20 @@ function playableSectionSnapshot(
   };
 }
 
+/** Return whether a snapshotted section contains the selected rehearsal role. */
+function sectionContainsRole(section: object, roleId: string): boolean {
+  const roles = ownedDenseArray(ownDataValue(section, "roles"));
+  if (!roles) {
+    return false;
+  }
+  return roles.some(
+    (role) =>
+      role !== null &&
+      typeof role === "object" &&
+      ownDataValue(role, "id") === roleId,
+  );
+}
+
 /** Return whether a section exposes a usable closed loop window. */
 export function isPlayableLoopSection(
   section: RehearsalSection | undefined | null,
@@ -236,6 +250,7 @@ export function createLoopWindow(
 /** Snapshot every playable loop window from one untrusted song record. */
 export function resolveLoopWindows(
   song: RehearsalSong | null | undefined,
+  roleId: string | null | undefined = null,
 ): RehearsalLoopWindow[] {
   if (!song || typeof song !== "object") {
     return [];
@@ -245,10 +260,15 @@ export function resolveLoopWindows(
     return [];
   }
   const tempo = ownDataValue(song, "tempo");
+  const selectedRoleId =
+    typeof roleId === "string" && roleId.trim() ? roleId : null;
   return sections.flatMap((section) => {
     if (!section || typeof section !== "object") {
       return [];
     }
+    if (selectedRoleId && !sectionContainsRole(section, selectedRoleId)) {
+      return [];
+    }
     const window = createLoopWindow(section as RehearsalSection, tempo);
     return window ? [window] : [];
   });
diff --git a/apps/desktop/src/locales/en/common.json b/apps/desktop/src/locales/en/common.json
index 2c0308977..e51e2a962 100644
--- a/apps/desktop/src/locales/en/common.json
+++ b/apps/desktop/src/locales/en/common.json
@@ -152,6 +152,9 @@
   "workspaceLoopRegionLabel": "Tonight's section loop",
   "workspaceLoopTitle": "Tonight's loop",
   "workspaceLoopSectionPickerLabel": "Playable sections",
+  "workspaceLoopSectionPickerForRole": "Playable sections for {roleName}",
+  "workspaceLoopRoleFilterHint": "Showing sections that include {roleName}.",
+  "workspaceLoopNoRoleSections": "No playable sections include {roleName} yet. Choose All Roles or map this role first.",
   "workspaceLoopStart": "Start the count-in",
   "workspaceLoopThisSection": "Start selected section loop",
   "workspaceLoopResume": "Continue rehearsal clock",
diff --git a/apps/desktop/src/locales/ko/common.json b/apps/desktop/src/locales/ko/common.json
index 6f78ff5b5..b489229c3 100644
--- a/apps/desktop/src/locales/ko/common.json
+++ b/apps/desktop/src/locales/ko/common.json
@@ -152,6 +152,9 @@
   "workspaceLoopRegionLabel": "오늘 밤 구간 루프",
   "workspaceLoopTitle": "오늘 밤 루프",
   "workspaceLoopSectionPickerLabel": "연습할 구간",
+  "workspaceLoopSectionPickerForRole": "{roleName} 역할의 연습 구간",
+  "workspaceLoopRoleFilterHint": "{roleName} 역할이 포함된 구간만 표시합니다.",
+  "workspaceLoopNoRoleSections": "{roleName} 역할이 포함된 연습 구간이 아직 없습니다. 전체 보기로 바꾸거나 먼저 역할을 배치하세요.",
   "workspaceLoopStart": "카운트인 시작",
   "workspaceLoopThisSection": "선택한 구간 루프 시작",
   "workspaceLoopResume": "합주 시계 계속",

From 43698a61377f9c2f7d01e65783089caceed8c1b5 Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 05:06:57 +0900
Subject: [PATCH 04/13] fix(player): preserve role loop selection

---
 .../workspace/RehearsalPlayer.test.tsx        | 38 ++++++++++++++++
 .../features/workspace/RehearsalPlayer.tsx    | 45 +++++++++++--------
 .../src/features/workspace/Workspace.test.tsx | 26 +++++++++++
 .../src/features/workspace/Workspace.tsx      | 42 ++++++++++-------
 4 files changed, 116 insertions(+), 35 deletions(-)

diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index 202da786f..453cc3ecf 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -156,6 +156,44 @@ describe("RehearsalPlayer", () => {
     );
   });
 
+  it("keeps the selected loop by section ID when an earlier section is filtered out", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const verse = structuredClone(song.sections[0]!);
+    verse.id = "verse-no-lead-vocal";
+    verse.roles = verse.roles.filter((role) => role.id !== "lead-vocal");
+    const chorus = structuredClone(song.sections[0]!);
+    chorus.id = "chorus-1";
+    chorus.label = "chorus";
+    chorus.timeRange = { start: 40, end: 64 };
+    song.sections = [verse, chorus];
+
+    const { rerender } = render(<RehearsalPlayer song={song} />);
+    fireEvent.click(screen.getByRole("button", { name: /chorus/i }));
+    expect(
+      screen
+        .getByRole("button", { name: /chorus/i })
+        .getAttribute("aria-pressed"),
+    ).toBe("true");
+
+    rerender(
+      <RehearsalPlayer
+        song={song}
+        activeRole="lead-vocal"
+        activeRoleName="Lead Vocal"
+      />,
+    );
+
+    expect(
+      screen
+        .getByRole("button", { name: /chorus/i })
+        .getAttribute("aria-pressed"),
+    ).toBe("true");
+    expect(screen.getByTestId("rehearsal-loop-next-action")).toHaveTextContent(
+      /Map chorus from 0:40–1:04/i,
+    );
+  });
+
   it("explains when the active role has no playable sections", () => {
     setNavigatorLanguage("en-US");
     const song = createDemoRehearsalSong();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index db8453ce5..d344b002b 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -91,6 +91,11 @@ function hasSameLoopTiming(
   );
 }
 
+/** Return a stable selection key when analysis emits duplicate section IDs. */
+function loopSelectionKey(loop: RehearsalLoopWindow): string {
+  return `${loop.sectionId}:${loop.startSeconds}:${loop.endSeconds}`;
+}
+
 /** Render tonight's first section loop with a count-in and a named next action. */
 export function RehearsalPlayer({
   song,
@@ -105,10 +110,11 @@ export function RehearsalPlayer({
     () => resolveLoopWindows(song, activeRole),
     [activeRole, song],
   );
-  const [selectedSectionIndex, setSelectedSectionIndex] = useState(0);
-  const selectedRendererIndex = playableLoops[selectedSectionIndex]
-    ? selectedSectionIndex
-    : 0;
+  const [selectedLoopKey, setSelectedLoopKey] = useState<string | null>(null);
+  const selectedLoop =
+    playableLoops.find((loop) => loopSelectionKey(loop) === selectedLoopKey) ??
+    playableLoops[0] ??
+    null;
   const [transport, setTransport] = useState<RehearsalTransportState>(() =>
     reduceRehearsalTransport(createIdleTransportState(), {
       type: "arm",
@@ -191,24 +197,26 @@ export function RehearsalPlayer({
   }, [audioSourceUrl, hasNativeAudioConversionError]);
 
   useEffect(() => {
-    const nextLoop = playableLoops[selectedRendererIndex] ?? null;
     setTransport((current) => {
       if (
         current.loop &&
-        nextLoop &&
-        hasSameLoopTiming(current.loop, nextLoop)
+        selectedLoop &&
+        hasSameLoopTiming(current.loop, selectedLoop)
       ) {
         if (
-          current.loop.sectionLabel === nextLoop.sectionLabel &&
-          current.loop.tempoAssumed === nextLoop.tempoAssumed
+          current.loop.sectionLabel === selectedLoop.sectionLabel &&
+          current.loop.tempoAssumed === selectedLoop.tempoAssumed
         ) {
           return current;
         }
-        return { ...current, loop: nextLoop };
+        return { ...current, loop: selectedLoop };
       }
-      return reduceRehearsalTransport(current, { type: "arm", loop: nextLoop });
+      return reduceRehearsalTransport(current, {
+        type: "arm",
+        loop: selectedLoop,
+      });
     });
-  }, [playableLoops, selectedRendererIndex]);
+  }, [selectedLoop]);
 
   useEffect(() => {
     const audio = audioRef.current;
@@ -233,7 +241,6 @@ export function RehearsalPlayer({
     if (!hasPlayableAudio) {
       return;
     }
-    const selectedLoop = playableLoops[selectedRendererIndex] ?? null;
     if (selectedLoop) {
       setPlaybackError(false);
       startAudio(selectedLoop, false);
@@ -249,8 +256,7 @@ export function RehearsalPlayer({
     startAudio,
     startNonce,
     hasPlayableAudio,
-    playableLoops,
-    selectedRendererIndex,
+    selectedLoop,
   ]);
 
   useEffect(() => {
@@ -463,10 +469,13 @@ export function RehearsalPlayer({
           aria-label={sectionPickerLabel}
         >
           {playableLoops.map((loop, index) => {
-            const selected = index === selectedRendererIndex;
+            const selectionKey = loopSelectionKey(loop);
+            const selected =
+              selectedLoop !== null &&
+              selectionKey === loopSelectionKey(selectedLoop);
             return (
               <Button
-                key={`rehearsal-loop-section-${index}`}
+                key={`rehearsal-loop-section-${selectionKey}-${index}`}
                 type="button"
                 variant={selected ? "default" : "outline"}
                 size="sm"
@@ -476,7 +485,7 @@ export function RehearsalPlayer({
                     ? "min-h-10 border-cyan-300/30 bg-cyan-300 font-semibold text-slate-950"
                     : "min-h-10 border-white/10 bg-white/5 font-semibold text-slate-100"
                 }
-                onClick={() => setSelectedSectionIndex(index)}
+                onClick={() => setSelectedLoopKey(selectionKey)}
               >
                 <span>{loop.sectionLabel}</span>
                 <span> · </span>
diff --git a/apps/desktop/src/features/workspace/Workspace.test.tsx b/apps/desktop/src/features/workspace/Workspace.test.tsx
index 1aebd0116..6bb8cb566 100644
--- a/apps/desktop/src/features/workspace/Workspace.test.tsx
+++ b/apps/desktop/src/features/workspace/Workspace.test.tsx
@@ -251,6 +251,32 @@ describe("Workspace", () => {
     expect(within(playerSections).queryByRole("button", { name: /chorus/i })).toBeNull();
   });
 
+  it("clears a role that is absent after replacing the song", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const replacement = createDemoRehearsalSong();
+    replacement.sections = replacement.sections.map((section) => ({
+      ...section,
+      roles: section.roles.filter((role) => role.id !== "lead-vocal"),
+    }));
+
+    const { rerender } = render(<Workspace song={song} />);
+    fireEvent.click(screen.getByRole("tab", { name: "Lead Vocal" }));
+    expect(screen.getByTestId("rehearsal-loop-role-filter")).toHaveTextContent(
+      "Showing sections that include Lead Vocal.",
+    );
+
+    rerender(<Workspace song={replacement} />);
+
+    expect(screen.queryByTestId("rehearsal-loop-role-filter")).toBeNull();
+    expect(
+      screen.getByRole("tab", { name: "All Roles", selected: true }),
+    ).toBeTruthy();
+    expect(screen.getByTestId("rehearsal-loop-next-action")).not.toHaveTextContent(
+      /No playable sections include Lead Vocal/i,
+    );
+  });
+
   it("enables bass transcription from selected role metadata rather than role id text", () => {
     const song = createDemoRehearsalSong();
     song.sections[0]!.roles[0] = {
diff --git a/apps/desktop/src/features/workspace/Workspace.tsx b/apps/desktop/src/features/workspace/Workspace.tsx
index b4f5b6617..54842b46b 100644
--- a/apps/desktop/src/features/workspace/Workspace.tsx
+++ b/apps/desktop/src/features/workspace/Workspace.tsx
@@ -1,4 +1,4 @@
-import { useState, useMemo, memo, type MouseEvent } from "react";
+import { useState, useMemo, memo, useEffect, type MouseEvent } from "react";
 import { parseProjectBootstrapSummary, type ProjectBootstrapSummary, type RehearsalSong, type RehearsalRole } from "@bandscope/shared-types";
 import { RoleSwitcher } from "./RoleSwitcher";
 import { SectionRoadmap } from "./SectionRoadmap";
@@ -146,6 +146,14 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
     return map;
   }, [song]);
 
+  const resolvedActiveRole = activeRole && roleMap.has(activeRole) ? activeRole : null;
+
+  useEffect(() => {
+    if (activeRole && !roleMap.has(activeRole)) {
+      setActiveRole(null);
+    }
+  }, [activeRole, roleMap]);
+
   const allRoles = useMemo(() => {
     // Performance: Avoid O(N) allocation of intermediate array from Array.from() before mapping
     const roles: { id: string; name: string }[] = [];
@@ -157,11 +165,11 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
 
   // Performance: use the cached roleMap so activeRoleDetails does not rescan sections and roles on every render.
   const activeRoleDetails = useMemo(() => {
-    if (!activeRole) return undefined;
-    return roleMap.get(activeRole);
-  }, [activeRole, roleMap]);
+    if (!resolvedActiveRole) return undefined;
+    return roleMap.get(resolvedActiveRole);
+  }, [resolvedActiveRole, roleMap]);
   const canTranscribeBass = activeRoleDetails?.name.toLowerCase().includes("bass") ?? false;
-  const firstRange = useMemo(() => firstRangeSqueeze(song, activeRole), [activeRole, song]);
+  const firstRange = useMemo(() => firstRangeSqueeze(song, resolvedActiveRole), [resolvedActiveRole, song]);
   const firstRangeCopy = firstRange
     ? fillRangeCopy(
         t(firstRange.overlapWarning ? "workspaceFirstRangeClash" : "workspaceFirstRangeCheck"),
@@ -176,13 +184,13 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
 
   /** Handle the practice progress change internally by immutably updating the song state. */
   const handlePracticeProgressChange = (newProgress: number) => {
-    if (!activeRole || !onSongUpdate) return;
+    if (!resolvedActiveRole || !onSongUpdate) return;
 
     // Performance: Use shallow copying to avoid expensive structuredClone
     const nextSong = {
       ...song,
       sections: song.sections.map(section => {
-        const roleIndex = section.roles.findIndex(r => r.id === activeRole);
+        const roleIndex = section.roles.findIndex(r => r.id === resolvedActiveRole);
         if (roleIndex === -1) return section;
 
         const nextRoles = [...section.roles];
@@ -221,12 +229,12 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
     [collaborationApprovals.length, collaborationAssignments.length, collaborationComments.length]
   );
   const activeRoleAssignments = useMemo(
-    () => collaborationAssignments.filter(assignment => assignment.roleId === undefined || assignment.roleId === activeRole),
-    [activeRole, collaborationAssignments]
+    () => collaborationAssignments.filter(assignment => assignment.roleId === undefined || assignment.roleId === resolvedActiveRole),
+    [resolvedActiveRole, collaborationAssignments]
   );
   const activeRoleComments = useMemo(
-    () => collaborationComments.filter(comment => comment.roleId === undefined || comment.roleId === activeRole),
-    [activeRole, collaborationComments]
+    () => collaborationComments.filter(comment => comment.roleId === undefined || comment.roleId === resolvedActiveRole),
+    [resolvedActiveRole, collaborationComments]
   );
   const roleHarmonicExplanation =
     nonBlankText(activeRoleDetails?.harmonicExplanation) ??
@@ -369,8 +377,8 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
             song={song}
             hasLocalAudio={hasLocalAudio}
             audioSourcePath={parsedSourceBootstrap?.source.sourcePath ?? null}
-            activeRole={activeRole}
-            activeRoleName={activeRole ? activeRoleDetails?.name ?? activeRole : null}
+            activeRole={resolvedActiveRole}
+            activeRoleName={resolvedActiveRole ? activeRoleDetails?.name ?? resolvedActiveRole : null}
             startNonce={loopStartNonce}
           />
 
@@ -382,15 +390,15 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
               </div>
               <RoleSwitcher
                 roles={allRoles}
-                activeRole={activeRole}
+                activeRole={resolvedActiveRole}
                 onRoleChange={setActiveRole}
                 />
             </div>
 
-            {activeRole && (
+            {resolvedActiveRole && (
               <div className="mb-4 rounded-2xl border border-emerald-300/20 bg-emerald-300/[0.06] p-4">
                 <p className="text-xs font-black uppercase tracking-[0.24em] text-emerald-200">Stem Player</p>
-                <p className="mt-1 text-sm font-semibold text-slate-100">{activeRoleDetails?.name ?? activeRole}</p>
+                <p className="mt-1 text-sm font-semibold text-slate-100">{activeRoleDetails?.name ?? resolvedActiveRole}</p>
                 <div className="mt-3 flex flex-wrap gap-2">
                   <Button
                     type="button"
@@ -533,7 +541,7 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
 
           <SectionRoadmap
             song={song}
-            activeRole={activeRole}
+            activeRole={resolvedActiveRole}
             onSongUpdate={onSongUpdate}
           />
           </section>

From 2490ce247011e4dc00646a4c9adab703fffc240c Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 05:35:32 +0900
Subject: [PATCH 05/13] feat(player): add keyboard section cue navigation

---
 CHANGELOG.md                                  |  1 +
 .../workspace/RehearsalPlayer.test.tsx        | 28 +++++++++++++
 .../features/workspace/RehearsalPlayer.tsx    | 40 +++++++++++++++++++
 apps/desktop/src/locales/en/common.json       |  1 +
 apps/desktop/src/locales/ko/common.json       |  1 +
 5 files changed, 71 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 64e4c894a..d890e25de 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@
 - Tonight's rehearsal map now arms the first valid section map-clock loop, runs a tempo count-in, and names the next start, pause, stop, or choose-local-song action without claiming decoded audio playback; admitted section timing and picker copy use the same descriptor-snapshotted transport window.
 - Name tonight's first playable range on the ready rehearsal map and tell the player to check that span on their instrument before the section.
 - Display the analyzed song tempo (BPM) as a badge in the rehearsal workspace.
+- Move between playable section cues with Left and Right Arrow and keep the selected cue focused.
 - 각 합주 역할(Role)별 개인 연습 진행도를 0~100% 범위로 기록 및 시각화할 수 있는 연습 진척도(`practiceProgress`) 트래커 기능 추가. UI 컨트롤(슬라이더 및 +/- 버튼)과 한/영 다국어 지원 포함.
 
 ### Changed
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index 453cc3ecf..a50d58ee1 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -156,6 +156,34 @@ describe("RehearsalPlayer", () => {
     );
   });
 
+  it("moves section cues with the arrow keys and keeps the selected cue focused", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const chorus = structuredClone(song.sections[0]!);
+    chorus.id = "chorus-1";
+    chorus.label = "chorus";
+    chorus.timeRange = { start: 40, end: 64 };
+    song.sections = [song.sections[0]!, chorus];
+
+    render(<RehearsalPlayer song={song} />);
+
+    const verse = screen.getByRole("button", { name: /verse/i });
+    const chorusButton = screen.getByRole("button", { name: /chorus/i });
+    expect(
+      screen.getByTestId("rehearsal-loop-keyboard-hint"),
+    ).toHaveTextContent("Use Left and Right Arrow to move between section cues.");
+
+    fireEvent.keyDown(verse, { key: "ArrowRight" });
+    expect(chorusButton).toHaveAttribute("aria-pressed", "true");
+    expect(chorusButton).toHaveFocus();
+
+    fireEvent.keyDown(chorusButton, { key: "ArrowRight" });
+    expect(chorusButton).toHaveAttribute("aria-pressed", "true");
+    fireEvent.keyDown(chorusButton, { key: "ArrowLeft" });
+    expect(verse).toHaveAttribute("aria-pressed", "true");
+    expect(verse).toHaveFocus();
+  });
+
   it("keeps the selected loop by section ID when an earlier section is filtered out", () => {
     setNavigatorLanguage("en-US");
     const song = createDemoRehearsalSong();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index d344b002b..62d8a436a 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -4,6 +4,7 @@ import {
   useMemo,
   useRef,
   useState,
+  type KeyboardEvent,
   type ReactElement,
 } from "react";
 import type { RehearsalSong } from "@bandscope/shared-types";
@@ -115,6 +116,34 @@ export function RehearsalPlayer({
     playableLoops.find((loop) => loopSelectionKey(loop) === selectedLoopKey) ??
     playableLoops[0] ??
     null;
+  const handleSectionKeyDown = useCallback(
+    (event: KeyboardEvent<HTMLButtonElement>) => {
+      if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") {
+        return;
+      }
+      const selectedIndex = selectedLoop
+        ? playableLoops.indexOf(selectedLoop)
+        : -1;
+      const nextIndex =
+        selectedIndex + (event.key === "ArrowRight" ? 1 : -1);
+      if (
+        selectedIndex < 0 ||
+        nextIndex < 0 ||
+        nextIndex >= playableLoops.length
+      ) {
+        return;
+      }
+      event.preventDefault();
+      const nextLoop = playableLoops[nextIndex];
+      setSelectedLoopKey(loopSelectionKey(nextLoop));
+      document
+        .getElementById(
+          `rehearsal-loop-section-${loopSelectionKey(nextLoop)}-${nextIndex}`,
+        )
+        ?.focus();
+    },
+    [playableLoops, selectedLoop],
+  );
   const [transport, setTransport] = useState<RehearsalTransportState>(() =>
     reduceRehearsalTransport(createIdleTransportState(), {
       type: "arm",
@@ -479,13 +508,16 @@ export function RehearsalPlayer({
                 type="button"
                 variant={selected ? "default" : "outline"}
                 size="sm"
+                id={`rehearsal-loop-section-${selectionKey}-${index}`}
                 aria-pressed={selected}
+                aria-keyshortcuts="ArrowLeft ArrowRight"
                 className={
                   selected
                     ? "min-h-10 border-cyan-300/30 bg-cyan-300 font-semibold text-slate-950"
                     : "min-h-10 border-white/10 bg-white/5 font-semibold text-slate-100"
                 }
                 onClick={() => setSelectedLoopKey(selectionKey)}
+                onKeyDown={handleSectionKeyDown}
               >
                 <span>{loop.sectionLabel}</span>
                 <span> · </span>
@@ -498,6 +530,14 @@ export function RehearsalPlayer({
           })}
         </div>
       ) : null}
+      {playableLoops.length > 1 ? (
+        <p
+          className="mt-2 text-xs text-slate-400"
+          data-testid="rehearsal-loop-keyboard-hint"
+        >
+          {t("workspaceLoopSectionKeyboardHint")}
+        </p>
+      ) : null}
       <div className="mt-3 flex flex-wrap items-center gap-3">
         <label className="flex min-h-11 items-center gap-2 text-xs font-semibold uppercase tracking-[0.16em] text-slate-300">
           <span>{t("workspaceLoopPlaybackRateLabel")}</span>
diff --git a/apps/desktop/src/locales/en/common.json b/apps/desktop/src/locales/en/common.json
index e51e2a962..704b4f00a 100644
--- a/apps/desktop/src/locales/en/common.json
+++ b/apps/desktop/src/locales/en/common.json
@@ -153,6 +153,7 @@
   "workspaceLoopTitle": "Tonight's loop",
   "workspaceLoopSectionPickerLabel": "Playable sections",
   "workspaceLoopSectionPickerForRole": "Playable sections for {roleName}",
+  "workspaceLoopSectionKeyboardHint": "Use Left and Right Arrow to move between section cues.",
   "workspaceLoopRoleFilterHint": "Showing sections that include {roleName}.",
   "workspaceLoopNoRoleSections": "No playable sections include {roleName} yet. Choose All Roles or map this role first.",
   "workspaceLoopStart": "Start the count-in",
diff --git a/apps/desktop/src/locales/ko/common.json b/apps/desktop/src/locales/ko/common.json
index b489229c3..10ca9e4b4 100644
--- a/apps/desktop/src/locales/ko/common.json
+++ b/apps/desktop/src/locales/ko/common.json
@@ -153,6 +153,7 @@
   "workspaceLoopTitle": "오늘 밤 루프",
   "workspaceLoopSectionPickerLabel": "연습할 구간",
   "workspaceLoopSectionPickerForRole": "{roleName} 역할의 연습 구간",
+  "workspaceLoopSectionKeyboardHint": "왼쪽·오른쪽 화살표로 구간 큐를 이동하세요.",
   "workspaceLoopRoleFilterHint": "{roleName} 역할이 포함된 구간만 표시합니다.",
   "workspaceLoopNoRoleSections": "{roleName} 역할이 포함된 연습 구간이 아직 없습니다. 전체 보기로 바꾸거나 먼저 역할을 배치하세요.",
   "workspaceLoopStart": "카운트인 시작",

From 04396d9b4ebfd50ad598ffaf1edb33df3de70840 Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 05:41:10 +0900
Subject: [PATCH 06/13] fix(player): follow focused cue during arrow navigation

---
 .../src/features/workspace/RehearsalPlayer.test.tsx  |  4 ++++
 .../src/features/workspace/RehearsalPlayer.tsx       | 12 ++++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index a50d58ee1..7f823ef47 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -173,6 +173,10 @@ describe("RehearsalPlayer", () => {
       screen.getByTestId("rehearsal-loop-keyboard-hint"),
     ).toHaveTextContent("Use Left and Right Arrow to move between section cues.");
 
+    chorusButton.focus();
+    fireEvent.keyDown(chorusButton, { key: "ArrowLeft" });
+    expect(verse).toHaveFocus();
+
     fireEvent.keyDown(verse, { key: "ArrowRight" });
     expect(chorusButton).toHaveAttribute("aria-pressed", "true");
     expect(chorusButton).toHaveFocus();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index 62d8a436a..42398104f 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -121,13 +121,20 @@ export function RehearsalPlayer({
       if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") {
         return;
       }
+      const focusedIndex = Number(event.currentTarget.dataset.loopIndex);
       const selectedIndex = selectedLoop
         ? playableLoops.indexOf(selectedLoop)
         : -1;
+      const currentIndex =
+        Number.isSafeInteger(focusedIndex) &&
+        focusedIndex >= 0 &&
+        focusedIndex < playableLoops.length
+          ? focusedIndex
+          : selectedIndex;
       const nextIndex =
-        selectedIndex + (event.key === "ArrowRight" ? 1 : -1);
+        currentIndex + (event.key === "ArrowRight" ? 1 : -1);
       if (
-        selectedIndex < 0 ||
+        currentIndex < 0 ||
         nextIndex < 0 ||
         nextIndex >= playableLoops.length
       ) {
@@ -509,6 +516,7 @@ export function RehearsalPlayer({
                 variant={selected ? "default" : "outline"}
                 size="sm"
                 id={`rehearsal-loop-section-${selectionKey}-${index}`}
+                data-loop-index={index}
                 aria-pressed={selected}
                 aria-keyshortcuts="ArrowLeft ArrowRight"
                 className={

From 9c61a803a7cc951d31015fb22ca275d64f1830f7 Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 06:02:55 +0900
Subject: [PATCH 07/13] feat(player): allow manual cue boundary corrections

---
 .../workspace/RehearsalPlayer.test.tsx        |  43 ++++++
 .../features/workspace/RehearsalPlayer.tsx    | 134 +++++++++++++++++-
 .../src/features/workspace/Workspace.tsx      |   1 +
 apps/desktop/src/locales/en/common.json       |   6 +
 apps/desktop/src/locales/ko/common.json       |   6 +
 5 files changed, 189 insertions(+), 1 deletion(-)

diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index 7f823ef47..12271ec7a 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -188,6 +188,49 @@ describe("RehearsalPlayer", () => {
     expect(verse).toHaveFocus();
   });
 
+  it("lets the selected cue keep a manual range correction in the song map", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const onSongUpdate = vi.fn();
+    render(<RehearsalPlayer song={song} onSongUpdate={onSongUpdate} />);
+
+    expect(screen.getByTestId("rehearsal-loop-boundary-editor")).toHaveTextContent(
+      "Manual cue correction",
+    );
+    const start = screen.getByRole("spinbutton", {
+      name: "Start time (seconds)",
+    });
+    fireEvent.change(start, { target: { value: "12" } });
+    fireEvent.blur(start);
+
+    expect(onSongUpdate).toHaveBeenCalledTimes(1);
+    expect(onSongUpdate.mock.calls[0]![0].sections[0]!.timeRange).toEqual({
+      start: 12,
+      end: 30,
+    });
+    expect(song.sections[0]!.timeRange.start).toBe(10);
+  });
+
+  it("rejects a boundary correction that would invert the selected cue", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const onSongUpdate = vi.fn();
+    render(<RehearsalPlayer song={song} onSongUpdate={onSongUpdate} />);
+
+    const end = screen.getByRole("spinbutton", {
+      name: "End time (seconds)",
+    });
+    fireEvent.change(end, { target: { value: "5" } });
+    fireEvent.blur(end);
+
+    expect(onSongUpdate).not.toHaveBeenCalled();
+    expect(end).toHaveValue(30);
+    expect(end).toHaveAttribute("aria-invalid", "true");
+    expect(screen.getByTestId("rehearsal-loop-boundary-editor")).toHaveTextContent(
+      "with the end after the start",
+    );
+  });
+
   it("keeps the selected loop by section ID when an earlier section is filtered out", () => {
     setNavigatorLanguage("en-US");
     const song = createDemoRehearsalSong();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index 42398104f..2af0478c2 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -4,10 +4,14 @@ import {
   useMemo,
   useRef,
   useState,
+  type FocusEvent,
   type KeyboardEvent,
   type ReactElement,
 } from "react";
-import type { RehearsalSong } from "@bandscope/shared-types";
+import {
+  MAX_SECTION_TIME_SECONDS,
+  type RehearsalSong,
+} from "@bandscope/shared-types";
 import { convertFileSrc } from "@tauri-apps/api/core";
 import { Button } from "@/components/ui/button";
 import {
@@ -32,6 +36,7 @@ import {
 
 interface RehearsalPlayerProps {
   song: RehearsalSong;
+  onSongUpdate?: (song: RehearsalSong) => void;
   hasLocalAudio?: boolean;
   audioSourcePath?: string | null;
   activeRole?: string | null;
@@ -100,6 +105,7 @@ function loopSelectionKey(loop: RehearsalLoopWindow): string {
 /** Render tonight's first section loop with a count-in and a named next action. */
 export function RehearsalPlayer({
   song,
+  onSongUpdate,
   hasLocalAudio = false,
   audioSourcePath = null,
   activeRole = null,
@@ -112,10 +118,14 @@ export function RehearsalPlayer({
     [activeRole, song],
   );
   const [selectedLoopKey, setSelectedLoopKey] = useState<string | null>(null);
+  const [boundaryError, setBoundaryError] = useState(false);
   const selectedLoop =
     playableLoops.find((loop) => loopSelectionKey(loop) === selectedLoopKey) ??
     playableLoops[0] ??
     null;
+  useEffect(() => {
+    setBoundaryError(false);
+  }, [selectedLoopKey]);
   const handleSectionKeyDown = useCallback(
     (event: KeyboardEvent<HTMLButtonElement>) => {
       if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") {
@@ -471,6 +481,72 @@ export function RehearsalPlayer({
     transport.phase === "paused"
       ? t("workspaceLoopResume")
       : t("workspaceLoopStart");
+  const handleBoundaryBlur = useCallback(
+    (boundary: "start" | "end", event: FocusEvent<HTMLInputElement>) => {
+      if (!selectedLoop || !onSongUpdate) {
+        return;
+      }
+      const rawValue = event.currentTarget.value.trim();
+      const value = Number(rawValue);
+      const valid =
+        rawValue !== "" &&
+        Number.isSafeInteger(value) &&
+        value >= 0 &&
+        value <= MAX_SECTION_TIME_SECONDS &&
+        (boundary === "start"
+          ? value < selectedLoop.endSeconds
+          : value > selectedLoop.startSeconds);
+      if (!valid) {
+        event.currentTarget.value = String(
+          boundary === "start"
+            ? selectedLoop.startSeconds
+            : selectedLoop.endSeconds,
+        );
+        setBoundaryError(true);
+        return;
+      }
+
+      setBoundaryError(false);
+      const currentValue =
+        boundary === "start"
+          ? selectedLoop.startSeconds
+          : selectedLoop.endSeconds;
+      if (value === currentValue) {
+        return;
+      }
+
+      const sectionIndex = song.sections.findIndex(
+        (section) =>
+          section.id === selectedLoop.sectionId &&
+          section.timeRange.start === selectedLoop.startSeconds &&
+          section.timeRange.end === selectedLoop.endSeconds,
+      );
+      if (sectionIndex < 0) {
+        return;
+      }
+      const nextSong = {
+        ...song,
+        sections: song.sections.map((section, index) =>
+          index === sectionIndex
+            ? {
+                ...section,
+                timeRange: {
+                  ...section.timeRange,
+                  [boundary]: value,
+                },
+              }
+            : section,
+        ),
+      };
+      const nextLoop =
+        boundary === "start"
+          ? { ...selectedLoop, startSeconds: value }
+          : { ...selectedLoop, endSeconds: value };
+      setSelectedLoopKey(loopSelectionKey(nextLoop));
+      onSongUpdate(nextSong);
+    },
+    [onSongUpdate, selectedLoop, song],
+  );
 
   return (
     <section
@@ -546,6 +622,62 @@ export function RehearsalPlayer({
           {t("workspaceLoopSectionKeyboardHint")}
         </p>
       ) : null}
+      {selectedLoop && onSongUpdate ? (
+        <div
+          key={loopSelectionKey(selectedLoop)}
+          className="mt-3 rounded-xl border border-indigo-300/20 bg-indigo-300/[0.06] p-3"
+          data-testid="rehearsal-loop-boundary-editor"
+        >
+          <div className="flex flex-wrap items-center gap-2">
+            <p className="text-xs font-black uppercase tracking-[0.16em] text-indigo-100">
+              {t("workspaceLoopBoundaryTitle")}
+            </p>
+            <span className="rounded-full border border-indigo-200/20 bg-indigo-200/10 px-2 py-1 text-[0.65rem] font-bold uppercase tracking-[0.14em] text-indigo-100">
+              {t("workspaceLoopBoundaryCorrectionBadge")}
+            </span>
+          </div>
+          <p
+            className={`mt-2 text-xs ${boundaryError ? "text-amber-200" : "text-slate-400"}`}
+            id="rehearsal-loop-boundary-hint"
+          >
+            {boundaryError
+              ? t("workspaceLoopBoundaryError")
+              : t("workspaceLoopBoundaryHint")}
+          </p>
+          <div className="mt-3 flex flex-wrap gap-3">
+            <label className="flex min-w-40 flex-1 flex-col gap-1 text-xs font-semibold text-slate-300">
+              <span>{t("workspaceLoopBoundaryStartLabel")}</span>
+              <input
+                aria-describedby="rehearsal-loop-boundary-hint"
+                aria-invalid={boundaryError}
+                className="min-h-11 rounded-lg border border-white/10 bg-slate-950 px-3 text-sm font-semibold text-slate-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-cyan-300"
+                defaultValue={selectedLoop.startSeconds}
+                id="rehearsal-loop-boundary-start"
+                max={MAX_SECTION_TIME_SECONDS}
+                min={0}
+                onBlur={(event) => handleBoundaryBlur("start", event)}
+                step={1}
+                type="number"
+              />
+            </label>
+            <label className="flex min-w-40 flex-1 flex-col gap-1 text-xs font-semibold text-slate-300">
+              <span>{t("workspaceLoopBoundaryEndLabel")}</span>
+              <input
+                aria-describedby="rehearsal-loop-boundary-hint"
+                aria-invalid={boundaryError}
+                className="min-h-11 rounded-lg border border-white/10 bg-slate-950 px-3 text-sm font-semibold text-slate-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-cyan-300"
+                defaultValue={selectedLoop.endSeconds}
+                id="rehearsal-loop-boundary-end"
+                max={MAX_SECTION_TIME_SECONDS}
+                min={0}
+                onBlur={(event) => handleBoundaryBlur("end", event)}
+                step={1}
+                type="number"
+              />
+            </label>
+          </div>
+        </div>
+      ) : null}
       <div className="mt-3 flex flex-wrap items-center gap-3">
         <label className="flex min-h-11 items-center gap-2 text-xs font-semibold uppercase tracking-[0.16em] text-slate-300">
           <span>{t("workspaceLoopPlaybackRateLabel")}</span>
diff --git a/apps/desktop/src/features/workspace/Workspace.tsx b/apps/desktop/src/features/workspace/Workspace.tsx
index 54842b46b..ce269580a 100644
--- a/apps/desktop/src/features/workspace/Workspace.tsx
+++ b/apps/desktop/src/features/workspace/Workspace.tsx
@@ -375,6 +375,7 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
 
           <RehearsalPlayer
             song={song}
+            onSongUpdate={onSongUpdate}
             hasLocalAudio={hasLocalAudio}
             audioSourcePath={parsedSourceBootstrap?.source.sourcePath ?? null}
             activeRole={resolvedActiveRole}
diff --git a/apps/desktop/src/locales/en/common.json b/apps/desktop/src/locales/en/common.json
index 704b4f00a..133a6ce7f 100644
--- a/apps/desktop/src/locales/en/common.json
+++ b/apps/desktop/src/locales/en/common.json
@@ -154,6 +154,12 @@
   "workspaceLoopSectionPickerLabel": "Playable sections",
   "workspaceLoopSectionPickerForRole": "Playable sections for {roleName}",
   "workspaceLoopSectionKeyboardHint": "Use Left and Right Arrow to move between section cues.",
+  "workspaceLoopBoundaryTitle": "Correct this cue's range",
+  "workspaceLoopBoundaryCorrectionBadge": "Manual cue correction",
+  "workspaceLoopBoundaryStartLabel": "Start time (seconds)",
+  "workspaceLoopBoundaryEndLabel": "End time (seconds)",
+  "workspaceLoopBoundaryHint": "Whole seconds update the song map and are included in the next project save.",
+  "workspaceLoopBoundaryError": "Use whole seconds from 0 to the limit, with the end after the start.",
   "workspaceLoopRoleFilterHint": "Showing sections that include {roleName}.",
   "workspaceLoopNoRoleSections": "No playable sections include {roleName} yet. Choose All Roles or map this role first.",
   "workspaceLoopStart": "Start the count-in",
diff --git a/apps/desktop/src/locales/ko/common.json b/apps/desktop/src/locales/ko/common.json
index 10ca9e4b4..e4151ebbc 100644
--- a/apps/desktop/src/locales/ko/common.json
+++ b/apps/desktop/src/locales/ko/common.json
@@ -154,6 +154,12 @@
   "workspaceLoopSectionPickerLabel": "연습할 구간",
   "workspaceLoopSectionPickerForRole": "{roleName} 역할의 연습 구간",
   "workspaceLoopSectionKeyboardHint": "왼쪽·오른쪽 화살표로 구간 큐를 이동하세요.",
+  "workspaceLoopBoundaryTitle": "이 큐의 구간 보정",
+  "workspaceLoopBoundaryCorrectionBadge": "수동 큐 보정",
+  "workspaceLoopBoundaryStartLabel": "시작 시각(초)",
+  "workspaceLoopBoundaryEndLabel": "끝 시각(초)",
+  "workspaceLoopBoundaryHint": "정수 초로 곡 지도를 보정하며 다음 프로젝트 저장에 포함됩니다.",
+  "workspaceLoopBoundaryError": "0부터 제한값까지의 정수 초를 입력하고 끝을 시작보다 뒤로 두세요.",
   "workspaceLoopRoleFilterHint": "{roleName} 역할이 포함된 구간만 표시합니다.",
   "workspaceLoopNoRoleSections": "{roleName} 역할이 포함된 연습 구간이 아직 없습니다. 전체 보기로 바꾸거나 먼저 역할을 배치하세요.",
   "workspaceLoopStart": "카운트인 시작",

From 81efbe3716632acbbff72626258ef0b09b00fbde Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 06:15:51 +0900
Subject: [PATCH 08/13] fix(player): preserve cue editor focus

---
 .../workspace/RehearsalPlayer.test.tsx        | 25 +++++++++++
 .../features/workspace/RehearsalPlayer.tsx    | 41 +++++++++++++++----
 2 files changed, 59 insertions(+), 7 deletions(-)

diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index 12271ec7a..863945f7c 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { act, fireEvent, render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
 import { createDemoRehearsalSong } from "@bandscope/shared-types";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { RehearsalPlayer } from "./RehearsalPlayer";
@@ -231,6 +232,30 @@ describe("RehearsalPlayer", () => {
     );
   });
 
+  it("keeps focus on the next boundary field after a Tab correction", async () => {
+    setNavigatorLanguage("en-US");
+    const user = userEvent.setup();
+    const song = createDemoRehearsalSong();
+    const onSongUpdate = vi.fn();
+    render(<RehearsalPlayer song={song} onSongUpdate={onSongUpdate} />);
+
+    const start = screen.getByRole("spinbutton", {
+      name: "Start time (seconds)",
+    });
+    const end = screen.getByRole("spinbutton", {
+      name: "End time (seconds)",
+    });
+    await user.click(start);
+    await user.clear(start);
+    await user.type(start, "12");
+    await user.tab();
+
+    expect(end).toHaveFocus();
+    expect(start).toHaveValue(12);
+    expect(onSongUpdate).toHaveBeenCalledTimes(1);
+    expect(onSongUpdate.mock.calls[0]![0].sections[0]!.timeRange.start).toBe(12);
+  });
+
   it("keeps the selected loop by section ID when an earlier section is filtered out", () => {
     setNavigatorLanguage("en-US");
     const song = createDemoRehearsalSong();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index 2af0478c2..1440d990a 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -123,9 +123,18 @@ export function RehearsalPlayer({
     playableLoops.find((loop) => loopSelectionKey(loop) === selectedLoopKey) ??
     playableLoops[0] ??
     null;
+  const selectedBoundaryKey = selectedLoop ? loopSelectionKey(selectedLoop) : null;
+  const [boundaryDraft, setBoundaryDraft] = useState(() => ({
+    end: selectedLoop ? String(selectedLoop.endSeconds) : "",
+    start: selectedLoop ? String(selectedLoop.startSeconds) : "",
+  }));
   useEffect(() => {
     setBoundaryError(false);
-  }, [selectedLoopKey]);
+    setBoundaryDraft({
+      end: selectedLoop ? String(selectedLoop.endSeconds) : "",
+      start: selectedLoop ? String(selectedLoop.startSeconds) : "",
+    });
+  }, [selectedBoundaryKey, selectedLoop?.endSeconds, selectedLoop?.startSeconds]);
   const handleSectionKeyDown = useCallback(
     (event: KeyboardEvent<HTMLButtonElement>) => {
       if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") {
@@ -497,11 +506,14 @@ export function RehearsalPlayer({
           ? value < selectedLoop.endSeconds
           : value > selectedLoop.startSeconds);
       if (!valid) {
-        event.currentTarget.value = String(
+        const currentValue =
           boundary === "start"
             ? selectedLoop.startSeconds
-            : selectedLoop.endSeconds,
-        );
+            : selectedLoop.endSeconds;
+        setBoundaryDraft((current) => ({
+          ...current,
+          [boundary]: String(currentValue),
+        }));
         setBoundaryError(true);
         return;
       }
@@ -512,6 +524,10 @@ export function RehearsalPlayer({
           ? selectedLoop.startSeconds
           : selectedLoop.endSeconds;
       if (value === currentValue) {
+        setBoundaryDraft((current) => ({
+          ...current,
+          [boundary]: String(currentValue),
+        }));
         return;
       }
 
@@ -542,6 +558,10 @@ export function RehearsalPlayer({
         boundary === "start"
           ? { ...selectedLoop, startSeconds: value }
           : { ...selectedLoop, endSeconds: value };
+      setBoundaryDraft((current) => ({
+        ...current,
+        [boundary]: String(value),
+      }));
       setSelectedLoopKey(loopSelectionKey(nextLoop));
       onSongUpdate(nextSong);
     },
@@ -624,7 +644,6 @@ export function RehearsalPlayer({
       ) : null}
       {selectedLoop && onSongUpdate ? (
         <div
-          key={loopSelectionKey(selectedLoop)}
           className="mt-3 rounded-xl border border-indigo-300/20 bg-indigo-300/[0.06] p-3"
           data-testid="rehearsal-loop-boundary-editor"
         >
@@ -651,13 +670,17 @@ export function RehearsalPlayer({
                 aria-describedby="rehearsal-loop-boundary-hint"
                 aria-invalid={boundaryError}
                 className="min-h-11 rounded-lg border border-white/10 bg-slate-950 px-3 text-sm font-semibold text-slate-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-cyan-300"
-                defaultValue={selectedLoop.startSeconds}
                 id="rehearsal-loop-boundary-start"
                 max={MAX_SECTION_TIME_SECONDS}
                 min={0}
                 onBlur={(event) => handleBoundaryBlur("start", event)}
+                onChange={(event) => {
+                  const value = event.currentTarget.value;
+                  setBoundaryDraft((current) => ({ ...current, start: value }));
+                }}
                 step={1}
                 type="number"
+                value={boundaryDraft.start}
               />
             </label>
             <label className="flex min-w-40 flex-1 flex-col gap-1 text-xs font-semibold text-slate-300">
@@ -666,13 +689,17 @@ export function RehearsalPlayer({
                 aria-describedby="rehearsal-loop-boundary-hint"
                 aria-invalid={boundaryError}
                 className="min-h-11 rounded-lg border border-white/10 bg-slate-950 px-3 text-sm font-semibold text-slate-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-cyan-300"
-                defaultValue={selectedLoop.endSeconds}
                 id="rehearsal-loop-boundary-end"
                 max={MAX_SECTION_TIME_SECONDS}
                 min={0}
                 onBlur={(event) => handleBoundaryBlur("end", event)}
+                onChange={(event) => {
+                  const value = event.currentTarget.value;
+                  setBoundaryDraft((current) => ({ ...current, end: value }));
+                }}
                 step={1}
                 type="number"
+                value={boundaryDraft.end}
               />
             </label>
           </div>

From b8a4e1c16663ae10203de5293ad5f8347e81a397 Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 11:11:50 +0900
Subject: [PATCH 09/13] fix(player): preserve duplicate cue identity

---
 .../workspace/RehearsalPlayer.test.tsx        | 37 +++++++++++++++++++
 .../features/workspace/RehearsalPlayer.tsx    | 22 ++++++-----
 ...rsalTransport.descriptor-authority.test.ts |  1 +
 .../features/workspace/rehearsalTransport.ts  | 11 +++++-
 4 files changed, 59 insertions(+), 12 deletions(-)

diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index 863945f7c..9347c693d 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -294,6 +294,43 @@ describe("RehearsalPlayer", () => {
     );
   });
 
+  it("keeps duplicate cue identities distinct for navigation and correction", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const duplicate = {
+      ...song.sections[0]!,
+      label: "verse copy",
+      timeRange: { ...song.sections[0]!.timeRange },
+    };
+    song.sections = [song.sections[0]!, duplicate];
+    const onSongUpdate = vi.fn();
+    render(<RehearsalPlayer song={song} onSongUpdate={onSongUpdate} />);
+
+    const sectionButtons = screen
+      .getAllByRole("button")
+      .filter((button) => button.id.startsWith("rehearsal-loop-section-"));
+    expect(sectionButtons).toHaveLength(2);
+    expect(sectionButtons[0]).toHaveAttribute("aria-pressed", "true");
+    expect(sectionButtons[1]).toHaveAttribute("aria-pressed", "false");
+
+    sectionButtons[0]!.focus();
+    fireEvent.keyDown(sectionButtons[0]!, { key: "ArrowRight" });
+
+    expect(sectionButtons[1]).toHaveFocus();
+    expect(sectionButtons[0]).toHaveAttribute("aria-pressed", "false");
+    expect(sectionButtons[1]).toHaveAttribute("aria-pressed", "true");
+
+    const start = screen.getByRole("spinbutton", {
+      name: "Start time (seconds)",
+    });
+    fireEvent.change(start, { target: { value: "12" } });
+    fireEvent.blur(start);
+
+    expect(onSongUpdate).toHaveBeenCalledTimes(1);
+    expect(onSongUpdate.mock.calls[0]![0].sections[0]!.timeRange.start).toBe(10);
+    expect(onSongUpdate.mock.calls[0]![0].sections[1]!.timeRange.start).toBe(12);
+  });
+
   it("explains when the active role has no playable sections", () => {
     setNavigatorLanguage("en-US");
     const song = createDemoRehearsalSong();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index 1440d990a..470c02f2c 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -89,6 +89,7 @@ function hasSameLoopTiming(
   next: RehearsalLoopWindow,
 ): boolean {
   return (
+    current.sourceIndex === next.sourceIndex &&
     current.sectionId === next.sectionId &&
     current.startSeconds === next.startSeconds &&
     current.endSeconds === next.endSeconds &&
@@ -99,7 +100,7 @@ function hasSameLoopTiming(
 
 /** Return a stable selection key when analysis emits duplicate section IDs. */
 function loopSelectionKey(loop: RehearsalLoopWindow): string {
-  return `${loop.sectionId}:${loop.startSeconds}:${loop.endSeconds}`;
+  return String(loop.sourceIndex);
 }
 
 /** Render tonight's first section loop with a count-in and a named next action. */
@@ -531,18 +532,19 @@ export function RehearsalPlayer({
         return;
       }
 
-      const sectionIndex = song.sections.findIndex(
-        (section) =>
-          section.id === selectedLoop.sectionId &&
-          section.timeRange.start === selectedLoop.startSeconds &&
-          section.timeRange.end === selectedLoop.endSeconds,
-      );
-      if (sectionIndex < 0) {
+      const sectionIndex = selectedLoop.sourceIndex;
+      const section = song.sections[sectionIndex];
+      if (
+        !section ||
+        section.id !== selectedLoop.sectionId ||
+        section.timeRange.start !== selectedLoop.startSeconds ||
+        section.timeRange.end !== selectedLoop.endSeconds
+      ) {
         return;
       }
       const nextSong = {
         ...song,
-        sections: song.sections.map((section, index) =>
+        sections: song.sections.map((currentSection, index) =>
           index === sectionIndex
             ? {
                 ...section,
@@ -551,7 +553,7 @@ export function RehearsalPlayer({
                   [boundary]: value,
                 },
               }
-            : section,
+            : currentSection,
         ),
       };
       const nextLoop =
diff --git a/apps/desktop/src/features/workspace/rehearsalTransport.descriptor-authority.test.ts b/apps/desktop/src/features/workspace/rehearsalTransport.descriptor-authority.test.ts
index ae892fc3f..aeee51ac0 100644
--- a/apps/desktop/src/features/workspace/rehearsalTransport.descriptor-authority.test.ts
+++ b/apps/desktop/src/features/workspace/rehearsalTransport.descriptor-authority.test.ts
@@ -25,6 +25,7 @@ describe("rehearsal transport descriptor authority", () => {
     });
 
     expect(createLoopWindow(proxiedSection, song.tempo)).toEqual({
+      sourceIndex: 0,
       sectionId: expectedId,
       sectionLabel: expectedLabel,
       startSeconds: expectedRange.start,
diff --git a/apps/desktop/src/features/workspace/rehearsalTransport.ts b/apps/desktop/src/features/workspace/rehearsalTransport.ts
index 5cc0e9899..2fed6ffa7 100644
--- a/apps/desktop/src/features/workspace/rehearsalTransport.ts
+++ b/apps/desktop/src/features/workspace/rehearsalTransport.ts
@@ -27,6 +27,7 @@ export type RehearsalTransportPhase =
 
 /** Bounded loop window derived from one valid analyzed section. */
 export interface RehearsalLoopWindow {
+  sourceIndex: number;
   sectionId: string;
   sectionLabel: string;
   startSeconds: number;
@@ -230,6 +231,7 @@ export function formatRehearsalClock(totalSeconds: number): string {
 export function createLoopWindow(
   section: RehearsalSection,
   tempo: unknown,
+  sourceIndex = 0,
 ): RehearsalLoopWindow | null {
   const snapshot = playableSectionSnapshot(section);
   if (!snapshot) {
@@ -237,6 +239,7 @@ export function createLoopWindow(
   }
   const { tempoBpm, tempoAssumed } = resolveRehearsalTempo(tempo);
   return {
+    sourceIndex,
     sectionId: snapshot.id,
     sectionLabel: snapshot.label,
     startSeconds: snapshot.startSeconds,
@@ -262,14 +265,18 @@ export function resolveLoopWindows(
   const tempo = ownDataValue(song, "tempo");
   const selectedRoleId =
     typeof roleId === "string" && roleId.trim() ? roleId : null;
-  return sections.flatMap((section) => {
+  return sections.flatMap((section, sourceIndex) => {
     if (!section || typeof section !== "object") {
       return [];
     }
     if (selectedRoleId && !sectionContainsRole(section, selectedRoleId)) {
       return [];
     }
-    const window = createLoopWindow(section as RehearsalSection, tempo);
+    const window = createLoopWindow(
+      section as RehearsalSection,
+      tempo,
+      sourceIndex,
+    );
     return window ? [window] : [];
   });
 }

From b96e4549ef87b899fa7b784a6458bb2860bff53d Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 11:21:57 +0900
Subject: [PATCH 10/13] fix(player): preserve cue selection across edits

---
 .../workspace/RehearsalPlayer.test.tsx        | 46 +++++++++++++++++++
 .../features/workspace/RehearsalPlayer.tsx    |  7 +--
 ...rsalTransport.descriptor-authority.test.ts |  1 +
 .../features/workspace/rehearsalTransport.ts  | 28 +++++++++--
 4 files changed, 76 insertions(+), 6 deletions(-)

diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index 9347c693d..1e638a334 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -331,6 +331,52 @@ describe("RehearsalPlayer", () => {
     expect(onSongUpdate.mock.calls[0]![0].sections[1]!.timeRange.start).toBe(12);
   });
 
+  it("preserves the selected cue when an earlier section is inserted", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const chorus = structuredClone(song.sections[0]!);
+    chorus.id = "chorus-1";
+    chorus.label = "chorus";
+    chorus.timeRange = { start: 40, end: 64 };
+    song.sections = [song.sections[0]!, chorus];
+    const onSongUpdate = vi.fn();
+    const { rerender } = render(
+      <RehearsalPlayer song={song} onSongUpdate={onSongUpdate} />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: /chorus/i }));
+    const inserted = structuredClone(song.sections[0]!);
+    inserted.id = "intro-1";
+    inserted.label = "intro";
+    inserted.timeRange = { start: 0, end: 5 };
+    const updatedSong = { ...song, sections: [inserted, ...song.sections] };
+    rerender(
+      <RehearsalPlayer song={updatedSong} onSongUpdate={onSongUpdate} />,
+    );
+
+    const chorusButton = screen.getByRole("button", { name: /chorus/i });
+    expect(chorusButton).toHaveAttribute("aria-pressed", "true");
+    const start = screen.getByRole("spinbutton", {
+      name: "Start time (seconds)",
+    });
+    fireEvent.change(start, { target: { value: "42" } });
+    fireEvent.blur(start);
+
+    expect(onSongUpdate).toHaveBeenCalledTimes(1);
+    expect(onSongUpdate.mock.calls[0]![0].sections[1]!.timeRange.start).toBe(10);
+    expect(onSongUpdate.mock.calls[0]![0].sections[2]!.timeRange.start).toBe(42);
+    rerender(
+      <RehearsalPlayer
+        song={onSongUpdate.mock.calls[0]![0]}
+        onSongUpdate={onSongUpdate}
+      />,
+    );
+    expect(screen.getByRole("button", { name: /chorus/i })).toHaveAttribute(
+      "aria-pressed",
+      "true",
+    );
+  });
+
   it("explains when the active role has no playable sections", () => {
     setNavigatorLanguage("en-US");
     const song = createDemoRehearsalSong();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index 470c02f2c..880c215fb 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -89,7 +89,7 @@ function hasSameLoopTiming(
   next: RehearsalLoopWindow,
 ): boolean {
   return (
-    current.sourceIndex === next.sourceIndex &&
+    current.selectionKey === next.selectionKey &&
     current.sectionId === next.sectionId &&
     current.startSeconds === next.startSeconds &&
     current.endSeconds === next.endSeconds &&
@@ -100,7 +100,7 @@ function hasSameLoopTiming(
 
 /** Return a stable selection key when analysis emits duplicate section IDs. */
 function loopSelectionKey(loop: RehearsalLoopWindow): string {
-  return String(loop.sourceIndex);
+  return loop.selectionKey;
 }
 
 /** Render tonight's first section loop with a count-in and a named next action. */
@@ -261,7 +261,8 @@ export function RehearsalPlayer({
       ) {
         if (
           current.loop.sectionLabel === selectedLoop.sectionLabel &&
-          current.loop.tempoAssumed === selectedLoop.tempoAssumed
+          current.loop.tempoAssumed === selectedLoop.tempoAssumed &&
+          current.loop.sourceIndex === selectedLoop.sourceIndex
         ) {
           return current;
         }
diff --git a/apps/desktop/src/features/workspace/rehearsalTransport.descriptor-authority.test.ts b/apps/desktop/src/features/workspace/rehearsalTransport.descriptor-authority.test.ts
index aeee51ac0..219b32724 100644
--- a/apps/desktop/src/features/workspace/rehearsalTransport.descriptor-authority.test.ts
+++ b/apps/desktop/src/features/workspace/rehearsalTransport.descriptor-authority.test.ts
@@ -26,6 +26,7 @@ describe("rehearsal transport descriptor authority", () => {
 
     expect(createLoopWindow(proxiedSection, song.tempo)).toEqual({
       sourceIndex: 0,
+      selectionKey: JSON.stringify([expectedId, 0]),
       sectionId: expectedId,
       sectionLabel: expectedLabel,
       startSeconds: expectedRange.start,
diff --git a/apps/desktop/src/features/workspace/rehearsalTransport.ts b/apps/desktop/src/features/workspace/rehearsalTransport.ts
index 2fed6ffa7..ac689e10e 100644
--- a/apps/desktop/src/features/workspace/rehearsalTransport.ts
+++ b/apps/desktop/src/features/workspace/rehearsalTransport.ts
@@ -28,6 +28,7 @@ export type RehearsalTransportPhase =
 /** Bounded loop window derived from one valid analyzed section. */
 export interface RehearsalLoopWindow {
   sourceIndex: number;
+  selectionKey: string;
   sectionId: string;
   sectionLabel: string;
   startSeconds: number;
@@ -240,6 +241,10 @@ export function createLoopWindow(
   const { tempoBpm, tempoAssumed } = resolveRehearsalTempo(tempo);
   return {
     sourceIndex,
+    selectionKey: JSON.stringify([
+      snapshot.id,
+      0,
+    ]),
     sectionId: snapshot.id,
     sectionLabel: snapshot.label,
     startSeconds: snapshot.startSeconds,
@@ -265,19 +270,36 @@ export function resolveLoopWindows(
   const tempo = ownDataValue(song, "tempo");
   const selectedRoleId =
     typeof roleId === "string" && roleId.trim() ? roleId : null;
+  const selectionOrdinals = new Map<string, number>();
   return sections.flatMap((section, sourceIndex) => {
     if (!section || typeof section !== "object") {
       return [];
     }
-    if (selectedRoleId && !sectionContainsRole(section, selectedRoleId)) {
-      return [];
+    const sectionId = ownDataValue(section, "id");
+    const ordinal =
+      typeof sectionId === "string"
+        ? (selectionOrdinals.get(sectionId) ?? 0)
+        : 0;
+    if (typeof sectionId === "string") {
+      selectionOrdinals.set(sectionId, ordinal + 1);
     }
     const window = createLoopWindow(
       section as RehearsalSection,
       tempo,
       sourceIndex,
     );
-    return window ? [window] : [];
+    if (!window) {
+      return [];
+    }
+    if (selectedRoleId && !sectionContainsRole(section, selectedRoleId)) {
+      return [];
+    }
+    return [
+      {
+        ...window,
+        selectionKey: JSON.stringify([window.sectionId, ordinal]),
+      },
+    ];
   });
 }
 

From b8b4241ae723d25c47dfa72f0261ad9fea58418f Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 11:41:50 +0900
Subject: [PATCH 11/13] fix(player): preserve count-in timing across rate
 changes

---
 .../workspace/RehearsalPlayer.test.tsx        | 44 ++++++++++++++
 .../features/workspace/RehearsalPlayer.tsx    | 57 ++++++++++++++++---
 .../features/workspace/rehearsalTransport.ts  |  2 +-
 3 files changed, 95 insertions(+), 8 deletions(-)

diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index 1e638a334..caa3bdafc 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -672,6 +672,9 @@ describe("RehearsalPlayer", () => {
     fireEvent.click(
       screen.getByRole("button", { name: /Start the count-in/i }),
     );
+    expect(
+      screen.getByTestId("rehearsal-loop-next-action").textContent,
+    ).toMatch(/Count in 4 beats at 150 BPM/i);
     act(() => {
       vi.advanceTimersByTime(1600);
     });
@@ -688,6 +691,47 @@ describe("RehearsalPlayer", () => {
     );
   });
 
+  it("keeps the remaining count-in beat when playback rate changes", () => {
+    setNavigatorLanguage("en-US");
+    vi.useFakeTimers();
+    installPlayableAudioMocks();
+    const song = createDemoRehearsalSong();
+
+    render(
+      <RehearsalPlayer
+        song={song}
+        hasLocalAudio={true}
+        audioSourcePath={audioSourcePath}
+      />,
+    );
+    fireEvent.click(
+      screen.getByRole("button", { name: /Start the count-in/i }),
+    );
+    act(() => {
+      vi.advanceTimersByTime(400);
+    });
+
+    fireEvent.change(screen.getByRole("combobox", { name: /Playback speed/i }), {
+      target: { value: "0.75" },
+    });
+    expect(
+      screen.getByTestId("rehearsal-loop-next-action").textContent,
+    ).toMatch(/Count in 4 beats at 90 BPM/i);
+
+    act(() => {
+      vi.advanceTimersByTime(133);
+    });
+    expect(
+      screen.getByTestId("rehearsal-loop-next-action").textContent,
+    ).toMatch(/Count in 4 beats at 90 BPM/i);
+    act(() => {
+      vi.advanceTimersByTime(1);
+    });
+    expect(
+      screen.getByTestId("rehearsal-loop-next-action").textContent,
+    ).toMatch(/Count in 3 beats at 90 BPM/i);
+  });
+
   it("applies supported playback speed while preserving pitch when available", () => {
     setNavigatorLanguage("en-US");
     const { play } = installPlayableAudioMocks();
diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
index 880c215fb..bf420cd91 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.tsx
@@ -179,6 +179,11 @@ export function RehearsalPlayer({
   );
   const lastHandledStartNonce = useRef(0);
   const restartAudioOnLoopRef = useRef(false);
+  const countInBeatRef = useRef<{
+    durationMs: number;
+    startedAt: number;
+    remainingBeats: number;
+  } | null>(null);
   const audioRef = useRef<HTMLAudioElement>(null);
   const audioSourceUrl = useMemo(
     () => resolveAudioSourceUrl(audioSourcePath),
@@ -330,15 +335,53 @@ export function RehearsalPlayer({
 
   useEffect(() => {
     if (transport.phase !== "counting-in" || !transport.loop) {
+      countInBeatRef.current = null;
       return undefined;
     }
-    const timer = window.setInterval(() => {
-      setTransport((current) =>
-        reduceRehearsalTransport(current, { type: "beat" }),
-      );
-    }, beatDurationMs(transport.loop.tempoBpm) / transport.playbackRate);
-    return () => window.clearInterval(timer);
-  }, [transport.phase, transport.loop, transport.playbackRate]);
+    const durationMs =
+      beatDurationMs(transport.loop.tempoBpm) / transport.playbackRate;
+    const now = performance.now();
+    const previous = countInBeatRef.current;
+    const sameBeat =
+      previous?.remainingBeats === transport.countInRemainingBeats;
+    const elapsedMs = sameBeat
+      ? Math.max(0, now - previous.startedAt)
+      : 0;
+    const progress = sameBeat
+      ? Math.min(1, elapsedMs / previous.durationMs)
+      : 0;
+    countInBeatRef.current = {
+      durationMs,
+      startedAt: now,
+      remainingBeats: transport.countInRemainingBeats,
+    };
+    let timer: number | undefined;
+    /** Schedule the next count-in beat without coupling it to React commits. */
+    const scheduleBeat = (delayMs: number) => {
+      timer = window.setTimeout(() => {
+        const current = countInBeatRef.current;
+        if (!current || current.remainingBeats <= 0) {
+          return;
+        }
+        current.remainingBeats -= 1;
+        setTransport((state) => reduceRehearsalTransport(state, { type: "beat" }));
+        if (current.remainingBeats > 0) {
+          current.startedAt = performance.now();
+          scheduleBeat(current.durationMs);
+        }
+      }, delayMs);
+    };
+    scheduleBeat(Math.ceil(Math.max(0, durationMs * (1 - progress))));
+    return () => {
+      if (timer !== undefined) {
+        window.clearTimeout(timer);
+      }
+    };
+  }, [
+    transport.loop,
+    transport.phase,
+    transport.playbackRate,
+  ]);
 
   useEffect(() => {
     if (!audioSourceUrl || !transport.loop) {
diff --git a/apps/desktop/src/features/workspace/rehearsalTransport.ts b/apps/desktop/src/features/workspace/rehearsalTransport.ts
index ac689e10e..c7689ab0b 100644
--- a/apps/desktop/src/features/workspace/rehearsalTransport.ts
+++ b/apps/desktop/src/features/workspace/rehearsalTransport.ts
@@ -503,6 +503,6 @@ export function nextActionValues(
     start: formatRehearsalClock(state.loop.startSeconds),
     end: formatRehearsalClock(state.loop.endSeconds),
     beats: String(state.countInRemainingBeats || state.loop.countInBeats),
-    tempo: String(state.loop.tempoBpm),
+    tempo: String(state.loop.tempoBpm * state.playbackRate),
   };
 }

From 826b1df416bf3da31b3715ea556a13b0f5111863 Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 11:43:59 +0900
Subject: [PATCH 12/13] docs: align agent guidance with playback rate

---
 AGENTS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/AGENTS.md b/AGENTS.md
index 55023b6a2..431188c83 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -3,7 +3,7 @@
 ## Project overview
 
 - BandScope is a local-first desktop app for rehearsal prep: a practical song view with likely harmony by section and by instrument or vocal role, form and groove cues, stems, playable ranges, simplification guidance, transposition or setup cues, part-overlap cues, visible confidence, and rehearsal priorities.
-- The ready workspace must name a next rehearsal action. Tonight's first playable section loop (count-in, pause, stop) is the #961 transport slice; stem playback and pitch-preserving rate remain later work.
+- The ready workspace must name a next rehearsal action. Tonight's first playable section loop (count-in, pause, stop) is the #961 transport slice; #1063 adds bounded pitch-preserving playback rate, while stem playback remains later work.
 - Authoritative delivery rules live in `ARCHITECTURE.md`, `docs/plans/`, and the root verification scripts.
 - Brand, tone, UX copy, and prioritization rules live in `docs/brand-story.md` and must be applied to PRDs, TRDs, UI copy, onboarding, empty states, and error messages.
 - App security rules live in `docs/security/app-security.md` and must be applied to file handling, URL intake, subprocesses, IPC, WebView usage, model loading, updates, logging, cache handling, and export behavior.

From d99c9358b4c7bdcbf7d090c287b40d8104f97ade Mon Sep 17 00:00:00 2001
From: seonghobae <me@seonghobae.me>
Date: Sun, 30 Aug 2026 11:49:04 +0900
Subject: [PATCH 13/13] test(player): cover repeated count-in rate changes

---
 .../features/workspace/RehearsalPlayer.test.tsx  | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
index caa3bdafc..0cae5a010 100644
--- a/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
+++ b/apps/desktop/src/features/workspace/RehearsalPlayer.test.tsx
@@ -719,17 +719,27 @@ describe("RehearsalPlayer", () => {
     ).toMatch(/Count in 4 beats at 90 BPM/i);
 
     act(() => {
-      vi.advanceTimersByTime(133);
+      vi.advanceTimersByTime(50);
+    });
+    fireEvent.change(screen.getByRole("combobox", { name: /Playback speed/i }), {
+      target: { value: "1.25" },
     });
     expect(
       screen.getByTestId("rehearsal-loop-next-action").textContent,
-    ).toMatch(/Count in 4 beats at 90 BPM/i);
+    ).toMatch(/Count in 4 beats at 150 BPM/i);
+
+    act(() => {
+      vi.advanceTimersByTime(369);
+    });
+    expect(
+      screen.getByTestId("rehearsal-loop-next-action").textContent,
+    ).toMatch(/Count in 4 beats at 150 BPM/i);
     act(() => {
       vi.advanceTimersByTime(1);
     });
     expect(
       screen.getByTestId("rehearsal-loop-next-action").textContent,
-    ).toMatch(/Count in 3 beats at 90 BPM/i);
+    ).toMatch(/Count in 3 beats at 150 BPM/i);
   });
 
   it("applies supported playback speed while preserving pitch when available", () => {