diff --git a/AGENTS.md b/AGENTS.md
index b9a67ce17..4308d30d4 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. The ready workspace names tonight's first playable range and offers a download of tonight's first-action chart; when a valid named playable range exists the chart starts with that action, and otherwise it omits `firstAction` rather than inventing one.
 - 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..2b1cc790c 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -82,10 +82,10 @@ Last updated: 2026-03-11
   - likely harmony by section and by role
   - 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
+  - playable ranges and density or overlap warnings, with the ready workspace naming tonight's first span, the next instrument check, and a download of tonight's first-action chart
   - 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
+  - cue-sheet or chart-style exports that summarize the analysis in rehearsal-friendly form, with the chart JSON leading with tonight's first playable-range action
 
 ## Confidence, edits, and provenance
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0b6f7e784..4dc730117 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Added
 
+- Lead the chart JSON with tonight's first playable-range action and name that download on the rehearsal map.
 - 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..791ac986c 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, the next instrument check, and a download of tonight's first-action chart. `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.chartExport.test.tsx b/apps/desktop/src/features/workspace/Workspace.chartExport.test.tsx
new file mode 100644
index 000000000..3e65b00b8
--- /dev/null
+++ b/apps/desktop/src/features/workspace/Workspace.chartExport.test.tsx
@@ -0,0 +1,60 @@
+import { fireEvent, render, screen } from "@testing-library/react";
+import { createDemoRehearsalSong } from "@bandscope/shared-types";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { Workspace } from "./Workspace";
+
+const originalLanguage = navigator.language;
+const originalCreateObjectUrl = URL.createObjectURL;
+const originalRevokeObjectUrl = URL.revokeObjectURL;
+
+function setNavigatorLanguage(language: string) {
+  Object.defineProperty(navigator, "language", {
+    configurable: true,
+    value: language
+  });
+}
+
+describe("Workspace chart export contract", () => {
+  afterEach(() => {
+    setNavigatorLanguage(originalLanguage);
+    vi.restoreAllMocks();
+    Object.defineProperty(URL, "createObjectURL", {
+      configurable: true,
+      value: originalCreateObjectUrl
+    });
+    Object.defineProperty(URL, "revokeObjectURL", {
+      configurable: true,
+      value: originalRevokeObjectUrl
+    });
+  });
+
+  it("keeps the full-band chart lead stable when the UI role changes", async () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const createObjectUrl = vi.fn(() => "blob:full-band-chart");
+    vi.spyOn(HTMLAnchorElement.prototype, "click").mockImplementation(() => undefined);
+    Object.defineProperty(URL, "createObjectURL", {
+      configurable: true,
+      value: createObjectUrl
+    });
+    Object.defineProperty(URL, "revokeObjectURL", {
+      configurable: true,
+      value: vi.fn()
+    });
+
+    render(<Workspace song={song} />);
+    fireEvent.click(screen.getByRole("tab", { name: "Lead Vocal" }));
+    fireEvent.click(screen.getByRole("button", { name: "Download tonight's first-action chart" }));
+
+    const blob = createObjectUrl.mock.calls[0]?.[0] as Blob;
+    const payload = JSON.parse(await blob.text()) as {
+      firstAction?: { role?: string };
+      sections?: Array<{ roles?: Array<{ name?: string }> }>;
+    };
+
+    expect(payload.firstAction?.role).toBe("Bass Guitar");
+    expect(payload.sections?.[0]?.roles?.map((role) => role.name)).toEqual(
+      expect.arrayContaining(["Bass Guitar", "Lead Vocal"])
+    );
+  });
+});
diff --git a/apps/desktop/src/features/workspace/Workspace.test.tsx b/apps/desktop/src/features/workspace/Workspace.test.tsx
index 7837bf80e..666759057 100644
--- a/apps/desktop/src/features/workspace/Workspace.test.tsx
+++ b/apps/desktop/src/features/workspace/Workspace.test.tsx
@@ -196,6 +196,68 @@ describe("Workspace", () => {
     );
   });
 
+  it("names tonight's first-action chart download and leads the file with that action", async () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    const createObjectUrl = vi.fn(() => "blob:chart");
+    const revokeObjectUrl = vi.fn();
+    const click = vi.spyOn(HTMLAnchorElement.prototype, "click").mockImplementation(() => undefined);
+    Object.defineProperty(URL, "createObjectURL", {
+      configurable: true,
+      value: createObjectUrl
+    });
+    Object.defineProperty(URL, "revokeObjectURL", {
+      configurable: true,
+      value: revokeObjectUrl
+    });
+
+    render(<Workspace song={song} />);
+
+    const download = screen.getByRole("button", { name: "Download tonight's first-action chart" });
+    fireEvent.click(download);
+
+    const blob = createObjectUrl.mock.calls[0]?.[0] as Blob;
+    const payload = JSON.parse(await blob.text());
+    expect(Object.keys(payload)[1]).toBe("firstAction");
+    expect(payload.firstAction).toEqual({
+      section: "verse",
+      role: "Bass Guitar",
+      lowestNote: "C#2",
+      highestNote: "E3",
+      next: "Bass Guitar sits C#2–E3 in verse. Hear that clash on your instrument before the verse."
+    });
+    expect(click).toHaveBeenCalledTimes(1);
+    expect(revokeObjectUrl).toHaveBeenCalledWith("blob:chart");
+  });
+
+  it("does not invent a first-action chart lead when the first range still needs an ear check", async () => {
+    setNavigatorLanguage("en-US");
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.roles = song.sections[0]!.roles.map((role) => ({
+      ...role,
+      range: { lowestNote: "", highestNote: "none" },
+      overlapWarnings: []
+    }));
+    const createObjectUrl = vi.fn(() => "blob:chart-missing");
+    vi.spyOn(HTMLAnchorElement.prototype, "click").mockImplementation(() => undefined);
+    Object.defineProperty(URL, "createObjectURL", {
+      configurable: true,
+      value: createObjectUrl
+    });
+    Object.defineProperty(URL, "revokeObjectURL", {
+      configurable: true,
+      value: vi.fn()
+    });
+
+    render(<Workspace song={song} />);
+    fireEvent.click(screen.getByRole("button", { name: "Download tonight's first-action chart" }));
+
+    const blob = createObjectUrl.mock.calls[0]?.[0] as Blob;
+    const payload = JSON.parse(await blob.text());
+    expect(payload.firstAction).toBeUndefined();
+    expect(Object.keys(payload)).toEqual(["title", "headline", "sections"]);
+  });
+
   it("falls back from blank planning copy and tolerates partial collaboration payloads", () => {
     setNavigatorLanguage("en-US");
     const song = createDemoRehearsalSong();
@@ -325,5 +387,6 @@ describe("Workspace", () => {
     expect(screen.getByText("스템")).toBeTruthy();
     expect(screen.getByText("합주 우선순위")).toBeTruthy();
     expect(screen.getByText("역할과 화성")).toBeTruthy();
+    expect(screen.getByRole("button", { name: "오늘 먼저 할 일 차트 받기" })).toBeTruthy();
   });
 });
diff --git a/apps/desktop/src/features/workspace/Workspace.tsx b/apps/desktop/src/features/workspace/Workspace.tsx
index d44e20777..407b6ae00 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 { firstChartAction } from "./firstChartAction";
 import { createTranslator, detectPreferredLocale } from "../../i18n";
 import { generateCueSheetCsv, generateChartSummaryJson, generateMetadataHandoffJson, sanitizeFilename } from "../../lib/export";
 import { Button } from "@/components/ui/button";
@@ -234,7 +235,7 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
 
   /** Documented. */
   const handleExportChart = () => {
-    const json = generateChartSummaryJson(song);
+    const json = generateChartSummaryJson(song, { firstAction: firstChartAction(song, activeRole, t) });
     downloadTextFile(json, "application/json;charset=utf-8;", `${sanitizeFilename(song.title)}_chart.json`);
   };
 
@@ -285,7 +286,7 @@ export function Workspace({ song, sourceBootstrap = null, onSongUpdate }: Worksp
                 className="min-h-10 border-white/10 bg-white/5 font-semibold text-slate-100 shadow-sm hover:bg-white/10 hover:text-white"
             >
                 <Download className="mr-2 size-4 text-slate-300" aria-hidden="true" />
-              Export Chart (JSON)
+              {t("workspaceFirstRangeDownloadChart")}
             </Button>
             <Button
               variant="outline"
diff --git a/apps/desktop/src/features/workspace/firstChartAction.test.ts b/apps/desktop/src/features/workspace/firstChartAction.test.ts
new file mode 100644
index 000000000..51c4971db
--- /dev/null
+++ b/apps/desktop/src/features/workspace/firstChartAction.test.ts
@@ -0,0 +1,69 @@
+import { createDemoRehearsalSong, type RehearsalSong } from "@bandscope/shared-types";
+import { describe, expect, it } from "vitest";
+import { createTranslator } from "../../i18n";
+import { firstChartAction } from "./firstChartAction";
+
+describe("firstChartAction", () => {
+  const t = createTranslator("en");
+
+  it("leads with the first clashing span and the instrument-check next action", () => {
+    expect(firstChartAction(createDemoRehearsalSong(), null, t)).toEqual({
+      section: "verse",
+      role: "Bass Guitar",
+      lowestNote: "C#2",
+      highestNote: "E3",
+      next: "Bass Guitar sits C#2–E3 in verse. Hear that clash on your instrument before the verse."
+    });
+  });
+
+  it("keeps the full-band lead when a UI role is selected", () => {
+    const action = firstChartAction(createDemoRehearsalSong(), "lead-vocal", t);
+
+    expect(action?.role).toBe("Bass Guitar");
+    expect(action?.lowestNote).toBe("C#2");
+    expect(action?.highestNote).toBe("E3");
+    expect(action?.next).toBe(
+      "Bass Guitar sits C#2–E3 in verse. Hear that clash on your instrument before the verse."
+    );
+  });
+
+  it("uses the check copy when the first span has no clash", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.roles = song.sections[0]!.roles.map((role) => ({
+      ...role,
+      overlapWarnings: []
+    }));
+
+    expect(firstChartAction(song, null, t)?.next).toBe(
+      "Bass Guitar sits C#2–E3 in verse. Check that span on your instrument before the verse."
+    );
+  });
+
+  it("returns null when no named span exists", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.roles = song.sections[0]!.roles.map((role) => ({
+      ...role,
+      range: { lowestNote: "", highestNote: "none" },
+      overlapWarnings: []
+    }));
+
+    expect(firstChartAction(song, null, t)).toBeNull();
+  });
+
+  it("fails closed on malformed runtime collections", () => {
+    expect(firstChartAction(null as unknown as RehearsalSong, null, t)).toBeNull();
+  });
+
+  it("keeps formula-shaped role names literal so JSON encoding can neutralize them later", () => {
+    const song = createDemoRehearsalSong();
+    song.sections[0]!.roles[0] = {
+      ...song.sections[0]!.roles[0]!,
+      name: "=HYPERLINK(\"http://evil\")"
+    };
+
+    expect(firstChartAction(song, "bass-guitar", t)).toMatchObject({
+      role: "=HYPERLINK(\"http://evil\")",
+      next: "=HYPERLINK(\"http://evil\") sits C#2–E3 in verse. Hear that clash on your instrument before the verse."
+    });
+  });
+});
diff --git a/apps/desktop/src/features/workspace/firstChartAction.ts b/apps/desktop/src/features/workspace/firstChartAction.ts
new file mode 100644
index 000000000..661f88402
--- /dev/null
+++ b/apps/desktop/src/features/workspace/firstChartAction.ts
@@ -0,0 +1,43 @@
+import type { RehearsalSong } from "@bandscope/shared-types";
+import type { TranslationKey } from "../../i18n";
+import type { ChartFirstAction } from "../../lib/export";
+import { fillRangeCopy, firstRangeSqueeze } from "./firstRangeSqueeze";
+
+/** Documented. */
+type Translator = (key: TranslationKey) => string;
+
+/**
+ * Build tonight's first-action lead for the full-band rehearsal chart JSON.
+ *
+ * Uses the same playable-span authority as the ready map. Values stay
+ * literal so JSON encoding, not this helper, is the serialization boundary.
+ * Malformed songs and unnamed spans fail closed instead of inventing a lead.
+ */
+export function firstChartAction(
+  song: RehearsalSong,
+  activeRole: string | null,
+  t: Translator
+): ChartFirstAction | null {
+  // The chart body always contains the full band, so a transient UI role filter must not alter its lead.
+  void activeRole;
+  const squeeze = firstRangeSqueeze(song, null);
+  if (!squeeze) {
+    return null;
+  }
+
+  return {
+    section: squeeze.sectionLabel,
+    role: squeeze.roleName,
+    lowestNote: squeeze.lowestNote,
+    highestNote: squeeze.highestNote,
+    next: fillRangeCopy(
+      t(squeeze.overlapWarning ? "workspaceFirstRangeClash" : "workspaceFirstRangeCheck"),
+      {
+        roleName: squeeze.roleName,
+        lowestNote: squeeze.lowestNote,
+        highestNote: squeeze.highestNote,
+        sectionLabel: squeeze.sectionLabel
+      }
+    )
+  };
+}
diff --git a/apps/desktop/src/lib/export.test.ts b/apps/desktop/src/lib/export.test.ts
index 265e983d4..ff7790a69 100644
--- a/apps/desktop/src/lib/export.test.ts
+++ b/apps/desktop/src/lib/export.test.ts
@@ -131,6 +131,7 @@ describe("export generation", () => {
     const parsed = JSON.parse(jsonStr);
     expect(parsed.title).toBe("Test");
     expect(parsed.sections[0].roles[0].chord).toBe("=Cmaj7");
+    expect(parsed.firstAction).toBeUndefined();
   });
 
   it("generates chart summary JSON when headline is missing", () => {
@@ -143,6 +144,33 @@ describe("export generation", () => {
     expect(parsed.headline).toBe("");
   });
 
+  it("leads the chart JSON with tonight's first action when a lead is provided", () => {
+    const jsonStr = generateChartSummaryJson(mockSong, {
+      firstAction: {
+        section: "verse",
+        role: "=HYPERLINK(\"http://evil\")",
+        lowestNote: "C2",
+        highestNote: "C3",
+        next: "=HYPERLINK(\"http://evil\") sits C2–C3 in verse. Check that span on your instrument before the verse."
+      }
+    });
+    const parsed = JSON.parse(jsonStr);
+    expect(Object.keys(parsed)).toEqual(["title", "firstAction", "headline", "sections"]);
+    expect(parsed.firstAction).toEqual({
+      section: "verse",
+      role: "=HYPERLINK(\"http://evil\")",
+      lowestNote: "C2",
+      highestNote: "C3",
+      next: "=HYPERLINK(\"http://evil\") sits C2–C3 in verse. Check that span on your instrument before the verse."
+    });
+    expect(parsed.sections[0].roles[0].chord).toBe("=Cmaj7");
+  });
+
+  it("does not invent a first action when the lead is omitted or null", () => {
+    expect(JSON.parse(generateChartSummaryJson(mockSong)).firstAction).toBeUndefined();
+    expect(JSON.parse(generateChartSummaryJson(mockSong, { firstAction: null })).firstAction).toBeUndefined();
+  });
+
   it("generates a metadata-only local handoff without source paths or transcription data", () => {
     const sourceBootstrap: ProjectBootstrapSummary = {
       projectId: "project-1",
diff --git a/apps/desktop/src/lib/export.ts b/apps/desktop/src/lib/export.ts
index 3d4493b1d..1bcee0b10 100644
--- a/apps/desktop/src/lib/export.ts
+++ b/apps/desktop/src/lib/export.ts
@@ -59,10 +59,36 @@ export function generateCueSheetCsv(song: RehearsalSong): string {
   return rows.join("\n");
 }
 
+/** Tonight's first playable-range action for the rehearsal chart JSON. */
+export type ChartFirstAction = {
+  section: string;
+  role: string;
+  lowestNote: string;
+  highestNote: string;
+  next: string;
+};
+
 /** Documented. */
-export function generateChartSummaryJson(song: RehearsalSong): string {
+export function generateChartSummaryJson(
+  song: RehearsalSong,
+  options?: { firstAction?: ChartFirstAction | null }
+): string {
   // Just a clean JSON stringification for now, focusing on the core chart data
-  const summary = {
+  const summary: {
+    title: string;
+    firstAction?: ChartFirstAction;
+    headline: string;
+    sections: Array<{
+      label: string;
+      groove: string;
+      roles: Array<{
+        name: string;
+        chord: string;
+        cue: string;
+        priority: string;
+      }>;
+    }>;
+  } = {
     title: song.title,
     headline: song.exportSummary?.headline || "",
     sections: song.sections.map(s => ({
@@ -76,6 +102,19 @@ export function generateChartSummaryJson(song: RehearsalSong): string {
       }))
     }))
   };
+  if (options?.firstAction) {
+    const { title, headline, sections } = summary;
+    return JSON.stringify(
+      {
+        title,
+        firstAction: options.firstAction,
+        headline,
+        sections
+      },
+      null,
+      2
+    );
+  }
   return JSON.stringify(summary, null, 2);
 }
 
diff --git a/apps/desktop/src/locales/en/common.json b/apps/desktop/src/locales/en/common.json
index d803a765e..ddd2c5e36 100644
--- a/apps/desktop/src/locales/en/common.json
+++ b/apps/desktop/src/locales/en/common.json
@@ -153,6 +153,7 @@
   "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.",
+  "workspaceFirstRangeDownloadChart": "Download tonight's first-action chart",
   "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..4fecdc809 100644
--- a/apps/desktop/src/locales/ko/common.json
+++ b/apps/desktop/src/locales/ko/common.json
@@ -153,6 +153,7 @@
   "workspaceFirstRangeCheck": "{sectionLabel}의 {roleName}은 {lowestNote}–{highestNote}입니다. {sectionLabel} 들어가기 전에 그 음역을 악기로 확인해 보세요.",
   "workspaceFirstRangeClash": "{sectionLabel}의 {roleName}은 {lowestNote}–{highestNote}이고 다른 파트와 겹칩니다. {sectionLabel} 들어가기 전에 그 충돌을 악기로 들어 보세요.",
   "workspaceFirstRangeMissing": "오늘 먼저 볼 음역은 아직 귀로 확인이 필요합니다. 선택한 파트의 최저·최고음을 첫 구간 전에 확인해 보세요.",
+  "workspaceFirstRangeDownloadChart": "오늘 먼저 할 일 차트 받기",
   "sectionRangeLabel": "음역",
   "sectionRangeNextAction": "{sectionLabel} 들어가기 전에 이 음역을 악기로 확인해 보세요."
 }
diff --git a/docs/architecture/overview.md b/docs/architecture/overview.md
index 3cf5261b9..a4b15c0fa 100644
--- a/docs/architecture/overview.md
+++ b/docs/architecture/overview.md
@@ -23,7 +23,7 @@ It is technically defined as a rehearsal-analysis product, not a single-output c
 
 ## Exported rehearsal deliverables
 
-- BandScope should support cue-sheet or chart-style outputs derived from the same section and role model.
+- BandScope should support cue-sheet or chart-style outputs derived from the same section and role model. When a valid named playable range exists, the chart JSON leads with tonight's first playable-range action so a player can start from the same check the board already named; otherwise it omits `firstAction` rather than inventing guidance.
 - Exported artifacts should stay compact and rehearsal-friendly rather than becoming DAW sessions or engraved scores.
 
 ## Delivery flow
diff --git a/docs/doctoring/chart-first-action.md b/docs/doctoring/chart-first-action.md
new file mode 100644
index 000000000..531c7c915
--- /dev/null
+++ b/docs/doctoring/chart-first-action.md
@@ -0,0 +1,54 @@
+# Chart JSON first-action lead
+
+## Decision
+
+The ready workspace names tonight's first playable range. The chart JSON still dumped title, headline, and every section×role row first, so a player opening tonight's chart had to hunt for that same check. `generateChartSummaryJson` now prepends an optional `firstAction` object. `export.ts` stays locale-free; the workspace computes the localized lead through `firstChartAction`. If that helper cannot name a playable span on the untrusted song payload, the lead is omitted rather than invented. Because the chart body is full-band, transient role selection in the workspace does not change the exported `firstAction`.
+
+```mermaid
+flowchart LR
+    A[Untrusted song payload] --> B[firstRangeSqueeze]
+    B -->|named span| C[firstChartAction]
+    B -->|no span| Z[Omit firstAction]
+    C --> D[Localized firstAction]
+    D --> E[JSON.stringify]
+    Z --> F[title headline sections]
+    E --> F
+    F --> G[Chart JSON]
+```
+
+## Security Notes
+
+### Attack surface
+
+Chart JSON is derived from untrusted analysis payloads. Section labels, role names, range labels, and next-action copy can carry formula-shaped values (`=`, `+`, `-`, `@`), quotes, and control characters.
+
+### Trust boundary
+
+`JSON.stringify` is the only chart-JSON encoder. `firstChartAction` treats the song as untrusted runtime data and fails closed. Lead values stay literal until that encoder runs. Filename sanitization for the download remains `sanitizeFilename`. This path does not write CSV.
+
+### Logging and privacy
+
+This export path does not add logging, telemetry, network transmission, or server-side retention. The generated Blob exists only in the local download flow until its object URL is revoked. The downloaded JSON can contain song titles, section labels, role names, arrangement notes, and other user-entered rehearsal metadata already present in the full-band chart; those values may identify people or projects, so their exposure follows wherever the user saves or shares the downloaded file rather than a new BandScope logging channel.
+
+### Mitigations
+
+- Do not invent a first-action object when the squeeze cannot name a playable span.
+- Keep formula-shaped role names and range labels literal in the helper so encoding stays centralized in `export.ts`.
+- Omit the `firstAction` key when the lead is missing or null; do not serialize a null action as guidance.
+- Keep the chart lead full-band so a transient workspace role filter cannot silently change the identity of the downloaded artifact.
+- Do not weaken or duplicate the existing cue-sheet formula-injection tests.
+
+### Test points
+
+- `apps/desktop/src/lib/export.test.ts` proves a lead object is JSON-encoded literally and that a missing/null lead does not add a key.
+- `apps/desktop/src/features/workspace/firstChartAction.test.ts` proves fail-closed matching, full-band lead stability, and literal formula-shaped role names.
+- `apps/desktop/src/features/workspace/Workspace.chartExport.test.tsx` proves selecting a UI role does not change the full-band chart lead or body.
+- `apps/desktop/src/features/workspace/Workspace.test.tsx` proves the chart download is named as tonight's first-action chart and that the file leads with that action.
+
+### Realistic threats
+
+A crafted project that puts `=CMD` in a role name could otherwise teach the wrong first action if the helper invented a span, or could confuse a downstream consumer that eval'd chart JSON. BandScope does not eval the artifact.
+
+### Remaining risk
+
+Downstream tools that interpret JSON string values as spreadsheet formulas or scripts remain outside this encoder. Cue-sheet CSV sanitization stays in `escapeCsvField` and is not reused here.