diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7d994f7..1d645c8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@ See [`changelog/README.md`](changelog/README.md) for the full index.
 
 ## Latest releases
 
+- **[0.12.0](changelog/0.12.0.md)** — 2026-05-18 · AI cleanup prompt handoff — Unused-tab button + `<details>` block in `improvements.md` + `prompt` CLI subcommand generate a markdown prompt for Claude Code (or any AI agent) to delete flagged measures. Lineage stays read-only.
 - **[0.11.7](changelog/0.11.7.md)** — 2026-04-28 · Default tab is now Sources (was Measures); fix Measures + Columns flipping to ascending sort on report reload
 - **[0.11.6](changelog/0.11.6.md)** — 2026-04-26 · Cross-doc link integrity — fix `[Sources.md](#)` regression in Model.md §3.3 + Index.md glossary entries now link to their companion docs (Measures, DataDictionary, Functions, CalcGroups)
 - **[0.11.5](changelog/0.11.5.md)** — 2026-04-26 · Improvements audit names the entities — tables / measures / columns missing descriptions now list the actual offenders inline
diff --git a/WHATS-NEW.md b/WHATS-NEW.md
index d9daceb..426bc9b 100644
--- a/WHATS-NEW.md
+++ b/WHATS-NEW.md
@@ -18,8 +18,9 @@ Drop in a PBIP folder — get a **searchable dashboard** plus **nine Markdown do
 - **Lineage** — search any measure or column from the tab itself, or click any entity in Measures / Columns / Pages / Tables. Shows upstream dependencies + source tables + downstream visuals in one view.
 
 ### Analysis
-- **Unused** — orphan measures, dead-chain measures, indirect-use detection
-- **Improvements** — 16-check model-health audit, severity-tiered (high · medium · low · info · strengths) — includes **broken-reference detection**: flags any DAX referencing a table / column / measure that doesn't exist
+
+- **Unused** — orphan measures, dead-chain measures, indirect-use detection. When measures are flagged, a top toolbar generates an **AI cleanup prompt** you can paste into Claude Code (with the [`pbi-desktop`](https://github.com/data-goblin/power-bi-agentic-development) plugin) or any AI agent that can drive TOM / Tabular Editor — PowerBI-Lineage never deletes anything itself; it hands off a ready-to-run markdown prompt with Stage 1 / Stage 2 ordering + EXTERNALMEASURE safety guards baked in.
+- **Improvements** — 16-check model-health audit, severity-tiered (high · medium · low · info · strengths) — includes **broken-reference detection**: flags any DAX referencing a table / column / measure that doesn't exist. The "unused measures" and "dead-chain" findings each carry a collapsible `<details>` block with the matching AI cleanup prompt, so wiki readers get it too.
 
 ### Output
 - **Documentation tab** — Markdown ready to paste into ADO Wiki or GitHub. Up to nine files — *Model · Data Dictionary · Sources · Measures · Functions · Calc Groups · Pages · Improvements · Index*. Empty docs (e.g. no UDFs) skip automatically.
@@ -28,7 +29,7 @@ Drop in a PBIP folder — get a **searchable dashboard** plus **nine Markdown do
 ## Under the hood
 
 - Runs **entirely in your browser** (File System Access API — nothing uploads) *or* as a **local CLI**
-- **Zero runtime dependencies**, MIT-licensed, 276 tests
+- **Zero runtime dependencies**, MIT-licensed, 299 tests
 - Three themes: dark · light · BluPulse — pick from the bottom of this overlay
 
 ## Running locally (CLI mode)
diff --git a/changelog/0.12.0.md b/changelog/0.12.0.md
new file mode 100644
index 0000000..60911ae
--- /dev/null
+++ b/changelog/0.12.0.md
@@ -0,0 +1,24 @@
+## [0.12.0] — 2026-05-18 · AI cleanup prompt handoff
+
+Closes the gap between *"Lineage tells you what's dead"* and *"Lineage helps you delete it"* — without breaking the read-only / zero-dep promise. PowerBI-Lineage never mutates the model itself; it now generates a markdown prompt the user pastes into Claude Code (with Kurt Buhler's [`pbi-desktop`](https://github.com/data-goblin/power-bi-agentic-development) plugin) or any AI agent that can drive TOM / Tabular Editor CLI.
+
+### Added
+- **Unused tab toolbar** — when the audit flags any unused or dead-chain measures, a top-of-tab bar appears with a single smart **"Generate AI cleanup prompt"** button. Auto-picks the right category (`unused-measures`, `dead-chain-measures`, or combined `measures-all`) from what's flagged. Counts on the button match what ends up in the prompt — EXTERNALMEASURE proxies excluded, auto-date tables excluded.
+- **Preview modal** — clicking the button opens a modal with the full prompt body, **Copy to clipboard** + **Download .md** actions. Closes on Escape, backdrop click, or the × button. Clipboard fallback selects-all if `navigator.clipboard.writeText` is blocked (HTTP origins / old Safari).
+- **`improvements.md` embed** — the "unused measures" and "dead-chain" findings in the generated audit doc now carry a collapsible `<details>AI cleanup prompt (copy + paste…)</details>` block. Survives the ADO Wiki + GitHub MD render path, so wiki readers can grab the prompt without opening the dashboard.
+- **CLI subcommand** — `powerbi-lineage prompt --category <c> --report <path> [--output <file>]` emits the same prompt to stdout (or a file) for CI / batch flows. `--help` prints usage; unknown flags fail loudly so a typo doesn't silently produce the wrong prompt.
+
+### Prompt anatomy
+- **Six safety constraints** baked into every prompt: confirm-before-each-deletion, Stage-1-before-Stage-2 ordering, EXTERNALMEASURE guard (read DAX from the live model and skip proxies), `_`-prefix helper-measure flag, single `SaveChanges()` at end, "make a git commit before starting" pre-flight (Power BI's Ctrl+Z does NOT undo TOM changes).
+- **No DAX bodies embedded** — the AI agent is already connected to the live model via `pbi-desktop`, so it can read DAX itself before deleting. Embedding it bloated the prompt for zero added safety; the v0.12.0 prompt just lists the measures as bullets.
+- **Stage 1 / Stage 2 grouping** — "directly unused" first, "dead-chain" second, with explicit "re-audit after Stage 1" warning. Deleting the top of a chain reclassifies items below it.
+
+### Changed
+- **Inline-script export-stripper hardened** — `src/html-generator.ts` now strips `export function|const|let|var|class` and named `export { a, b }` blocks in addition to the trailing empty `export {};`. Previously a TS module with inline `export` declarations would silently kill the entire dashboard `<script>` block when concatenated. (Discovered during this release while adding `ai-prompts.js` to the inline-script manifest.)
+
+### Tests
+- 299 tests pass (was 276): 14 new for the prompt builder, 4 new for the MD embed, 6 new for the CLI subcommand. **No new runtime dependencies.**
+
+### Notes
+- Lineage will **never** run the prompt for you. The destructive action stays in the user's own shell, in the AI tool they chose, with a git commit pre-flight. This is by design — see [the design doc](../claudedocs/intake-specs/design-ai-cleanup-handoff.md) (status: locked) for the full decision table and the rationale for rejecting `--apply` flags / TMDL-on-disk pruning / vendoring `pbi-desktop`.
+- v1 covers measures only (unused + dead-chain). Unused columns, dead inactive relationships, orphan pages = v2 — same builder, more categories.
diff --git a/package-lock.json b/package-lock.json
index 825bad9..295984f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,13 @@
 {
   "name": "powerbi-lineage",
-  "version": "0.1.0",
+  "version": "0.11.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "powerbi-lineage",
-      "version": "0.1.0",
+      "version": "0.11.7",
+      "license": "MIT",
       "bin": {
         "powerbi-lineage": "dist/app.js"
       },
diff --git a/package.json b/package.json
index e30926e..37e0123 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "powerbi-lineage",
-  "version": "0.11.7",
+  "version": "0.12.0",
   "description": "Generate documentation from Power BI PBIP projects — runs in your browser (nothing uploaded) or as a local CLI. Outputs a searchable dashboard plus 9+ Markdown docs ready for ADO Wiki or GitHub.",
   "license": "MIT",
   "author": "Jonathan Papworth",
diff --git a/readme.md b/readme.md
index 3bbc112..cd185db 100644
--- a/readme.md
+++ b/readme.md
@@ -9,7 +9,7 @@ Open a PBIP project folder — get a searchable dashboard plus nine Markdown doc
 </p>
 
 <p align="center">
-  <img alt="Tests 276/276" src="https://img.shields.io/badge/tests-276%2F276-22c55e?style=flat-square">
+  <img alt="Tests 299/299" src="https://img.shields.io/badge/tests-299%2F299-22c55e?style=flat-square">
   <img alt="Runtime deps 0" src="https://img.shields.io/badge/runtime%20deps-0-64748b?style=flat-square">
   <img alt="Node ≥18" src="https://img.shields.io/badge/node-%E2%89%A518-5E6A7B?style=flat-square">
 </p>
@@ -199,7 +199,7 @@ scripts/
   serve-browser.mjs    Tiny static server for local testing
 
 changelog/             Per-version release notes (one file per release)
-tests/                 node:test suites — 276 tests, zero framework deps
+tests/                 node:test suites — 299 tests, zero framework deps
 ```
 
 ## Zero runtime dependencies
diff --git a/src/ai-prompts.ts b/src/ai-prompts.ts
new file mode 100644
index 0000000..ab29724
--- /dev/null
+++ b/src/ai-prompts.ts
@@ -0,0 +1,225 @@
+/**
+ * AI cleanup prompt generator.
+ *
+ * Turns the existing audit's "unused measures" + "dead-chain measures"
+ * findings into a markdown prompt the user can paste into the AI tool
+ * of their choice (recommended: Claude Code with the `pbi-desktop`
+ * plugin) to actually delete those measures from a live model.
+ *
+ * Lineage itself never mutates the model — this module is the entire
+ * v1 surface area of the "AI cleanup handoff" feature. See
+ * claudedocs/intake-specs/design-ai-cleanup-handoff.md for the
+ * locked decisions and the rationale for the read-only commitment.
+ */
+import type { FullData, ModelMeasure } from "./data-builder.js";
+
+// Note: this module is intentionally **self-contained** so it can be
+// concatenated into the dashboard's inline <script> block (a classic
+// script, not a module bundle). The dead-chain algorithm is duplicated
+// from improvements.ts as `findDeadChainMeasures` below — kept in sync
+// by the tests in tests/ai-prompts.test.ts and tests/improvements.test.ts
+// asserting the same fixture produces the same dead-chain output.
+
+export type CleanupCategory =
+  | "unused-measures"
+  | "dead-chain-measures"
+  | "measures-all";
+
+export interface BuildCleanupPromptOptions {
+  /** Override the ISO date stamp emitted in the prompt body. Used by tests. */
+  now?: Date;
+}
+
+export interface CleanupTargetCounts {
+  /** Directly-unused user measures, EXTERNALMEASURE proxies excluded. */
+  stage1: number;
+  /** Dead-chain user measures (reachable only via Stage 1), EXTERNALMEASURE proxies excluded. */
+  stage2: number;
+}
+
+interface KillTarget {
+  table: string;
+  name: string;
+}
+
+function isoDate(d: Date): string {
+  return d.toISOString().slice(0, 10);
+}
+
+function userMeasures(data: FullData): ModelMeasure[] {
+  // Same filter as runImprovementChecks — auto-date tables are engine-
+  // generated and not user-managed, so their measures are never kill
+  // candidates even if they look unused.
+  return data.measures.filter(m => {
+    const t = data.tables.find(tt => tt.name === m.table);
+    return !t || t.origin !== "auto-date";
+  });
+}
+
+function isExternalProxy(m: ModelMeasure): boolean {
+  return m.externalProxy !== null;
+}
+
+function stage1Targets(data: FullData): KillTarget[] {
+  return userMeasures(data)
+    .filter(m => m.status === "unused" && !isExternalProxy(m))
+    .map(m => ({ table: m.table, name: m.name }));
+}
+
+/**
+ * Inline copy of improvements.deadChainMeasures so this module has no
+ * dependency on improvements.ts (allows it to be inlined into the
+ * dashboard's classic-script bundle without dragging improvements.ts
+ * along). Same algorithm: BFS from every status:"direct" measure
+ * through the dep graph; anything unreachable AND not already marked
+ * unused is dead-chain. Two callers, one definition — kept in sync by
+ * shared-fixture tests on both sides.
+ */
+function findDeadChainMeasures(data: FullData): string[] {
+  const byName = new Map<string, ModelMeasure>(data.measures.map(m => [m.name, m]));
+  const reachable = new Set<string>();
+  const queue: string[] = data.measures
+    .filter(m => m.status === "direct")
+    .map(m => m.name);
+  while (queue.length) {
+    const current = queue.shift()!;
+    if (reachable.has(current)) continue;
+    reachable.add(current);
+    const m = byName.get(current);
+    if (!m) continue;
+    for (const dep of m.daxDependencies) {
+      if (!reachable.has(dep)) queue.push(dep);
+    }
+  }
+  return data.measures
+    .filter(m => !reachable.has(m.name) && m.status !== "unused")
+    .map(m => m.name);
+}
+
+function stage2Targets(data: FullData): KillTarget[] {
+  const um = userMeasures(data);
+  const byName = new Map(um.map(m => [m.name, m]));
+  const deadNames = findDeadChainMeasures(data);
+  return deadNames
+    .map(n => byName.get(n))
+    .filter((m): m is ModelMeasure => m !== undefined)
+    .filter(m => m.status !== "unused" && !isExternalProxy(m))
+    .map(m => ({ table: m.table, name: m.name }));
+}
+
+function renderTargetList(targets: KillTarget[]): string {
+  if (targets.length === 0) return "_(none flagged)_";
+  return targets.map(t => `- \`${t.table}[${t.name}]\``).join("\n");
+}
+
+const RECOMMENDED_TOOL = `## Recommended tool
+If you are Claude Code and the \`pbi-desktop\` plugin from data-goblins is
+installed, use its \`connect-pbid\` skill. Otherwise, use TOM via PowerShell
+or the Tabular Editor CLI. Do **not** edit TMDL files directly while
+Power BI Desktop is open.`;
+
+const SAFETY_CONSTRAINTS = `## Safety constraints — read before acting
+1. Confirm with me before each deletion.
+2. Process **Stage 1 (directly unused)** completely before touching Stage 2 (dead-chain).
+   After Stage 1, re-run the audit; some Stage 2 items may need to stay.
+3. Before deleting each measure, read its DAX from the live model. If the
+   expression contains \`EXTERNALMEASURE(...)\` it is bound to a remote
+   Analysis Services cube and looks orphaned only from this side — skip it.
+   (PowerBI-Lineage already excludes proxies it can identify statically, but
+   verify directly as belt-and-braces.)
+4. If a measure's name starts with \`_\` it may be an intentional helper —
+   prompt me before deleting, do not auto-skip.
+5. After all deletions, call \`$model.SaveChanges()\` once; verify the model
+   still opens in Power BI Desktop with no broken-reference errors.
+6. Power BI Desktop's Ctrl+Z does NOT undo TOM changes. Make a \`.pbip\`
+   git commit before starting.`;
+
+const VERIFICATION = `## Verification
+After all stages complete:
+- Re-open the \`.pbip\` in Power BI Desktop; no error dialog should appear.
+- Open the Improvements tab in PowerBI-Lineage; the "unused measures" and
+  "dead-chain measures" findings should be empty or reduced as expected.
+- If anything looks wrong, \`git reset --hard\` to the pre-cleanup commit.`;
+
+function titleFor(category: CleanupCategory): string {
+  switch (category) {
+    case "unused-measures":     return "Cleanup task — delete unused Power BI measures";
+    case "dead-chain-measures": return "Cleanup task — delete dead-chain Power BI measures";
+    case "measures-all":        return "Cleanup task — delete unused + dead-chain Power BI measures";
+  }
+}
+
+function goalFor(category: CleanupCategory, date: string): string {
+  const common = `This list was generated by PowerBI-Lineage's static audit on ${date}.`;
+  switch (category) {
+    case "unused-measures":
+      return `## Goal
+Delete the measures listed in \`## Targets\` below from my Power BI model.
+${common} Each measure is consumed by **zero** visuals across **zero** pages
+and is not referenced by any other in-use measure.`;
+    case "dead-chain-measures":
+      return `## Goal
+Delete the measures listed in \`## Targets\` below from my Power BI model.
+${common} Each measure IS referenced by other measures, but those measures
+are themselves never on a visual — the whole chain terminates in nothing.
+**This is Stage 2 work.** Complete Stage 1 (directly unused) first and
+re-run the audit; some items below may no longer apply.`;
+    case "measures-all":
+      return `## Goal
+Delete the measures listed in \`## Targets\` below from my Power BI model.
+${common} Stage 1 = directly unused (zero visual bindings, no other measure
+references them). Stage 2 = dead-chain (referenced only by Stage 1 measures).
+Do Stage 1 first, then re-audit before touching Stage 2.`;
+  }
+}
+
+/**
+ * Count what `buildCleanupPrompt` would emit for each stage, without
+ * rendering the prompt. Used by the Unused-tab toolbar to decide
+ * whether to show the "Generate AI cleanup prompt" button and what
+ * to label it with. Numbers match what ends up in the prompt body
+ * (EXTERNALMEASURE proxies excluded, auto-date tables excluded),
+ * which can be lower than the Unused-tab card count.
+ */
+export function countCleanupTargets(data: FullData): CleanupTargetCounts {
+  return {
+    stage1: stage1Targets(data).length,
+    stage2: stage2Targets(data).length,
+  };
+}
+
+export function buildCleanupPrompt(
+  data: FullData,
+  category: CleanupCategory,
+  opts: BuildCleanupPromptOptions = {},
+): string {
+  const date = isoDate(opts.now ?? new Date());
+  const s1 = stage1Targets(data);
+  const s2 = stage2Targets(data);
+
+  const sections: string[] = [
+    `# ${titleFor(category)}`,
+    goalFor(category, date),
+    RECOMMENDED_TOOL,
+    SAFETY_CONSTRAINTS,
+  ];
+
+  const targetSection: string[] = ["## Targets"];
+
+  if (category === "unused-measures" || category === "measures-all") {
+    targetSection.push(`### Stage 1 — directly unused (${s1.length} measure${s1.length === 1 ? "" : "s"})
+
+${renderTargetList(s1)}`);
+  }
+
+  if (category === "dead-chain-measures" || category === "measures-all") {
+    targetSection.push(`### Stage 2 — dead-chain (${s2.length} measure${s2.length === 1 ? "" : "s"}, only kill after Stage 1 + re-audit)
+
+${renderTargetList(s2)}`);
+  }
+
+  sections.push(targetSection.join("\n\n"));
+  sections.push(VERIFICATION);
+
+  return sections.join("\n\n") + "\n";
+}
diff --git a/src/app.ts b/src/app.ts
index 8244ab0..d1117b4 100644
--- a/src/app.ts
+++ b/src/app.ts
@@ -15,6 +15,7 @@ import { generateImprovementsMd } from "./improvements.js";
 import { findSemanticModelPath } from "./model-parser.js";
 import { escHtml } from "./render/safe.js";
 import { validateReportPath } from "./path-guard.js";
+import { buildCleanupPrompt, type CleanupCategory } from "./ai-prompts.js";
 
 // Resolve the package version once at module load (falls back if unavailable).
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -25,6 +26,110 @@ const APP_VERSION: string = (() => {
   } catch { return "0.1.0"; }
 })();
 
+// ---------------------------------------------------------------------------
+// Subcommand dispatch — runs before any server-startup code. Currently
+// just `prompt` for the AI cleanup handoff; structured so additional
+// subcommands can slot in without growing this file too much.
+// ---------------------------------------------------------------------------
+
+function runPromptSubcommand(args: string[]): never {
+  // Parse `--key value` style flags. Unknown flags fail loudly so a
+  // typo doesn't silently produce the wrong prompt.
+  const flags: Record<string, string> = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--help" || a === "-h") {
+      printPromptUsage();
+      process.exit(0);
+    }
+    if (!a.startsWith("--")) {
+      console.error(`Unexpected positional arg: ${a}`);
+      printPromptUsage();
+      process.exit(2);
+    }
+    const key = a.slice(2);
+    const val = args[i + 1];
+    if (val === undefined || val.startsWith("--")) {
+      console.error(`Flag ${a} requires a value.`);
+      printPromptUsage();
+      process.exit(2);
+    }
+    flags[key] = val;
+    i++;
+  }
+
+  const validCategories: CleanupCategory[] = ["unused-measures", "dead-chain-measures", "measures-all"];
+  const category = flags.category as CleanupCategory;
+  if (!category || !validCategories.includes(category)) {
+    console.error(`--category is required; one of: ${validCategories.join(", ")}`);
+    printPromptUsage();
+    process.exit(2);
+  }
+
+  if (!flags.report) {
+    console.error(`--report <path-to-.Report-folder> is required.`);
+    printPromptUsage();
+    process.exit(2);
+  }
+
+  const validation = validateReportPath(flags.report);
+  if (!validation.ok) {
+    console.error(`Report path invalid: ${validation.reason}`);
+    process.exit(2);
+  }
+  const reportPath = validation.resolved;
+
+  try {
+    findSemanticModelPath(reportPath);
+  } catch (e) {
+    console.error(`Could not locate semantic model: ${(e as Error).message}`);
+    process.exit(2);
+  }
+
+  let data;
+  try {
+    data = buildFullData(reportPath);
+  } catch (e) {
+    console.error(`Parser error: ${(e as Error).message}`);
+    process.exit(1);
+  }
+
+  const prompt = buildCleanupPrompt(data, category);
+
+  if (flags.output) {
+    try {
+      fs.writeFileSync(flags.output, prompt, "utf8");
+      console.error(`Wrote ${prompt.length} bytes to ${flags.output}`);
+    } catch (e) {
+      console.error(`Could not write output: ${(e as Error).message}`);
+      process.exit(1);
+    }
+  } else {
+    process.stdout.write(prompt);
+  }
+  process.exit(0);
+}
+
+function printPromptUsage(): void {
+  console.error(`
+  powerbi-lineage prompt --category <c> --report <path> [--output <file>]
+
+  Generates a markdown prompt for an AI agent (Claude Code + pbi-desktop,
+  Cursor, etc.) to delete the measures the audit flags. Lineage does NOT
+  run the prompt — it just emits the markdown.
+
+  --category   unused-measures | dead-chain-measures | measures-all
+  --report     Path to a .Report folder inside a PBIP project
+  --output     Optional file path (defaults to stdout)
+`);
+}
+
+// Dispatch BEFORE the server-startup code below runs. Anything that
+// isn't a known subcommand falls through to the dashboard server.
+if (process.argv[2] === "prompt") {
+  runPromptSubcommand(process.argv.slice(3));
+}
+
 // ---------------------------------------------------------------------------
 // Recent paths storage
 // ---------------------------------------------------------------------------
diff --git a/src/client/globals.d.ts b/src/client/globals.d.ts
index 9656912..14bf061 100644
--- a/src/client/globals.d.ts
+++ b/src/client/globals.d.ts
@@ -78,3 +78,18 @@ declare function uc(n: number): string;
 declare function mdRender(md: string): string;
 declare function mdEscapeHtml(s: string): string;
 declare function mdInline(s: string): string;
+
+// AI cleanup prompt builder — defined in src/ai-prompts.ts and
+// concatenated into the inline <script> via the manifest in
+// html-generator.ts. The module is self-contained (no other-module
+// runtime imports) precisely so it can be inlined like the render
+// helpers. Type signature mirrors the source.
+declare function buildCleanupPrompt(
+  data: any,  // eslint-disable-line @typescript-eslint/no-explicit-any
+  category: "unused-measures" | "dead-chain-measures" | "measures-all",
+  opts?: { now?: Date },
+): string;
+
+declare function countCleanupTargets(
+  data: any,  // eslint-disable-line @typescript-eslint/no-explicit-any
+): { stage1: number; stage2: number };
diff --git a/src/client/main.ts b/src/client/main.ts
index d1f48e4..a9e844d 100644
--- a/src/client/main.ts
+++ b/src/client/main.ts
@@ -328,6 +328,11 @@ document.addEventListener('click', function(e){
     case 'export-measures-csv':       exportMeasuresCsv(); break;
     case 'export-columns-csv':        exportColumnsCsv(); break;
     case 'export-relationships-csv':  exportRelationshipsCsv(); break;
+    // AI cleanup prompt modal — opens from Unused tab buttons.
+    case 'cleanup-modal-open':        openCleanupModal((d.category as CleanupModalCategory) || "measures-all"); break;
+    case 'close-cleanup-modal':       closeCleanupModal(); break;
+    case 'cleanup-modal-copy':        copyCleanupPromptToClipboard(); break;
+    case 'cleanup-modal-download':    downloadCleanupPromptAsMd(); break;
   }
 });
 
@@ -1161,7 +1166,7 @@ function renderUnused(){
   const unusedC=DATA.columns.filter((c: any) =>c.status==='unused'),indirectC=DATA.columns.filter((c: any) =>c.status==='indirect');
   const pureOrphanM=unusedM.filter((m: any) =>!m.dependedOnBy.length);
   const chainOrphanM=unusedM.filter((m: any) =>m.dependedOnBy.length>0);
-  let h='';
+  let h=renderCleanupBar();
 
   if(pureOrphanM.length) h+=orphanSection('pure-m','Unused Measures — Not Referenced Anywhere','No visual uses them and no other measure references them — safe to remove','var(--clr-unused)',pureOrphanM.length,'Measures',
     pureOrphanM.map((m: any) =>`<div class="lc clickable" style="border-left:3px solid var(--clr-unused);flex:0 0 auto" data-action="lineage" data-type="measure" data-name="${escAttr(m.name)}"><div class="lc-name">${escHtml(m.name)}</div><div class="lc-sub">${escHtml(m.table)} · ${escHtml(m.formatString||'')}</div></div>`).join(""));
@@ -1186,6 +1191,143 @@ function renderUnused(){
   document.getElementById("unused-content")!.innerHTML=h;
 }
 
+// ─────────────────────────────────────────────────────────────────────
+// AI cleanup prompt modal — opened from the Unused tab. Lineage stays
+// read-only; this just packages the audit's kill-candidate list into a
+// markdown prompt the user pastes into Claude Code / another AI agent
+// that can drive TOM. The prompt builder lives in src/ai-prompts.ts
+// (self-contained, inlined via html-generator's manifest).
+// ─────────────────────────────────────────────────────────────────────
+
+type CleanupModalCategory = "unused-measures" | "dead-chain-measures" | "measures-all";
+
+/**
+ * Build the "Generate AI cleanup prompt" toolbar shown above the
+ * orphan sections in the Unused tab. Picks the right category based
+ * on what's available:
+ *   - Stage 1 + Stage 2 both have items → "measures-all" (combined)
+ *   - Only Stage 1                      → "unused-measures"
+ *   - Only Stage 2                      → "dead-chain-measures"
+ *   - Neither                           → empty string (hide bar)
+ * Counts on the button match what ends up in the prompt body
+ * (EXTERNALMEASURE proxies excluded), not what's on the cards below.
+ */
+function renderCleanupBar(): string {
+  if (!DATA || !DATA.measures) return '';
+  const counts = countCleanupTargets(DATA);
+  if (counts.stage1 === 0 && counts.stage2 === 0) return '';
+  let category: CleanupModalCategory;
+  let parts: string[] = [];
+  if (counts.stage1 > 0 && counts.stage2 > 0) {
+    category = 'measures-all';
+    parts.push(counts.stage1 + ' unused');
+    parts.push(counts.stage2 + ' dead-chain');
+  } else if (counts.stage1 > 0) {
+    category = 'unused-measures';
+    parts.push(counts.stage1 + ' unused measure' + (counts.stage1 === 1 ? '' : 's'));
+  } else {
+    category = 'dead-chain-measures';
+    parts.push(counts.stage2 + ' dead-chain measure' + (counts.stage2 === 1 ? '' : 's'));
+  }
+  const label = 'Generate AI cleanup prompt (' + parts.join(' + ') + ')';
+  const tooltip = "PowerBI-Lineage won't run this — copy + paste into Claude Code (with the pbi-desktop plugin) or another AI agent that can drive TOM. The prompt includes Stage 1/Stage 2 ordering and EXTERNALMEASURE safety guards.";
+  return '<div class="cleanup-bar">' +
+    '<div class="cleanup-bar-msg">Ready to act on these? Generate an AI prompt to delete the flagged measures.</div>' +
+    '<button type="button" class="cleanup-bar-btn" data-action="cleanup-modal-open" data-category="' + category + '" title="' + escAttr(tooltip) + '">' +
+      escHtml(label) +
+    '</button>' +
+  '</div>';
+}
+
+let currentCleanupPrompt: { category: CleanupModalCategory; body: string } | null = null;
+
+function openCleanupModal(category: CleanupModalCategory): void {
+  if (!DATA || !DATA.measures) return;
+  const body = buildCleanupPrompt(DATA, category);
+  currentCleanupPrompt = { category, body };
+  const modal = document.getElementById("cleanup-modal");
+  const pre   = document.getElementById("cleanup-modal-pre");
+  const title = document.getElementById("cleanup-modal-title");
+  const stat  = document.getElementById("cleanup-modal-status");
+  if (!modal || !pre || !title) return;
+  const titles: Record<CleanupModalCategory, string> = {
+    "unused-measures":     "AI cleanup prompt — directly unused measures",
+    "dead-chain-measures": "AI cleanup prompt — dead-chain measures",
+    "measures-all":        "AI cleanup prompt — unused + dead-chain measures",
+  };
+  title.textContent = titles[category];
+  pre.textContent = body;
+  if (stat) { stat.textContent = ""; stat.className = "cleanup-modal-status"; }
+  modal.hidden = false;
+  document.body.style.overflow = "hidden";
+}
+
+function closeCleanupModal(): void {
+  const modal = document.getElementById("cleanup-modal");
+  if (modal) modal.hidden = true;
+  document.body.style.overflow = "";
+  currentCleanupPrompt = null;
+}
+
+function setCleanupModalStatus(msg: string, kind: "ok" | "error"): void {
+  const s = document.getElementById("cleanup-modal-status");
+  if (!s) return;
+  s.textContent = msg;
+  s.className = "cleanup-modal-status is-" + kind;
+  // Auto-clear after 3s if untouched
+  const stamp = msg;
+  setTimeout(function(){
+    if (s.textContent === stamp) { s.textContent = ""; s.className = "cleanup-modal-status"; }
+  }, 3000);
+}
+
+function copyCleanupPromptToClipboard(): void {
+  if (!currentCleanupPrompt) return;
+  const body = currentCleanupPrompt.body;
+  const nav = navigator as Navigator & { clipboard?: { writeText: (s: string) => Promise<void> } };
+  if (nav.clipboard && nav.clipboard.writeText) {
+    nav.clipboard.writeText(body).then(
+      function(){ setCleanupModalStatus("Copied to clipboard ✓", "ok"); },
+      function(){ cleanupPromptSelectAllFallback(); },
+    );
+  } else {
+    cleanupPromptSelectAllFallback();
+  }
+}
+
+function cleanupPromptSelectAllFallback(): void {
+  const pre = document.getElementById("cleanup-modal-pre");
+  if (!pre) return;
+  const range = document.createRange();
+  range.selectNodeContents(pre);
+  const sel = window.getSelection();
+  if (sel) { sel.removeAllRanges(); sel.addRange(range); }
+  setCleanupModalStatus("Clipboard blocked — press Ctrl+C / Cmd+C", "error");
+}
+
+function downloadCleanupPromptAsMd(): void {
+  if (!currentCleanupPrompt) return;
+  const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, "");
+  const filename = "cleanup-" + currentCleanupPrompt.category + "-" + stamp + ".md";
+  const blob = new Blob([currentCleanupPrompt.body], { type: "text/markdown;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url; a.download = filename;
+  document.body.appendChild(a); a.click();
+  setTimeout(function(){
+    if (a.parentNode) a.parentNode.removeChild(a);
+    URL.revokeObjectURL(url);
+  }, 200);
+  setCleanupModalStatus("Downloaded " + filename, "ok");
+}
+
+// Escape key closes the modal when it's open.
+document.addEventListener("keydown", function(e: KeyboardEvent){
+  if (e.key !== "Escape") return;
+  const modal = document.getElementById("cleanup-modal");
+  if (modal && !modal.hidden) closeCleanupModal();
+});
+
 // ─────────────────────────────────────────────────────────────────────
 // Sources tab view-toggle — segmented control that swaps between the
 // original card-grouped breakdown (#sources-content) and the flat
diff --git a/src/html-generator.ts b/src/html-generator.ts
index 09a1906..7337e63 100644
--- a/src/html-generator.ts
+++ b/src/html-generator.ts
@@ -121,12 +121,22 @@ const DASHBOARD_CSS = readStyles();
 // ─────────────────────────────────────────────────────────────────────
 /**
  * Read one compiled client file (relative path under dist/client/)
- * and return its body with the tsc-inserted `export {};` stripped.
+ * and return its body with ESM module-export plumbing stripped — the
+ * inline <script> block we splice these into is a *classic* script,
+ * not a module, so any `export` keyword is a parse error that kills
+ * the entire script block silently.
  *
- * TypeScript auto-adds the export when a .ts file references ambient
- * declarations (our src/client/globals.d.ts) or stdlib types — this
- * would be a syntax error inside a classic `<script>` block so we
- * strip it unconditionally.
+ * Three patterns to strip:
+ *   1. `export {};`  — tsc auto-emits this on TS files that reference
+ *      ambient declarations (our `src/client/globals.d.ts`).
+ *   2. `export { a, b };` — named re-exports.
+ *   3. `export function foo()` / `export const foo` / `export let|var|class`
+ *      — inline exports on declarations. Stripped to leave the bare
+ *      declaration so the symbol becomes a script-scope global,
+ *      which is exactly what other concatenated files expect.
+ *
+ * Type-only imports / exports are already erased by tsc, so we don't
+ * need to handle them.
  */
 function readCompiledClientFile(rel: string): string {
   const candidates = [
@@ -135,7 +145,9 @@ function readCompiledClientFile(rel: string): string {
   ];
   for (const p of candidates) {
     try {
-      return fs.readFileSync(p, "utf8").replace(/\nexport\s*\{\s*\};?\s*$/s, "\n");
+      return fs.readFileSync(p, "utf8")
+        .replace(/^export\s+(async\s+function|function|const|let|var|class)\s/gm, "$1 ")
+        .replace(/^export\s*\{[^}]*\};?\s*$/gm, "");
     } catch { /* try next */ }
   }
   throw new Error(
@@ -158,6 +170,7 @@ function readCompiledClient(): string {
   const modules = [
     "render/escape.js",  // Stop 5 pass 2 — escHtml, escAttr, sc, uc (no deps)
     "render/md.js",      // Stop 5 pass 2 — markdown renderer (uses escHtml)
+    "../ai-prompts.js",  // self-contained; exports buildCleanupPrompt for the cleanup modal
     "main.js",           // still the big one; gets smaller every pass
   ];
   return modules.map(readCompiledClientFile).join("\n");
@@ -400,6 +413,24 @@ let GENERATED_AT=${safeJSON(ts)};
 // Client runtime — extracted to src/client/main.ts in Stop 5, inlined here from dist/client/main.js.
 ${CLIENT_JS}
 </script>
+<div id="cleanup-modal" class="cleanup-modal" hidden role="dialog" aria-modal="true" aria-labelledby="cleanup-modal-title">
+  <div class="cleanup-modal-backdrop" data-action="close-cleanup-modal"></div>
+  <div class="cleanup-modal-panel">
+    <div class="cleanup-modal-header">
+      <h2 id="cleanup-modal-title">AI cleanup prompt</h2>
+      <button type="button" class="cleanup-modal-close" data-action="close-cleanup-modal" aria-label="Close">&times;</button>
+    </div>
+    <div class="cleanup-modal-body">
+      <p class="cleanup-modal-hint">Copy this prompt and paste it into Claude Code (with the <code>pbi-desktop</code> plugin) or any AI agent that can drive TOM / Tabular Editor CLI. PowerBI-Lineage will not run it — you do.</p>
+      <pre id="cleanup-modal-pre" tabindex="0"></pre>
+    </div>
+    <div class="cleanup-modal-footer">
+      <button type="button" class="cleanup-modal-btn cleanup-modal-btn-primary" data-action="cleanup-modal-copy">Copy to clipboard</button>
+      <button type="button" class="cleanup-modal-btn" data-action="cleanup-modal-download">Download .md</button>
+      <span id="cleanup-modal-status" class="cleanup-modal-status" aria-live="polite"></span>
+    </div>
+  </div>
+</div>
 </body>
 </html>`;
 }
diff --git a/src/improvements.ts b/src/improvements.ts
index d437bff..e909cb4 100644
--- a/src/improvements.ts
+++ b/src/improvements.ts
@@ -21,6 +21,7 @@
 
 import type { FullData, ModelMeasure } from "./data-builder.js";
 import type { ModelRelationship } from "./model-parser.js";
+import { buildCleanupPrompt, type CleanupCategory } from "./ai-prompts.js";
 
 // ─────────────────────────────────────────────────────────────────────
 // Types
@@ -28,6 +29,11 @@ import type { ModelRelationship } from "./model-parser.js";
 
 export type ImprovementSeverity = "high" | "medium" | "low" | "info" | "good";
 
+/** Stable discriminator linking a check to downstream consumers (e.g.
+ *  the AI cleanup prompt builder). Optional — most checks don't need
+ *  one. Only set on checks whose findings have an automated follow-up. */
+export type ImprovementKind = "unused-measures" | "dead-chain-measures";
+
 export interface Improvement {
   severity: ImprovementSeverity;
   title: string;
@@ -41,6 +47,8 @@ export interface Improvement {
   maxListed?: number;
   /** Optional cross-reference hint pointing at another doc / tab. */
   crossRef?: string;
+  /** Stable identifier for downstream consumers. See ImprovementKind. */
+  kind?: ImprovementKind;
 }
 
 // ─────────────────────────────────────────────────────────────────────
@@ -436,6 +444,7 @@ export function runImprovementChecks(data: FullData): Improvement[] {
       items: unusedMeasures.map(m => m.table + "[" + m.name + "]"),
       maxListed: 15,
       crossRef: "The dashboard's **Unused** tab shows the same list with full per-entity lineage context.",
+      kind: "unused-measures",
     });
   }
   const deadChainRaw = deadChainMeasures(data);
@@ -450,6 +459,7 @@ export function runImprovementChecks(data: FullData): Improvement[] {
       summary: "These are used by other measures, but those measures are never on a visual themselves.",
       rationale: "The chain terminates in nothing — these measures are effectively dead. Remove the top of the chain (the directly-unused measures) and these become unused in turn.",
       items: deadChain.slice(0, 20),
+      kind: "dead-chain-measures",
     });
   }
   const unusedColumns = userColumns.filter(c => c.status === "unused" && !c.isKey);
@@ -700,7 +710,28 @@ const SEVERITY_META: Record<ImprovementSeverity, { icon: string; label: string;
   good:   { icon: "✅", label: "Strengths",       order: 4 },
 };
 
-function renderImprovementItem(it: Improvement): string[] {
+/** Map `Improvement.kind` to the `CleanupCategory` the prompt builder
+ *  expects. Same string today, but separate types so the two can drift
+ *  later without coupling. */
+const KIND_TO_CATEGORY: Record<ImprovementKind, CleanupCategory> = {
+  "unused-measures":     "unused-measures",
+  "dead-chain-measures": "dead-chain-measures",
+};
+
+function renderCleanupPromptBlock(data: FullData, kind: ImprovementKind): string[] {
+  const prompt = buildCleanupPrompt(data, KIND_TO_CATEGORY[kind]);
+  return [
+    "<details>",
+    "<summary>AI cleanup prompt (copy + paste into Claude Code or another AI agent)</summary>",
+    "",
+    prompt.replace(/\n+$/, ""),
+    "",
+    "</details>",
+    "",
+  ];
+}
+
+function renderImprovementItem(it: Improvement, data: FullData): string[] {
   const lines: string[] = [];
   lines.push(`### ${it.title}`);
   lines.push("");
@@ -723,6 +754,9 @@ function renderImprovementItem(it: Improvement): string[] {
     lines.push(`> ${it.crossRef}`);
     lines.push("");
   }
+  if (it.kind) {
+    for (const ln of renderCleanupPromptBlock(data, it.kind)) lines.push(ln);
+  }
   return lines;
 }
 
@@ -788,7 +822,7 @@ export function generateImprovementsMd(data: FullData, reportName: string, _mode
     lines.push(`## ${SEVERITY_META[sev].icon} ${SEVERITY_META[sev].label} (${group.length})`);
     lines.push("");
     for (const it of group) {
-      for (const ln of renderImprovementItem(it)) lines.push(ln);
+      for (const ln of renderImprovementItem(it, data)) lines.push(ln);
     }
     lines.push("---");
     lines.push("");
diff --git a/src/styles/dashboard.css b/src/styles/dashboard.css
index 71100b4..c37d5ab 100644
--- a/src/styles/dashboard.css
+++ b/src/styles/dashboard.css
@@ -892,3 +892,116 @@
     /* BluPulse aurora overlay is a body::after pseudo — kill it in print. */
     body::after, body::before { display: none !important; }
   }
+
+  /* ─────────────────────────────────────────────────────────────────
+     AI cleanup prompt — Unused-tab toolbar + modal. Toolbar sits
+     above the orphan sections; clicking the button opens the modal.
+     Themed via existing surface/text/border tokens for dark, light,
+     and BluPulse.
+  ───────────────────────────────────────────────────────────────── */
+  .cleanup-bar {
+    display: flex; align-items: center; justify-content: space-between;
+    gap: 12px; flex-wrap: wrap;
+    padding: 12px 14px; margin-bottom: 16px;
+    background: var(--surface-alt, rgba(255,255,255,0.04));
+    border: 1px solid var(--border-soft);
+    border-left: 3px solid var(--clr-measure, #F59E0B);
+    border-radius: var(--radius-md, 6px);
+  }
+  .cleanup-bar-msg {
+    font-size: 13px; opacity: 0.9; flex: 1 1 280px;
+  }
+  .cleanup-bar-btn {
+    appearance: none; cursor: pointer;
+    background: var(--clr-measure, #F59E0B); color: #0B0D11;
+    border: 0; border-radius: 4px;
+    padding: 8px 14px; font-size: 13px; font-weight: 600;
+    white-space: nowrap;
+  }
+  .cleanup-bar-btn:hover { filter: brightness(1.05); }
+  .cleanup-bar-btn:focus-visible { outline: 2px solid var(--clr-measure, #F59E0B); outline-offset: 2px; }
+
+
+  .cleanup-modal[hidden] { display: none; }
+  .cleanup-modal {
+    position: fixed; inset: 0; z-index: 200;
+    display: flex; align-items: center; justify-content: center;
+    padding: 24px;
+  }
+  .cleanup-modal-backdrop {
+    position: absolute; inset: 0;
+    background: rgba(0,0,0,0.55);
+    backdrop-filter: blur(2px);
+  }
+  .cleanup-modal-panel {
+    position: relative;
+    width: min(880px, 100%); max-height: 88vh;
+    display: flex; flex-direction: column;
+    background: var(--surface);
+    color: var(--text-body);
+    border: 1px solid var(--border-soft);
+    border-radius: var(--radius-md, 8px);
+    box-shadow: 0 12px 40px rgba(0,0,0,0.45);
+    overflow: hidden;
+  }
+  .cleanup-modal-header {
+    display: flex; align-items: center; justify-content: space-between;
+    padding: 14px 18px;
+    border-bottom: 1px solid var(--border-soft);
+  }
+  .cleanup-modal-header h2 {
+    margin: 0; font-size: 16px; font-weight: 600;
+  }
+  .cleanup-modal-close {
+    appearance: none; background: transparent; border: 0; color: var(--text-body);
+    font-size: 22px; line-height: 1; cursor: pointer;
+    padding: 4px 8px; border-radius: 4px;
+  }
+  .cleanup-modal-close:hover { background: rgba(255,255,255,0.08); }
+  .cleanup-modal-body {
+    padding: 14px 18px;
+    overflow-y: auto;
+    flex: 1 1 auto;
+  }
+  .cleanup-modal-hint {
+    margin: 0 0 12px 0; font-size: 13px; opacity: 0.85;
+  }
+  .cleanup-modal-hint code {
+    padding: 1px 6px; border-radius: 3px;
+    background: rgba(255,255,255,0.08); font-family: 'JetBrains Mono', ui-monospace, monospace;
+    font-size: 12px;
+  }
+  .cleanup-modal-body pre {
+    margin: 0; padding: 12px;
+    background: var(--surface-alt, rgba(255,255,255,0.04));
+    border: 1px solid var(--border-soft);
+    border-radius: 4px;
+    font-family: 'JetBrains Mono', ui-monospace, monospace;
+    font-size: 12px; line-height: 1.5;
+    white-space: pre-wrap; word-break: break-word;
+    max-height: 56vh; overflow: auto;
+    user-select: text;
+  }
+  .cleanup-modal-footer {
+    display: flex; align-items: center; gap: 8px;
+    padding: 12px 18px;
+    border-top: 1px solid var(--border-soft);
+  }
+  .cleanup-modal-btn {
+    appearance: none; cursor: pointer;
+    background: transparent; color: var(--text-body);
+    border: 1px solid var(--border-soft);
+    border-radius: 4px;
+    padding: 7px 14px; font-size: 13px; font-weight: 500;
+  }
+  .cleanup-modal-btn:hover { background: rgba(255,255,255,0.08); }
+  .cleanup-modal-btn-primary {
+    background: var(--clr-measure, #F59E0B);
+    color: #0B0D11; border-color: transparent;
+  }
+  .cleanup-modal-btn-primary:hover { filter: brightness(1.05); }
+  .cleanup-modal-status {
+    margin-left: auto; font-size: 12px; opacity: 0.8; min-height: 1.2em;
+  }
+  .cleanup-modal-status.is-ok    { color: var(--clr-success, #22C55E); opacity: 1; }
+  .cleanup-modal-status.is-error { color: var(--clr-unused,  #EF4444); opacity: 1; }
diff --git a/tests/ai-prompts.test.ts b/tests/ai-prompts.test.ts
new file mode 100644
index 0000000..a86b747
--- /dev/null
+++ b/tests/ai-prompts.test.ts
@@ -0,0 +1,232 @@
+/**
+ * AI cleanup prompt builder — unit tests.
+ *
+ * Covers the three categories, EXTERNALMEASURE exclusion, auto-date
+ * exclusion, stage ordering, and a few edge cases (empty stages,
+ * special characters in measure names).
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { buildCleanupPrompt } from "../src/ai-prompts.js";
+import type { FullData, ModelMeasure } from "../src/data-builder.js";
+
+// ─────────────────────────────────────────────────────────────────────
+// Factories — mirror tests/improvements.test.ts so the two test
+// files stay readable side-by-side.
+// ─────────────────────────────────────────────────────────────────────
+
+function mk(over: Partial<FullData> = {}): FullData {
+  return {
+    measures: [], columns: [], relationships: [], functions: [],
+    calcGroups: [], tables: [], pages: [], hiddenPages: [],
+    allPages: [], expressions: [], compatibilityLevel: null,
+    modelProperties: {
+      name: "m", description: "Test model.", culture: "", sourceQueryCulture: "",
+      discourageImplicitMeasures: false, valueFilterBehavior: "",
+      cultures: [], defaultPowerBIDataSourceVersion: "",
+    },
+    totals: {
+      measuresInModel: 0, measuresDirect: 0, measuresIndirect: 0, measuresUnused: 0,
+      columnsInModel: 0, columnsDirect: 0, columnsIndirect: 0, columnsUnused: 0,
+      relationships: 0, functions: 0, calcGroups: 0, tables: 0, pages: 0, visuals: 0,
+    },
+    ...over,
+  } as FullData;
+}
+
+function mkMeasure(over: Partial<ModelMeasure> = {}): ModelMeasure {
+  return {
+    name: "M", table: "T", daxExpression: "1", formatString: "", description: "",
+    displayFolder: "", daxDependencies: [], dependedOnBy: [], usedIn: [],
+    usageCount: 0, pageCount: 0, status: "unused", externalProxy: null,
+    ...over,
+  };
+}
+
+const FIXED_DATE = new Date("2026-05-17T00:00:00Z");
+
+// ─────────────────────────────────────────────────────────────────────
+// Header / boilerplate invariants — apply to all three categories
+// ─────────────────────────────────────────────────────────────────────
+
+test("buildCleanupPrompt — emits ISO date stamp from injected `now`", () => {
+  const md = buildCleanupPrompt(mk(), "measures-all", { now: FIXED_DATE });
+  assert.ok(md.includes("2026-05-17"), "expected ISO-8601 date in prompt body");
+  assert.ok(!md.includes("2026-05-17T"), "date should be sliced to YYYY-MM-DD");
+});
+
+test("buildCleanupPrompt — every category includes the six safety constraints", () => {
+  for (const cat of ["unused-measures", "dead-chain-measures", "measures-all"] as const) {
+    const md = buildCleanupPrompt(mk(), cat, { now: FIXED_DATE });
+    assert.ok(md.includes("Safety constraints"), `${cat}: missing safety section`);
+    assert.ok(md.includes("Confirm with me before each deletion"), `${cat}: missing rule 1`);
+    assert.ok(md.includes("Stage 1 (directly unused)"), `${cat}: missing rule 2 (Stage 1 first)`);
+    assert.ok(md.includes("EXTERNALMEASURE("), `${cat}: missing rule 3 (EXTERNALMEASURE guard)`);
+    assert.ok(md.includes("`_`"), `${cat}: missing rule 4 (helper-measure flag)`);
+    assert.ok(md.includes("$model.SaveChanges()"), `${cat}: missing rule 5 (save once)`);
+    assert.ok(md.includes("Ctrl+Z does NOT"), `${cat}: missing rule 6 (no-undo warning)`);
+  }
+});
+
+test("buildCleanupPrompt — every category points at pbi-desktop as recommended tool", () => {
+  for (const cat of ["unused-measures", "dead-chain-measures", "measures-all"] as const) {
+    const md = buildCleanupPrompt(mk(), cat, { now: FIXED_DATE });
+    assert.ok(md.includes("`pbi-desktop`"), `${cat}: missing pbi-desktop recommendation`);
+    assert.ok(md.includes("Tabular Editor CLI"), `${cat}: missing Tabular Editor fallback`);
+    assert.ok(md.includes("TOM via PowerShell"), `${cat}: missing TOM fallback`);
+  }
+});
+
+test("buildCleanupPrompt — verification section tells user to re-open project", () => {
+  const md = buildCleanupPrompt(mk(), "measures-all", { now: FIXED_DATE });
+  assert.ok(md.includes("## Verification"));
+  assert.ok(md.includes("Re-open the `.pbip`"));
+  assert.ok(md.includes("git reset --hard"));
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// Stage 1 — directly unused measures
+// ─────────────────────────────────────────────────────────────────────
+
+test("buildCleanupPrompt — Stage 1 lists `status: 'unused'` measures as bullet entries", () => {
+  const data = mk({
+    measures: [
+      mkMeasure({ table: "Sales", name: "Old Total", daxExpression: "SUM(Sales[Amount])", status: "unused" }),
+      mkMeasure({ table: "Sales", name: "Live", daxExpression: "SUM(Sales[Amount])", status: "direct" }),
+    ],
+  });
+  const md = buildCleanupPrompt(data, "unused-measures", { now: FIXED_DATE });
+  assert.ok(md.includes("- `Sales[Old Total]`"), "missing Stage 1 bullet for Old Total");
+  assert.ok(!md.includes("- `Sales[Live]`"), "Live measure (status:direct) should not appear in Stage 1");
+  assert.ok(md.includes("Stage 1 — directly unused (1 measure)"), "expected singular count");
+  assert.ok(!md.includes("SUM(Sales[Amount])"), "DAX body should NOT be embedded — AI reads it from the live model");
+  assert.ok(!md.includes("```dax"), "no dax-fenced blocks in the prompt body");
+});
+
+test("buildCleanupPrompt — Stage 1 with zero candidates emits the placeholder", () => {
+  const md = buildCleanupPrompt(mk(), "unused-measures", { now: FIXED_DATE });
+  assert.ok(md.includes("Stage 1 — directly unused (0 measures)"));
+  assert.ok(md.includes("_(none flagged)_"));
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// Stage 2 — dead-chain measures
+// ─────────────────────────────────────────────────────────────────────
+
+test("buildCleanupPrompt — Stage 2 lists dead-chain measures (status: indirect, no live caller)", () => {
+  const data = mk({
+    measures: [
+      // Unused top-of-chain → Stage 1
+      mkMeasure({ table: "T", name: "Dead", status: "unused", daxDependencies: ["Dead-Helper"] }),
+      // Only reachable from Dead → Stage 2
+      mkMeasure({ table: "T", name: "Dead-Helper", status: "indirect" }),
+      // Direct, reachable → not in any stage
+      mkMeasure({ table: "T", name: "Live", status: "direct", daxDependencies: ["Live-Helper"] }),
+      mkMeasure({ table: "T", name: "Live-Helper", status: "indirect" }),
+    ],
+  });
+  const md = buildCleanupPrompt(data, "dead-chain-measures", { now: FIXED_DATE });
+  assert.ok(md.includes("- `T[Dead-Helper]`"), "Dead-Helper should be Stage 2");
+  assert.ok(!md.includes("- `T[Live-Helper]`"), "Live-Helper is reachable from Live, should NOT be Stage 2");
+  assert.ok(!md.includes("- `T[Dead]`"), "Dead is Stage 1, should NOT appear in a dead-chain-only prompt");
+});
+
+test("buildCleanupPrompt — dead-chain-only category warns 'This is Stage 2 work' in the goal", () => {
+  const md = buildCleanupPrompt(mk(), "dead-chain-measures", { now: FIXED_DATE });
+  assert.ok(md.includes("This is Stage 2 work"), "Stage-2-only prompt must warn about Stage 1 ordering up front");
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// Combined — measures-all (ordering matters)
+// ─────────────────────────────────────────────────────────────────────
+
+test("buildCleanupPrompt — measures-all emits Stage 1 strictly before Stage 2", () => {
+  const data = mk({
+    measures: [
+      mkMeasure({ table: "T", name: "S1", status: "unused", daxDependencies: ["S2"] }),
+      mkMeasure({ table: "T", name: "S2", status: "indirect" }),
+    ],
+  });
+  const md = buildCleanupPrompt(data, "measures-all", { now: FIXED_DATE });
+  const s1Idx = md.indexOf("### Stage 1");
+  const s2Idx = md.indexOf("### Stage 2");
+  assert.ok(s1Idx >= 0, "Stage 1 header must appear");
+  assert.ok(s2Idx >= 0, "Stage 2 header must appear");
+  assert.ok(s1Idx < s2Idx, `Stage 1 (@${s1Idx}) must come before Stage 2 (@${s2Idx})`);
+  // And the dead-chain bullet must be after Stage 2 header, not before.
+  const s2ItemIdx = md.indexOf("- `T[S2]`");
+  assert.ok(s2ItemIdx > s2Idx, "S2 dead-chain bullet must render under the Stage 2 header");
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// EXTERNALMEASURE exclusion — the load-bearing safety filter
+// ─────────────────────────────────────────────────────────────────────
+
+test("buildCleanupPrompt — EXTERNALMEASURE proxies are NEVER in the kill list, even when status:unused", () => {
+  const data = mk({
+    measures: [
+      mkMeasure({
+        table: "Remote", name: "Remote Revenue",
+        daxExpression: "EXTERNALMEASURE(\"Revenue\", DOUBLE, \"DirectQuery to AS - Sales\")",
+        status: "unused",
+        externalProxy: {
+          remoteName: "Revenue", type: "DOUBLE",
+          externalModel: "DirectQuery to AS - Sales", cluster: null,
+        },
+      }),
+      mkMeasure({ table: "Sales", name: "Legit Unused", status: "unused", daxExpression: "0" }),
+    ],
+  });
+  const md = buildCleanupPrompt(data, "measures-all", { now: FIXED_DATE });
+  assert.ok(!md.includes("- `Remote[Remote Revenue]`"),
+    "EXTERNALMEASURE-bound measure must not appear in kill targets even when status:unused");
+  assert.ok(md.includes("- `Sales[Legit Unused]`"),
+    "non-proxy unused measure should still be flagged");
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// Auto-date exclusion — matches improvements.ts userMeasures filter
+// ─────────────────────────────────────────────────────────────────────
+
+test("buildCleanupPrompt — measures on auto-date tables are excluded", () => {
+  const data = mk({
+    tables: [
+      { name: "LocalDateTable_x", description: "", isCalcGroup: false, origin: "auto-date" as const,
+        isCalculatedTable: false, parameterKind: null, columnCount: 0, measureCount: 0, keyCount: 0,
+        fkCount: 0, hiddenColumnCount: 0, columns: [], measures: [], relationships: [],
+        partitions: [], hierarchies: [] } as any,
+      { name: "Sales", description: "", isCalcGroup: false, origin: "user" as const,
+        isCalculatedTable: false, parameterKind: null, columnCount: 0, measureCount: 0, keyCount: 0,
+        fkCount: 0, hiddenColumnCount: 0, columns: [], measures: [], relationships: [],
+        partitions: [], hierarchies: [] } as any,
+    ],
+    measures: [
+      mkMeasure({ table: "LocalDateTable_x", name: "Auto Year Total", status: "unused" }),
+      mkMeasure({ table: "Sales", name: "Old", status: "unused" }),
+    ],
+  });
+  const md = buildCleanupPrompt(data, "unused-measures", { now: FIXED_DATE });
+  assert.ok(!md.includes("- `LocalDateTable_x[Auto Year Total]`"),
+    "auto-date table measures must never appear in the kill list");
+  assert.ok(md.includes("- `Sales[Old]`"),
+    "user-table measures with status:unused should still appear");
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// Output shape — final byte-level sanity
+// ─────────────────────────────────────────────────────────────────────
+
+test("buildCleanupPrompt — output ends with a single trailing newline", () => {
+  const md = buildCleanupPrompt(mk(), "unused-measures", { now: FIXED_DATE });
+  assert.ok(md.endsWith("\n"), "prompt should end with newline (POSIX-friendly)");
+  assert.ok(!md.endsWith("\n\n"), "prompt should not have double trailing newline");
+});
+
+test("buildCleanupPrompt — title varies per category", () => {
+  const u = buildCleanupPrompt(mk(), "unused-measures", { now: FIXED_DATE });
+  const d = buildCleanupPrompt(mk(), "dead-chain-measures", { now: FIXED_DATE });
+  const a = buildCleanupPrompt(mk(), "measures-all", { now: FIXED_DATE });
+  assert.ok(u.startsWith("# Cleanup task — delete unused Power BI measures\n"));
+  assert.ok(d.startsWith("# Cleanup task — delete dead-chain Power BI measures\n"));
+  assert.ok(a.startsWith("# Cleanup task — delete unused + dead-chain Power BI measures\n"));
+});
diff --git a/tests/cli-prompt.test.ts b/tests/cli-prompt.test.ts
new file mode 100644
index 0000000..e358f66
--- /dev/null
+++ b/tests/cli-prompt.test.ts
@@ -0,0 +1,78 @@
+/**
+ * CLI smoke test — `powerbi-lineage prompt …` subcommand.
+ *
+ * Spawned as a subprocess because runPromptSubcommand calls
+ * process.exit() — importing it directly would kill the test runner.
+ * The compiled app.js lives at dist-test/src/app.js under the test
+ * tsconfig output dir, same layout as the other server-side modules.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const APP_JS = path.resolve("dist-test/src/app.js");
+const FIXTURE = "test/Health_and_Safety.Report";
+const APP_EXISTS = fs.existsSync(APP_JS);
+const FIXTURE_EXISTS = fs.existsSync(path.resolve(FIXTURE));
+
+function runCli(args: string[]): { code: number | null; stdout: string; stderr: string } {
+  const r = spawnSync(process.execPath, [APP_JS, ...args], {
+    encoding: "utf8",
+    // Generous — the parser has to walk the H&S model.
+    timeout: 30_000,
+  });
+  return { code: r.status, stdout: r.stdout || "", stderr: r.stderr || "" };
+}
+
+test("CLI prompt — missing --category exits non-zero with usage on stderr", { skip: !APP_EXISTS }, () => {
+  const r = runCli(["prompt", "--report", "anywhere"]);
+  assert.notEqual(r.code, 0, "expected non-zero exit for missing --category");
+  assert.ok(r.stderr.includes("--category"), "stderr should mention --category");
+});
+
+test("CLI prompt — unknown --category exits non-zero", { skip: !APP_EXISTS }, () => {
+  const r = runCli(["prompt", "--category", "nonsense", "--report", "anywhere"]);
+  assert.notEqual(r.code, 0, "expected non-zero exit for unknown category");
+});
+
+test("CLI prompt — missing --report exits non-zero", { skip: !APP_EXISTS }, () => {
+  const r = runCli(["prompt", "--category", "unused-measures"]);
+  assert.notEqual(r.code, 0, "expected non-zero exit for missing --report");
+  assert.ok(r.stderr.includes("--report"), "stderr should mention --report");
+});
+
+test("CLI prompt — --help prints usage and exits 0", { skip: !APP_EXISTS }, () => {
+  const r = runCli(["prompt", "--help"]);
+  assert.equal(r.code, 0, "expected exit 0 on --help");
+  assert.ok(r.stderr.includes("--category") || r.stdout.includes("--category"),
+    "usage output should describe --category");
+});
+
+test("CLI prompt — emits prompt to stdout against H&S fixture", { skip: !APP_EXISTS || !FIXTURE_EXISTS }, () => {
+  const r = runCli(["prompt", "--category", "measures-all", "--report", path.resolve(FIXTURE)]);
+  assert.equal(r.code, 0, `expected exit 0, got ${r.code}. stderr: ${r.stderr}`);
+  assert.ok(r.stdout.startsWith("# Cleanup task"),
+    "expected prompt to start with the Cleanup task H1");
+  assert.ok(r.stdout.includes("## Safety constraints"),
+    "expected safety constraints section");
+  assert.ok(r.stdout.includes("## Targets"),
+    "expected Targets section");
+});
+
+test("CLI prompt — --output writes to file instead of stdout", { skip: !APP_EXISTS || !FIXTURE_EXISTS }, () => {
+  const outFile = path.resolve("dist-test/cli-prompt-output.tmp.md");
+  // Best-effort cleanup if a prior run crashed mid-flight.
+  try { fs.unlinkSync(outFile); } catch {}
+  const r = runCli(["prompt", "--category", "unused-measures", "--report", path.resolve(FIXTURE), "--output", outFile]);
+  try {
+    assert.equal(r.code, 0, `expected exit 0, got ${r.code}. stderr: ${r.stderr}`);
+    assert.equal(r.stdout, "", "stdout should be empty when --output is set");
+    assert.ok(fs.existsSync(outFile), "output file should exist after run");
+    const body = fs.readFileSync(outFile, "utf8");
+    assert.ok(body.includes("# Cleanup task"), "file should contain the prompt header");
+  } finally {
+    try { fs.unlinkSync(outFile); } catch {}
+  }
+});
diff --git a/tests/improvements.test.ts b/tests/improvements.test.ts
index 6bec9f5..a751ca9 100644
--- a/tests/improvements.test.ts
+++ b/tests/improvements.test.ts
@@ -208,6 +208,69 @@ test("generateImprovementsMd — auto-date entry appears when auto-date tables e
   assert.ok(md.includes("Auto-Date/Time is enabled"));
 });
 
+// ─────────────────────────────────────────────────────────────────────
+// AI cleanup prompt — embedded <details> block per finding
+// ─────────────────────────────────────────────────────────────────────
+
+test("generateImprovementsMd — unused-measures finding embeds AI cleanup <details> block", () => {
+  const data = mk({
+    measures: [
+      mkMeasure({ table: "Sales", name: "Old Total", status: "unused", daxExpression: "SUM(Sales[X])" }),
+    ],
+  });
+  const md = generateImprovementsMd(data, "t");
+  assert.ok(md.includes("### 1 unused measure"), "expected unused-measures finding to render");
+  assert.ok(md.includes("<details>"), "expected <details> wrapper to render");
+  assert.ok(md.includes("AI cleanup prompt (copy + paste"), "expected summary text");
+  assert.ok(md.includes("# Cleanup task — delete unused Power BI measures"),
+    "expected the prompt's H1 title to be embedded");
+  assert.ok(md.includes("Sales[Old Total]"), "expected the kill target in the embedded prompt");
+});
+
+test("generateImprovementsMd — dead-chain finding embeds its own prompt block (Stage-2-only)", () => {
+  const data = mk({
+    measures: [
+      mkMeasure({ name: "Top", status: "unused", daxDependencies: ["Helper"] }),
+      mkMeasure({ name: "Helper", status: "indirect" }),
+    ],
+  });
+  const md = generateImprovementsMd(data, "t");
+  assert.ok(md.includes("only reachable through unused chains"), "expected dead-chain finding");
+  // Two findings (unused + dead-chain) → two <details> blocks
+  const detailsCount = (md.match(/<details>/g) || []).length;
+  assert.equal(detailsCount, 2, "expected one <details> per finding (unused + dead-chain)");
+  assert.ok(md.includes("# Cleanup task — delete dead-chain Power BI measures"),
+    "expected dead-chain-specific prompt header");
+});
+
+test("generateImprovementsMd — no <details> block when no unused / dead-chain findings", () => {
+  const md = generateImprovementsMd(mk(), "t");
+  assert.ok(!md.includes("<details>"), "empty model should not embed any cleanup prompt");
+});
+
+test("generateImprovementsMd — EXTERNALMEASURE proxy never appears in the embedded prompt body", () => {
+  const data = mk({
+    measures: [
+      mkMeasure({
+        table: "Remote", name: "Remote Revenue", status: "unused",
+        daxExpression: "EXTERNALMEASURE(\"R\", DOUBLE, \"DirectQuery to AS - X\")",
+        externalProxy: { remoteName: "R", type: "DOUBLE", externalModel: "DirectQuery to AS - X", cluster: null },
+      }),
+      mkMeasure({ table: "Sales", name: "Legit", status: "unused", daxExpression: "0" }),
+    ],
+  });
+  const md = generateImprovementsMd(data, "t");
+  // Find just the <details> block content
+  const start = md.indexOf("<details>");
+  const end = md.indexOf("</details>");
+  assert.ok(start >= 0 && end > start, "expected a <details> block to be present");
+  const block = md.slice(start, end);
+  assert.ok(!block.includes("Remote[Remote Revenue]"),
+    "EXTERNALMEASURE-bound measure must not appear in the embedded kill list");
+  assert.ok(block.includes("Sales[Legit]"),
+    "non-proxy unused measure should be in the embedded kill list");
+});
+
 // ─────────────────────────────────────────────────────────────────────
 // Fixture integration — H&S
 // ─────────────────────────────────────────────────────────────────────
diff --git a/tsconfig.browser.json b/tsconfig.browser.json
index 2b930cc..68952d0 100644
--- a/tsconfig.browser.json
+++ b/tsconfig.browser.json
@@ -26,6 +26,7 @@
     "src/data-builder.ts",
     "src/md-generator.ts",
     "src/improvements.ts",
+    "src/ai-prompts.ts",
     "src/report-scanner.ts",
     "src/pbir-reader.ts",
     "src/render/**/*"