diff --git a/AGENTS.md b/AGENTS.md
index b9a67ce17..b43b4bce4 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,7 +1,7 @@
 # AGENTS.md
 
 ## 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.
+- 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. After a named part is selected, the ready workspace names that part's first trusted simplification as the next first-pass take.
 - 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.
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index ca0df5ac4..ab017e911 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -83,6 +83,7 @@ Last updated: 2026-03-11
   - section roadmap with entries, dropouts, pickups, stops, tags, and handoffs
   - groove and timing cues relevant to locking the band together
   - playable ranges and density or overlap warnings, with the ready workspace naming tonight's first span and the next instrument check
+  - the selected part's first trusted simplification as the next first-pass take
   - simplification, transposition, capo, tuning, or setup cues where applicable
   - role-specific rehearsal priorities and confidence flags
   - cue-sheet or chart-style exports that summarize the analysis in rehearsal-friendly form
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0b6f7e784..2bb4bc004 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Added
 
+- After a named part is selected, name that part's first trusted simplification and tell the player to play that simpler take before adding the rest.
 - 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.
 - 각 합주 역할(Role)별 개인 연습 진행도를 0~100% 범위로 기록 및 시각화할 수 있는 연습 진척도(`practiceProgress`) 트래커 기능 추가. UI 컨트롤(슬라이더 및 +/- 버튼)과 한/영 다국어 지원 포함.
diff --git a/CLAUDE.md b/CLAUDE.md
index b5a34c1fa..153a47c3e 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -51,7 +51,7 @@ BandScope is a local-first desktop app for rehearsal prep: it turns a song into
 
 Three layers, decoupled through shared contracts:
 
-- `apps/desktop` — Tauri 2 + Vite + React 19 shell (Tailwind 4, Base UI, Storybook). Feature screens live in `src/features/` (home, workspace, chords, ranges, player, settings). The ready workspace names tonight's first playable range and the next instrument check. `src/lib/analysis.ts` and `src/lib/job_runner.ts` call typed Tauri IPC commands, with a browser fallback that serves demo data when not running inside Tauri.
+- `apps/desktop` — Tauri 2 + Vite + React 19 shell (Tailwind 4, Base UI, Storybook). Feature screens live in `src/features/` (home, workspace, chords, ranges, player, settings). The ready workspace names tonight's first playable range and the next instrument check. After a named part is selected, it also names that part's first trusted simplification as the next first-pass take. `src/lib/analysis.ts` and `src/lib/job_runner.ts` call typed Tauri IPC commands, with a browser fallback that serves demo data when not running inside Tauri.
 - `apps/desktop/src-tauri/src/main.rs` — the Rust orchestration boundary. Tauri commands (`start_analysis_job`, `get_analysis_job_status`, `select_local_audio_source`, `import_youtube_url`) validate untrusted input (project IDs, file paths, URLs) and spawn the Python engine as a subprocess. There is no loopback HTTP listener and no network path for local analysis.
 - `services/analysis-engine` — Python package `bandscope_analysis` (librosa/numpy). Entry point `cli.py` reads a JSON job request on stdin and prints a structured job-status JSON envelope on stdout (`--progress-jsonl` streams progress lines). `api.py` orchestrates the pipeline across the `separation`, `sections`, `roles`, `chords`, `ranges`, `temporal`, `transcription`, and `youtube` modules.
 
diff --git a/apps/desktop/src/features/workspace/Workspace.first-pass.test.tsx b/apps/desktop/src/features/workspace/Workspace.first-pass.test.tsx
new file mode 100644
index 000000000..8dee9a185
--- /dev/null
+++ b/apps/desktop/src/features/workspace/Workspace.first-pass.test.tsx
@@ -0,0 +1,78 @@
+import { fireEvent, render, screen } from "@testing-library/react";
+import { createDemoRehearsalSong } from "@bandscope/shared-types";
+import { afterEach, describe, expect, it } from "vitest";
+import { Workspace } from "./Workspace";
+
+const originalLanguage = navigator.language;
+
+function setNavigatorLanguage(language: string) {
+  Object.defineProperty(navigator, "language", {
+    configurable: true,
+    value: language
+  });
+}
+
+describe("Workspace selected-part first-pass take", () => {
+  afterEach(() => {
+    setNavigatorLanguage(originalLanguage);
+  });
+
+  it("hides the first-pass take until a named part is selected", () => {
+    setNavigatorLanguage("en-US");
+    render(<Workspace song={createDemoRehearsalSong()} />);
+
+    expect(screen.queryByTestId("selected-part-first-pass")).toBeNull();
+  });
+
+  it("names the selected bass part's simpler take as the first pass", () => {
+    setNavigatorLanguage("en-US");
+    render(<Workspace song={createDemoRehearsalSong()} />);
+    fireEvent.click(screen.getByRole("tab", { name: "Bass Guitar" }));
+
+    const callout = screen.getByTestId("selected-part-first-pass");
+    expect(callout).toHaveTextContent("Tonight's first-pass take");
+    expect(callout).toHaveTextContent(
+      "First pass for Bass Guitar in verse: Stay on roots if the chorus entrance gets muddy. Play that simpler take before adding the rest."
+    );
+  });
+
+  it("names the selected vocal part's simpler take as the first pass", () => {
+    setNavigatorLanguage("en-US");
+    render(<Workspace song={createDemoRehearsalSong()} />);
+    fireEvent.click(screen.getByRole("tab", { name: "Lead Vocal" }));
+
+    expect(screen.getByTestId("selected-part-first-pass")).toHaveTextContent(
+      "First pass for Lead Vocal in verse: Keep the sustained note centered; skip the ad-lib on the first pass. Play that simpler take before adding the rest."
+    );
+  });
+
+  it("keeps Korean copy particle-safe for a Latin role name", () => {
+    setNavigatorLanguage("ko-KR");
+    render(<Workspace song={createDemoRehearsalSong()} />);
+    fireEvent.click(screen.getByRole("tab", { name: "Bass Guitar" }));
+
+    const callout = screen.getByTestId("selected-part-first-pass");
+    expect(callout).toHaveTextContent("오늘 이 파트의 첫 간소화");
+    expect(callout).toHaveTextContent("Bass Guitar 파트");
+    expect(callout).not.toHaveTextContent("Bass Guitar으로");
+    expect(callout).toHaveTextContent(
+      "verse에서 Bass Guitar 파트의 첫 패스: Stay on roots if the chorus entrance gets muddy. 나머지를 더하기 전에 그 간소화된 버전으로 연습하세요."
+    );
+  });
+
+  it("tells the player to confirm a missing first-pass take instead of hiding the next action", () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.roles[0] = {
+      ...song.sections[0]!.roles[0]!,
+      simplification: "none"
+    };
+
+    render(<Workspace song={song} />);
+    fireEvent.click(screen.getByRole("tab", { name: "Bass Guitar" }));
+
+    expect(screen.getByTestId("selected-part-first-pass")).toHaveTextContent(
+      "This part still needs a trusted first-pass take. Confirm the simpler version before the first run."
+    );
+  });
+});
diff --git a/apps/desktop/src/features/workspace/Workspace.tsx b/apps/desktop/src/features/workspace/Workspace.tsx
index d44e20777..515fcd8b8 100644
--- a/apps/desktop/src/features/workspace/Workspace.tsx
+++ b/apps/desktop/src/features/workspace/Workspace.tsx
@@ -5,6 +5,7 @@ import { SectionRoadmap } from "./SectionRoadmap";
 import { GrooveMap } from "./GrooveMap";
 import { PracticeProgress } from "./PracticeProgress";
 import { fillRangeCopy, firstRangeSqueeze } from "./firstRangeSqueeze";
+import { fillFirstPassCopy, firstPassSimplification } from "./firstPassSimplification";
 import { createTranslator, detectPreferredLocale } from "../../i18n";
 import { generateCueSheetCsv, generateChartSummaryJson, generateMetadataHandoffJson, sanitizeFilename } from "../../lib/export";
 import { Button } from "@/components/ui/button";
@@ -163,6 +164,18 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
         }
       )
     : t("workspaceFirstRangeMissing");
+  const selectedFirstPass = useMemo(
+    () => (activeRole ? firstPassSimplification(song, activeRole) : null),
+    [activeRole, song]
+  );
+  const selectedFirstPassCopy =
+    selectedFirstPass?.status === "ready"
+      ? fillFirstPassCopy(t("workspaceSelectedFirstPassReady"), {
+          roleName: selectedFirstPass.roleName,
+          sectionLabel: selectedFirstPass.sectionLabel,
+          value: selectedFirstPass.value
+        })
+      : t("workspaceSelectedFirstPassUnavailable");
 
   /** Handle the practice progress change internally by immutably updating the song state. */
   const handlePracticeProgressChange = (newProgress: number) => {
@@ -372,6 +385,16 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
               <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>
+                <section
+                  className="mt-3 rounded-xl border border-indigo-300/20 bg-indigo-300/[0.08] p-3"
+                  data-testid="selected-part-first-pass"
+                  aria-label={t("workspaceSelectedFirstPassTitle")}
+                >
+                  <p className="text-[0.7rem] font-black uppercase tracking-[0.22em] text-indigo-100">
+                    {t("workspaceSelectedFirstPassTitle")}
+                  </p>
+                  <p className="mt-2 text-sm leading-6 text-slate-100">{selectedFirstPassCopy}</p>
+                </section>
                 <div className="mt-3 flex flex-wrap gap-2">
                   <Button
                     type="button"
diff --git a/apps/desktop/src/features/workspace/firstPassSimplification.test.ts b/apps/desktop/src/features/workspace/firstPassSimplification.test.ts
new file mode 100644
index 000000000..909cd2fab
--- /dev/null
+++ b/apps/desktop/src/features/workspace/firstPassSimplification.test.ts
@@ -0,0 +1,212 @@
+import { createDemoRehearsalSong, type RehearsalRole, type RehearsalSong } from "@bandscope/shared-types";
+import { describe, expect, it } from "vitest";
+import { fillFirstPassCopy, firstPassSimplification } from "./firstPassSimplification";
+
+/** Return the demo song with one role replaced in every section it appears. */
+function withRolePatch(
+  song: RehearsalSong,
+  roleId: string,
+  patch: (role: RehearsalRole) => RehearsalRole
+): RehearsalSong {
+  return {
+    ...song,
+    sections: song.sections.map((section) => ({
+      ...section,
+      roles: section.roles.map((role) => (role.id === roleId ? patch(role) : role))
+    }))
+  };
+}
+
+describe("firstPassSimplification", () => {
+  it("names the selected bass part's first-pass take", () => {
+    expect(firstPassSimplification(createDemoRehearsalSong(), "bass-guitar")).toEqual({
+      status: "ready",
+      value: "Stay on roots if the chorus entrance gets muddy.",
+      sectionLabel: "verse",
+      roleName: "Bass Guitar"
+    });
+  });
+
+  it("names the selected keys part's first-pass take", () => {
+    expect(firstPassSimplification(createDemoRehearsalSong(), "keys-right")).toEqual({
+      status: "ready",
+      value: "Drop the top extension if the chorus turnaround still feels busy.",
+      sectionLabel: "verse",
+      roleName: "Keyboard 1 Right Hand"
+    });
+  });
+
+  it("names the selected vocal part's first-pass take", () => {
+    expect(firstPassSimplification(createDemoRehearsalSong(), "lead-vocal")).toEqual({
+      status: "ready",
+      value: "Keep the sustained note centered; skip the ad-lib on the first pass.",
+      sectionLabel: "verse",
+      roleName: "Lead Vocal"
+    });
+  });
+
+  it("fails closed without a selected named part", () => {
+    expect(firstPassSimplification(createDemoRehearsalSong(), null)).toEqual({ status: "unavailable" });
+    expect(firstPassSimplification(createDemoRehearsalSong(), "   ")).toEqual({ status: "unavailable" });
+    expect(firstPassSimplification(createDemoRehearsalSong(), "none")).toEqual({ status: "unavailable" });
+  });
+
+  it("fails closed on blank, none, or missing simplification values", () => {
+    const blank = withRolePatch(createDemoRehearsalSong(), "bass-guitar", (role) => ({
+      ...role,
+      simplification: "  "
+    }));
+    const none = withRolePatch(createDemoRehearsalSong(), "lead-vocal", (role) => ({
+      ...role,
+      simplification: "none"
+    }));
+    const missing = withRolePatch(createDemoRehearsalSong(), "keys-right", (role) => {
+      const { simplification: _dropped, ...withoutSimplification } = role;
+      void _dropped;
+      return withoutSimplification as RehearsalRole;
+    });
+
+    expect(firstPassSimplification(blank, "bass-guitar")).toEqual({ status: "unavailable" });
+    expect(firstPassSimplification(none, "lead-vocal")).toEqual({ status: "unavailable" });
+    expect(firstPassSimplification(missing, "keys-right")).toEqual({ status: "unavailable" });
+  });
+
+  it("fails closed when simplification is inherited instead of owned", () => {
+    const song = createDemoRehearsalSong();
+    const role = { ...song.sections[0]!.roles[0]! };
+    const { simplification: _dropped, ...withoutSimplification } = role;
+    void _dropped;
+    Object.setPrototypeOf(withoutSimplification, { simplification: "sneaky roots only" });
+    song.sections[0] = {
+      ...song.sections[0]!,
+      roles: [withoutSimplification as RehearsalRole, ...song.sections[0]!.roles.slice(1)]
+    };
+
+    expect(firstPassSimplification(song, "bass-guitar")).toEqual({ status: "unavailable" });
+  });
+
+  it("fails closed on a malformed song root", () => {
+    expect(firstPassSimplification(null, "bass-guitar")).toEqual({ status: "unavailable" });
+    expect(firstPassSimplification({ title: "no sections" }, "bass-guitar")).toEqual({
+      status: "unavailable"
+    });
+  });
+
+  it("fails closed on a malformed section member", () => {
+    const song = createDemoRehearsalSong();
+    song.sections = [null as unknown as RehearsalSong["sections"][number], ...song.sections];
+
+    expect(firstPassSimplification(song, "bass-guitar")).toEqual({ status: "unavailable" });
+  });
+
+  it("fails closed when a section omits roles or a role omits identity", () => {
+    const missingRoles = createDemoRehearsalSong();
+    const { roles: _droppedRoles, ...sectionWithoutRoles } = missingRoles.sections[0]!;
+    void _droppedRoles;
+    missingRoles.sections[0] = sectionWithoutRoles as RehearsalSong["sections"][number];
+
+    const missingRoleIdentity = createDemoRehearsalSong();
+    const { id: _droppedId, ...roleWithoutId } = missingRoleIdentity.sections[0]!.roles[0]!;
+    void _droppedId;
+    missingRoleIdentity.sections[0] = {
+      ...missingRoleIdentity.sections[0]!,
+      roles: [roleWithoutId as RehearsalRole, ...missingRoleIdentity.sections[0]!.roles.slice(1)]
+    };
+
+    expect(firstPassSimplification(missingRoles, "bass-guitar")).toEqual({ status: "unavailable" });
+    expect(firstPassSimplification(missingRoleIdentity, "bass-guitar")).toEqual({
+      status: "unavailable"
+    });
+  });
+
+  it("fails closed on duplicate role ids in one section", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0] = {
+      ...song.sections[0]!,
+      roles: [...song.sections[0]!.roles, { ...song.sections[0]!.roles[0]! }]
+    };
+
+    expect(firstPassSimplification(song, "bass-guitar")).toEqual({ status: "unavailable" });
+  });
+
+  it("fails closed when the same selected id uses two display names", () => {
+    const song = createDemoRehearsalSong();
+    const verse = song.sections[0]!;
+    song.sections = [
+      verse,
+      {
+        ...verse,
+        id: "chorus-1",
+        label: "chorus",
+        roles: verse.roles.map((role) =>
+          role.id === "bass-guitar" ? { ...role, name: "Electric Bass" } : role
+        )
+      }
+    ];
+
+    expect(firstPassSimplification(song, "bass-guitar")).toEqual({ status: "unavailable" });
+  });
+
+  it("skips a non-canonical section label instead of showing it as the first pass", () => {
+    const song = createDemoRehearsalSong();
+    const verse = song.sections[0]!;
+    song.sections = [
+      { ...verse, label: "drop-D intro" as RehearsalSong["sections"][number]["label"] },
+      { ...verse, id: "chorus-1", label: "chorus" }
+    ];
+
+    expect(firstPassSimplification(song, "bass-guitar")).toEqual({
+      status: "ready",
+      value: "Stay on roots if the chorus entrance gets muddy.",
+      sectionLabel: "chorus",
+      roleName: "Bass Guitar"
+    });
+  });
+
+  it("does not skip an untrusted first canonical take to a later section", () => {
+    const song = createDemoRehearsalSong();
+    const verse = song.sections[0]!;
+    song.sections = [
+      {
+        ...verse,
+        roles: verse.roles.map((role) =>
+          role.id === "bass-guitar" ? { ...role, simplification: "none" } : role
+        )
+      },
+      {
+        ...verse,
+        id: "chorus-1",
+        label: "chorus",
+        roles: verse.roles.map((role) =>
+          role.id === "bass-guitar"
+            ? { ...role, simplification: "Hold roots through the chorus lift." }
+            : role
+        )
+      }
+    ];
+
+    expect(firstPassSimplification(song, "bass-guitar")).toEqual({ status: "unavailable" });
+  });
+
+  it("fails closed for an unknown selected role", () => {
+    expect(firstPassSimplification(createDemoRehearsalSong(), "missing-role")).toEqual({
+      status: "unavailable"
+    });
+  });
+});
+
+describe("fillFirstPassCopy", () => {
+  it("fills owned tokens and leaves inherited members literal", () => {
+    expect(
+      fillFirstPassCopy("First pass for {roleName} in {sectionLabel}: {value} Play that simpler take before adding the rest.", {
+        roleName: "Bass Guitar",
+        sectionLabel: "verse",
+        value: "Stay on roots if the chorus entrance gets muddy."
+      })
+    ).toBe(
+      "First pass for Bass Guitar in verse: Stay on roots if the chorus entrance gets muddy. Play that simpler take before adding the rest."
+    );
+
+    expect(fillFirstPassCopy("keep {toString}", {})).toBe("keep {toString}");
+  });
+});
diff --git a/apps/desktop/src/features/workspace/firstPassSimplification.ts b/apps/desktop/src/features/workspace/firstPassSimplification.ts
new file mode 100644
index 000000000..c8937c591
--- /dev/null
+++ b/apps/desktop/src/features/workspace/firstPassSimplification.ts
@@ -0,0 +1,148 @@
+import { SECTION_FORM_LABELS, type RehearsalSong } from "@bandscope/shared-types";
+import { fillRangeCopy, meaningfulRangeText } from "./firstRangeSqueeze";
+
+/** Tonight's first trusted first-pass take for a selected named part. */
+export type FirstPassSimplification =
+  | {
+      status: "ready";
+      value: string;
+      sectionLabel: string;
+      roleName: string;
+    }
+  | { status: "unavailable" };
+
+type SelectedRoleCopy = {
+  sectionLabel: string;
+  roleName: string;
+  simplification: string | null;
+};
+
+const CANONICAL_SECTION_LABELS = new Set<string>(SECTION_FORM_LABELS);
+
+/** Return whether an untrusted runtime value is a plain object record. */
+function isRuntimeObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Return whether a record owns a field rather than inheriting it. */
+function owns(record: Record<string, unknown>, field: string): boolean {
+  return Object.prototype.hasOwnProperty.call(record, field);
+}
+
+/** Admit one own-property simplification without granting inherited members authority. */
+function admitSimplification(roleValue: Record<string, unknown>): string | null {
+  if (!owns(roleValue, "simplification")) {
+    return null;
+  }
+
+  return meaningfulRangeText(roleValue.simplification) ?? null;
+}
+
+/**
+ * Name the selected part's first trusted first-pass take.
+ *
+ * Simplification is the rehearsal instruction the player should play before
+ * adding the rest of the part. This is selected-part guidance, not the
+ * song-wide first-simpler-take map product, and it is not Active Player or
+ * MIR work. Inherited simplification fields, blank or `none` values, unnamed
+ * roles, duplicate ids in one section, conflicting display names, and
+ * non-canonical section labels fail closed instead of becoming first-pass
+ * authority.
+ */
+export function firstPassSimplification(
+  song: RehearsalSong | unknown,
+  activeRole: string | null
+): FirstPassSimplification {
+  const selectedRoleId = meaningfulRangeText(activeRole);
+  if (!selectedRoleId || !isRuntimeObject(song) || !owns(song, "sections") || !Array.isArray(song.sections)) {
+    return { status: "unavailable" };
+  }
+
+  const copies: SelectedRoleCopy[] = [];
+  let knownName: string | undefined;
+
+  for (const sectionValue of song.sections) {
+    if (
+      !isRuntimeObject(sectionValue) ||
+      !owns(sectionValue, "label") ||
+      !owns(sectionValue, "roles") ||
+      !Array.isArray(sectionValue.roles)
+    ) {
+      return { status: "unavailable" };
+    }
+
+    const rawLabel = meaningfulRangeText(sectionValue.label);
+    if (!rawLabel) {
+      return { status: "unavailable" };
+    }
+
+    const sectionRoleIds = new Set<string>();
+    let selectedCopy: Record<string, unknown> | null = null;
+
+    for (const roleValue of sectionValue.roles) {
+      if (!isRuntimeObject(roleValue) || !owns(roleValue, "id") || !owns(roleValue, "name")) {
+        return { status: "unavailable" };
+      }
+
+      const roleId = meaningfulRangeText(roleValue.id);
+      const roleName = meaningfulRangeText(roleValue.name);
+      if (!roleId || !roleName) {
+        return { status: "unavailable" };
+      }
+      if (sectionRoleIds.has(roleId)) {
+        return { status: "unavailable" };
+      }
+      sectionRoleIds.add(roleId);
+
+      if (roleId !== selectedRoleId) {
+        continue;
+      }
+      if (selectedCopy) {
+        return { status: "unavailable" };
+      }
+      selectedCopy = roleValue;
+    }
+
+    if (!selectedCopy) {
+      continue;
+    }
+
+    const roleName = meaningfulRangeText(selectedCopy.name);
+    if (!roleName) {
+      return { status: "unavailable" };
+    }
+    if (knownName && knownName !== roleName) {
+      return { status: "unavailable" };
+    }
+    knownName = roleName;
+
+    if (!CANONICAL_SECTION_LABELS.has(rawLabel)) {
+      continue;
+    }
+
+    copies.push({
+      sectionLabel: rawLabel,
+      roleName,
+      simplification: admitSimplification(selectedCopy)
+    });
+  }
+
+  for (const copy of copies) {
+    if (!copy.simplification) {
+      return { status: "unavailable" };
+    }
+    return {
+      status: "ready",
+      value: copy.simplification,
+      sectionLabel: copy.sectionLabel,
+      roleName: copy.roleName
+    };
+  }
+
+  return { status: "unavailable" };
+}
+
+/** Fill trusted `{token}` placeholders for first-pass copy. */
+export function fillFirstPassCopy(template: string, values: Record<string, string>): string {
+  return fillRangeCopy(template, values);
+}
diff --git a/apps/desktop/src/locales/en/common.json b/apps/desktop/src/locales/en/common.json
index d803a765e..fdb656b32 100644
--- a/apps/desktop/src/locales/en/common.json
+++ b/apps/desktop/src/locales/en/common.json
@@ -153,6 +153,9 @@
   "workspaceFirstRangeCheck": "{roleName} sits {lowestNote}–{highestNote} in {sectionLabel}. Check that span on your instrument before the {sectionLabel}.",
   "workspaceFirstRangeClash": "{roleName} sits {lowestNote}–{highestNote} in {sectionLabel}. Hear that clash on your instrument before the {sectionLabel}.",
   "workspaceFirstRangeMissing": "Tonight's first range still needs an ear check. Confirm the high and low notes on the selected part before the first section.",
+  "workspaceSelectedFirstPassTitle": "Tonight's first-pass take",
+  "workspaceSelectedFirstPassReady": "First pass for {roleName} in {sectionLabel}: {value} Play that simpler take before adding the rest.",
+  "workspaceSelectedFirstPassUnavailable": "This part still needs a trusted first-pass take. Confirm the simpler version before the first run.",
   "sectionRangeLabel": "Range",
   "sectionRangeNextAction": "Check this span on your instrument before {sectionLabel}."
 }
diff --git a/apps/desktop/src/locales/ko/common.json b/apps/desktop/src/locales/ko/common.json
index 0f6c6c66d..d4e80d96a 100644
--- a/apps/desktop/src/locales/ko/common.json
+++ b/apps/desktop/src/locales/ko/common.json
@@ -153,6 +153,9 @@
   "workspaceFirstRangeCheck": "{sectionLabel}의 {roleName}은 {lowestNote}–{highestNote}입니다. {sectionLabel} 들어가기 전에 그 음역을 악기로 확인해 보세요.",
   "workspaceFirstRangeClash": "{sectionLabel}의 {roleName}은 {lowestNote}–{highestNote}이고 다른 파트와 겹칩니다. {sectionLabel} 들어가기 전에 그 충돌을 악기로 들어 보세요.",
   "workspaceFirstRangeMissing": "오늘 먼저 볼 음역은 아직 귀로 확인이 필요합니다. 선택한 파트의 최저·최고음을 첫 구간 전에 확인해 보세요.",
+  "workspaceSelectedFirstPassTitle": "오늘 이 파트의 첫 간소화",
+  "workspaceSelectedFirstPassReady": "{sectionLabel}에서 {roleName} 파트의 첫 패스: {value} 나머지를 더하기 전에 그 간소화된 버전으로 연습하세요.",
+  "workspaceSelectedFirstPassUnavailable": "이 파트에는 아직 신뢰할 수 있는 첫 패스 간소화가 없습니다. 첫 연습 전에 더 단순한 버전을 확인하세요.",
   "sectionRangeLabel": "음역",
   "sectionRangeNextAction": "{sectionLabel} 들어가기 전에 이 음역을 악기로 확인해 보세요."
 }
diff --git a/docs/design-system/component-contract.md b/docs/design-system/component-contract.md
index 22602c313..9341c1c17 100644
--- a/docs/design-system/component-contract.md
+++ b/docs/design-system/component-contract.md
@@ -31,6 +31,7 @@ The authoritative Figma view is `31 Component Contract Catalog`. This file mirro
 | Role Switcher | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-337 | `apps/desktop/src/features/workspace/RoleSwitcher.tsx` | Use `roles`, `activeRole`, and `onRoleChange`; `null` means all roles. |
 | Section Roadmap Card | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-402 | `apps/desktop/src/features/workspace/SectionRoadmap.tsx` | Use `song`, `activeRole`, and optional `onSongUpdate`; avoid rebuilding its internal card layout. |
 | Song Structure Timeline | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-457 | `apps/desktop/src/features/workspace/Workspace.tsx` | Feature-local `SongStructure({ sections, t })` memo component; not exported. |
+| Selected Part First-Pass Take | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-239 | `apps/desktop/src/features/workspace/Workspace.tsx`, `apps/desktop/src/features/workspace/firstPassSimplification.ts` | Feature-local selected-part callout. Show only after Role Switcher selection; copy must name the simpler take to play first. |
 | Groove Map | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-526 | `apps/desktop/src/features/workspace/GrooveMap.tsx` | Use `notes?: TranscriptionNote[]` and `isLoading?: boolean`; preserve scrollable region semantics and note labels. |
 | Source Control Stack | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-655 | `apps/desktop/src/App.tsx` | Feature-local source controls for local audio, YouTube URL import, project actions, and Start Analysis; keep before metrics at 375px. |
 | Export Action Group | https://www.figma.com/design/zthWmqfNKUgJBECvv002Qk/Bandscope-Design-System-v1?node-id=19-731 | `apps/desktop/src/features/workspace/Workspace.tsx` | Feature-local export buttons call `handleExportCueSheet`, `handleExportChart`, and `handleExportHandoff`. |
diff --git a/docs/doctoring/selected-part-first-pass.md b/docs/doctoring/selected-part-first-pass.md
new file mode 100644
index 000000000..8fa5f90c1
--- /dev/null
+++ b/docs/doctoring/selected-part-first-pass.md
@@ -0,0 +1,63 @@
+# Selected-part first-pass take
+
+## Decision
+
+After a named part is selected, the ready rehearsal workspace names that part's first trusted `simplification` as the next first-pass action: play the simpler take before adding the rest.
+
+When the selected part has no trusted simplification, the callout still names the next action: confirm the simpler version before the first run. The callout stays hidden until a part is selected so this lane does not become a song-wide first-simpler-take product.
+
+This is not Active Player ownership (`#961`) and not MIR ownership (`#828` / `#770`).
+
+## Own-property admission
+
+`simplification` is an untrusted project field. Workspace copy may only name a first-pass take from own-property evidence:
+
+- `simplification` must be an owned string;
+- the value must be meaningful text (not blank or `none`);
+- section labels must belong to shared `SECTION_FORM_LABELS`;
+- unnamed roles, duplicate ids in one section, or the same id with two display names fail closed.
+
+The helper never logs simplification text, role names, or project paths.
+
+## Security Notes
+
+### Attack surface
+
+Untrusted local project JSON can carry `sections[].roles[].simplification`. A prototype-inherited `simplification` or a `none` sentinel must not become first-pass authority or be interpolated into bilingual copy.
+
+### Trust boundary
+
+Admission is lexical and own-property only. The helper reads in-memory song objects already loaded by the desktop shell. It does not open files, resolve paths, call IPC, or export bytes. Display names interpolated into copy are the same named-role strings already shown in the Role Switcher.
+
+### Mitigations
+
+- `Object.prototype.hasOwnProperty.call` before reading `simplification`, `id`, `name`, `label`, and `roles`.
+- `meaningfulRangeText` rejects blank and `none` sentinel values.
+- Non-canonical section labels never become buyer-visible localization authority.
+- Conflicting section copies of the same named part return `unavailable`; Workspace still tells the player to confirm the first-pass take instead of guessing.
+- Locale templates keep `{roleName}` / `{sectionLabel}` / `{value}` placeholders; `fillRangeCopy` uses own-property token lookup so inherited members such as `toString` cannot render function source.
+- Korean copy uses `{roleName} 파트` so a Latin role label cannot produce `Bass Guitar으로`.
+
+### Test points
+
+- Helper: bass/keys/vocal takes; missing selection; blank/`none`/missing field; inherited simplification; duplicate ids; conflicting names; non-canonical labels; first untrusted canonical copy is not skipped.
+- Workspace: hidden until a part is selected; bass first-pass copy; vocal first-pass copy; Korean particle-safe Latin role; unavailable copy when the take is `none`.
+
+### Realistic threats
+
+A crafted project that puts `simplification` on `Object.prototype` or labels a section `drop-D intro` could otherwise tell a player to play hostile text or interpolate unexpected function source into the callout.
+
+### Remaining risk
+
+Simplification text is already shown on the Section Roadmap card. This callout reuses the same admitted strings for the selected part only and does not persist a new field.
+
+## Verification
+
+Run:
+
+```bash
+npm --workspace @bandscope/desktop exec vitest run \
+  src/features/workspace/firstPassSimplification.test.ts \
+  src/features/workspace/Workspace.first-pass.test.tsx \
+  src/features/workspace/Workspace.test.tsx
+```