@liustack/pptwise 0.22.0 → 0.24.0

package/dist/cli.js

@@ -1,66 +1,63 @@
 #!/usr/bin/env node
 import {
-  PptxIRV3Schema,
   VERSION,
   assembleDeck,
   buildAssetBrief,
+  copyThemePreset,
   disassembleDeck,
   extractBrandTheme,
+  forkTheme,
   formatInvalidSpecError,
-  migrateBannerHeadingToTwoColumn,
-  migrateBloomToClassroom,
-  migrateChromeToBranding,
-  migrateDeckPlanToSpec,
-  migrateIrV3ToV4,
-  migrateLogoWallToImageGrid,
   parseBrandThemeFile,
-  registerBrandThemeFile,
   resolveSpecThemeId,
   slugify,
   specJsonSchema,
   validateSpec
-} from "./chunk-M35M4QUC.js";
+} from "./chunk-2CA3JRFR.js";
 import {
   installNodePlatform,
   isMissingModuleError,
   proxyFetch
-} from "./chunk-3ZUKISTY.js";
+} from "./chunk-VEZGVYJS.js";
 import {
   AUDIENCE_VALUES,
   CANONICAL_THEME_IDS,
   CANVAS_H_PX,
   CANVAS_W_PX,
   FORMAT_BY_MIME,
+  LAYOUT_REGISTRY,
   MIME_BY_SNIFFED_FORMAT,
   NARRATIVE_PRESETS,
   PACING_BUDGETS,
   PptwiseError,
   STRATEGY_DEFINITIONS,
-  StyleOverrideSchema,
-  assertContrastFloor,
+  THEME_ID_CONSTRAINT,
+  THEME_ID_PATTERN,
+  THEME_OCCASIONS,
+  ThemeFileSchema,
   auditDeck,
   formatIssues,
   formatWarnings,
   generatePptx,
-  getInstalledThemeIds,
+  getThemeDefinition,
+  installThemeFile,
   irJsonSchema,
   listThemes,
   renderSlideSvg,
   resolveNarrative,
   sniffImageFormat,
-  styleJsonSchema,
   validateIr
-} from "./chunk-WL5KWYKS.js";
+} from "./chunk-G7WQ7KSP.js";
 import {
   getPlatform
-} from "./chunk-VUOLBHD7.js";
+} from "./chunk-RQUKZYSH.js";
 
 // src/cli.ts
 import { Command } from "commander";
 
 // src/cli/commands.ts
-import { mkdir as mkdir4, readdir as readdir3, readFile as readFile6, rm, writeFile as writeFile3 } from "fs/promises";
-import { basename as basename4, dirname as dirname3, join as join5, relative as relative2, resolve as resolve6 } from "path";
+import { mkdir as mkdir5, readFile as readFile6, rm as rm2, writeFile as writeFile4 } from "fs/promises";
+import { basename as basename5, dirname as dirname5, join as join7, relative as relative2, resolve as resolve7 } from "path";
 
 // src/cli/config.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -119,8 +116,8 @@ function pptwiseHome(opts = {}) {
 }
 function migrateLegacyHomes(home, nextDir) {
   if (existsSync(nextDir)) return;
-  for (const dirname5 of LEGACY_HOME_DIRNAMES) {
-    const legacy = join(home, dirname5);
+  for (const dirname8 of LEGACY_HOME_DIRNAMES) {
+    const legacy = join(home, dirname8);
     if (existsSync(legacy)) {
       copyLegacyHome(legacy, nextDir);
       return;
@@ -448,14 +445,10 @@ function missingKeysError(kind) {
 
 // src/cli/config.ts
 var ConfigSchema = z2.object({
-  theme: z2.string().optional(),
-  style: StyleOverrideSchema.optional(),
   decksDir: z2.string().optional(),
   outDir: z2.string().optional()
 }).strict();
 var UserConfigSchema = z2.object({
-  theme: z2.string().optional(),
-  style: StyleOverrideSchema.optional(),
   decksDir: z2.string().optional(),
   images: ImagesConfigSchema.optional()
 }).strict();
@@ -606,7 +599,6 @@ async function resolveLocalAssets(ir, baseDir, workspaceAssetsDir) {
 }
 
 // src/cli/deck-dir.ts
-var PLAN_FILENAME = "deck.plan.json";
 var SPEC_FILENAME = "deck.spec.json";
 var PAGES_DIRNAME = "pages";
 var ASSETS_DIRNAME = "assets";
@@ -657,18 +649,6 @@ function expectedLayoutHint() {
 }
 async function readSpecFile(dir) {
   const specPath = join3(dir, SPEC_FILENAME);
-  const planPath = join3(dir, PLAN_FILENAME);
-  const [specExists, planExists] = await Promise.all([pathExists(specPath), pathExists(planPath)]);
-  if (specExists && planExists) {
-    throw new PptwiseError(
-      `both ${SPEC_FILENAME} and ${PLAN_FILENAME} exist in ${dir} \u2014 ambiguous, refusing to guess which one wins. Delete ${PLAN_FILENAME} once you have confirmed ${SPEC_FILENAME} is correct (\`pptwise migrate\` never deletes the source file it read)`
-    );
-  }
-  if (!specExists && planExists) {
-    throw new PptwiseError(
-      `${dir} has ${PLAN_FILENAME} but no ${SPEC_FILENAME} \u2014 deck project directories now use ${SPEC_FILENAME}. Run \`pptwise migrate ${dir} -o ${dir}\` to convert it`
-    );
-  }
   let text;
   try {
     text = await readFile4(specPath, "utf8");
@@ -729,14 +709,26 @@ async function scanAssets(dir) {
   }
   return images2;
 }
+function specThemeFromRaw(spec2) {
+  if (typeof spec2 !== "object" || spec2 === null) return void 0;
+  const theme2 = spec2.theme;
+  return typeof theme2 === "string" ? theme2 : void 0;
+}
 async function readDeckDir(dir) {
   const deckDir = resolve4(dir);
+  const specPath = join3(deckDir, SPEC_FILENAME);
   const spec2 = await readSpecFile(deckDir);
+  const specTheme = specThemeFromRaw(spec2);
   const pages = await readPages(deckDir);
-  const { ir, generatedSeed, materializedLayoutCount } = assembleDeck(spec2, pages);
+  const { ir } = assembleDeck(spec2, pages);
   const images2 = await scanAssets(deckDir);
   const merged = { ...ir, assets: { images: { ...ir.assets.images, ...images2 } } };
-  return { ir: merged, generatedSeed, materializedLayoutCount, deckDir };
+  return {
+    ir: merged,
+    deckDir,
+    specPath,
+    ...specTheme !== void 0 ? { specTheme } : {}
+  };
 }
 async function writeDeckAssets(images2, outDir, sourceBaseDir) {
   const entries = Object.entries(images2);
@@ -778,6 +770,36 @@ async function writeOneAsset(id, src, assetsDir, sourceBaseDir) {
   }
 }
 
+// src/cli/theme-write.ts
+import { link, mkdir as mkdir3, rename, rm, writeFile as writeFile3 } from "fs/promises";
+import { basename as basename3, dirname as dirname2, join as join4 } from "path";
+import { randomBytes } from "crypto";
+async function writeThemeFile(path2, file, force = false, hooks) {
+  const dir = dirname2(path2);
+  await mkdir3(dir, { recursive: true });
+  const tmp = join4(dir, `.${basename3(path2)}.${randomBytes(8).toString("hex")}.tmp`);
+  try {
+    await writeFile3(tmp, JSON.stringify(file, null, 2) + "\n");
+    await hooks?.beforePublish?.(tmp, path2);
+    if (force) {
+      await rename(tmp, path2);
+      return;
+    }
+    try {
+      await link(tmp, path2);
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        throw new PptwiseError(`theme file already exists: ${path2}. Pass --force to overwrite.`);
+      }
+      throw error;
+    }
+    await rm(tmp, { force: true });
+  } catch (error) {
+    await rm(tmp, { force: true });
+    throw error;
+  }
+}
+
 // src/lib/slide-edge.ts
 var TAG = /<(\/?)(g|rect)\b([^>]*?)(\/?)>/g;
 var ATTR_CACHE = /* @__PURE__ */ new Map();
@@ -1195,6 +1217,61 @@ ${findingsDataScript}
 </html>
 `;
 }
+var CONTACT_SHEET_CSS = `
+:root { color-scheme: light; }
+* { box-sizing: border-box; }
+html, body { margin: 0; padding: 0; }
+body {
+  font: 14px/1.4 -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+  color: #111;
+  background: #f4f4f1;
+  padding: 24px;
+}
+h1 { font-size: 18px; font-weight: 600; margin: 0 0 16px; }
+table.cs { width: 100%; border-collapse: collapse; table-layout: fixed; }
+table.cs th, table.cs td { vertical-align: top; padding: 8px; }
+table.cs thead th { text-align: left; font-size: 13px; font-weight: 600; }
+table.cs tbody th { text-align: left; font-weight: 500; color: #555; width: 88px; }
+.cs-cell svg { display: block; width: 100%; height: auto; background: #fff; }
+`.trim();
+function buildContactSheetHtml(input) {
+  const { title, themes } = input;
+  const rowLabels = [];
+  for (const col of themes) {
+    for (const slide of col.slides) {
+      const label = slide.label ?? slide.type;
+      if (!rowLabels.includes(label)) rowLabels.push(label);
+    }
+  }
+  const head = themes.map((t) => `<th scope="col">${escapeHtml(t.id)}</th>`).join("");
+  const body = rowLabels.map((label) => {
+    const cells = themes.map((t, colIdx) => {
+      const slide = t.slides.find((s) => (s.label ?? s.type) === label);
+      if (!slide) return "<td></td>";
+      const svg = namespaceSvgIds(slide.svg, `t${colIdx}-${label}-`);
+      return `<td class="cs-cell">${svg}</td>`;
+    }).join("");
+    return `<tr><th scope="row">${escapeHtml(label)}</th>${cells}</tr>`;
+  }).join("");
+  const escapedTitle = escapeHtml(title);
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapedTitle} \u2014 theme comparison</title>
+<style>${CONTACT_SHEET_CSS}</style>
+</head>
+<body>
+<h1>${escapedTitle}</h1>
+<table class="cs">
+<thead><tr><th></th>${head}</tr></thead>
+<tbody>${body}</tbody>
+</table>
+</body>
+</html>
+`;
+}
 
 // src/cli/preview-manifest.ts
 var PREVIEW_MANIFEST_VERSION = 1;
@@ -1261,8 +1338,8 @@ function buildPreviewManifest(input) {
 
 // src/cli/workspace.ts
 import { existsSync as existsSync2 } from "fs";
-import { appendFile, mkdir as mkdir3, readFile as readFile5, readdir as readdir2, stat as stat2, unlink } from "fs/promises";
-import { basename as basename3, dirname as dirname2, extname as extname3, join as join4, resolve as resolve5 } from "path";
+import { appendFile, mkdir as mkdir4, readFile as readFile5, readdir as readdir2, stat as stat2, unlink } from "fs/promises";
+import { basename as basename4, dirname as dirname3, extname as extname3, join as join5, resolve as resolve5 } from "path";
 
 // src/cli/child.ts
 import {
@@ -1288,14 +1365,14 @@ function envValue(env, name) {
 }
 async function findOnPath(bin, env, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const join10 = deps.join ?? defaultJoin;
+  const join12 = deps.join ?? defaultJoin;
   const delimiter = deps.delimiter ?? defaultDelimiter;
   const tryAccess = deps.access ?? ((target, mode) => fsAccess(target, mode));
   const dirs = (envValue(env, "PATH") ?? "").split(delimiter).filter(Boolean);
   const suffixes = platform === "win32" ? [...(envValue(env, "PATHEXT") ?? DEFAULT_PATHEXT).split(";").map((ext) => ext.trim()).filter(Boolean), ""] : [""];
   for (const dir of dirs) {
     for (const suffix of suffixes) {
-      const full = join10(dir, `${bin}${suffix}`);
+      const full = join12(dir, `${bin}${suffix}`);
       try {
         await tryAccess(full, constants.X_OK);
         return full;
@@ -1567,11 +1644,11 @@ var ChildTimeoutError = class extends Error {
 async function runChild(command, args = [], options = {}) {
   const { timeoutMs, signal, ...spawnOptions } = options;
   const cwd = typeof spawnOptions.cwd === "string" ? spawnOptions.cwd : void 0;
-  const plan2 = await resolveSpawnPlan(command, args, spawnOptions.env ?? process.env, cwd);
-  return new Promise((resolve8, reject) => {
-    const child = spawnHidden(plan2.command, plan2.args, {
+  const plan = await resolveSpawnPlan(command, args, spawnOptions.env ?? process.env, cwd);
+  return new Promise((resolve9, reject) => {
+    const child = spawnHidden(plan.command, plan.args, {
       ...spawnOptions,
-      env: plan2.env ?? spawnOptions.env,
+      env: plan.env ?? spawnOptions.env,
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -1595,7 +1672,7 @@ async function runChild(command, args = [], options = {}) {
         reject(new ChildTimeoutError(timeoutMs ?? 0));
         return;
       }
-      resolve8({ code: code ?? 0, stdout, stderr });
+      resolve9({ code: code ?? 0, stdout, stderr });
     };
     const restartDrain = () => {
       if (!exited || settled) return;
@@ -1644,33 +1721,33 @@ var WORKSPACE_DIRNAME = ".pptwise";
 var LEGACY_WORKSPACE_DIRNAMES = [".pptpress", ".pptfast"];
 var WORKSPACE_IGNORE_ENTRY = `${WORKSPACE_DIRNAME}/`;
 function defaultWorkspaceDirname(anchor) {
-  if (existsSync2(join4(anchor, WORKSPACE_DIRNAME))) return WORKSPACE_DIRNAME;
+  if (existsSync2(join5(anchor, WORKSPACE_DIRNAME))) return WORKSPACE_DIRNAME;
   for (const name of LEGACY_WORKSPACE_DIRNAMES) {
-    if (existsSync2(join4(anchor, name))) return name;
+    if (existsSync2(join5(anchor, name))) return name;
   }
   return WORKSPACE_DIRNAME;
 }
-function ignoreEntryFor(dirname5) {
-  return `${dirname5}/`;
+function ignoreEntryFor(dirname8) {
+  return `${dirname8}/`;
 }
 var RENDERED_SVG_PATTERN = /^\d{3}-[a-z-]+\.svg$/;
 function deckSlug(target, isDir) {
-  const base = basename3(target);
+  const base = basename4(target);
   const name = isDir ? base : base.slice(0, base.length - extname3(base).length);
   const slug = slugify(name, "deck");
   assertSafeFileSegment(slug, "deck slug");
   return slug;
 }
 function resolveWorkspaceRoot(opts) {
-  const anchor = opts.projectConfigPath ? dirname2(resolve5(opts.projectConfigPath)) : resolve5(opts.cwd);
+  const anchor = opts.projectConfigPath ? dirname3(resolve5(opts.projectConfigPath)) : resolve5(opts.cwd);
   const configured = opts.outDir !== void 0;
-  const root = opts.outDir !== void 0 ? resolve5(anchor, opts.outDir) : join4(anchor, defaultWorkspaceDirname(anchor));
+  const root = opts.outDir !== void 0 ? resolve5(anchor, opts.outDir) : join5(anchor, defaultWorkspaceDirname(anchor));
   return { anchor, root, configured };
 }
 function resolveWorkspaceLocation(opts) {
   const { anchor, root, configured } = resolveWorkspaceRoot(opts);
   const slug = deckSlug(opts.target, opts.isDir);
-  return { anchor, root, dir: join4(root, slug), slug, configured };
+  return { anchor, root, dir: join5(root, slug), slug, configured };
 }
 var runGitDefault = async (args, cwd) => {
   try {
@@ -1692,7 +1769,7 @@ async function gitIgnoreStatus(dir, entry, runGit = runGitDefault) {
 async function inspectWorkspace(opts) {
   const { anchor, root, configured } = resolveWorkspaceRoot(opts);
   if (configured) return { anchor, root, configured, ignore: "skipped" };
-  const ignore = await gitIgnoreStatus(anchor, ignoreEntryFor(basename3(root)), opts.runGit);
+  const ignore = await gitIgnoreStatus(anchor, ignoreEntryFor(basename4(root)), opts.runGit);
   return { anchor, root, configured, ignore };
 }
 async function ensureGitIgnored(dir, entry, runGit = runGitDefault) {
@@ -1701,9 +1778,9 @@ async function ensureGitIgnored(dir, entry, runGit = runGitDefault) {
   if (status === "not-a-repo") return { kind: "no-repo" };
   const common = await runGit(["rev-parse", "--git-common-dir"], dir);
   if (common === null || common.code !== 0 || common.stdout.trim() === "") return { kind: "no-repo" };
-  const excludePath = join4(resolve5(dir, common.stdout.trim()), "info", "exclude");
+  const excludePath = join5(resolve5(dir, common.stdout.trim()), "info", "exclude");
   try {
-    await mkdir3(dirname2(excludePath), { recursive: true });
+    await mkdir4(dirname3(excludePath), { recursive: true });
     let existing = "";
     try {
       existing = await readFile5(excludePath, "utf8");
@@ -1729,7 +1806,7 @@ async function exists(path2) {
 async function prepareWorkspaceDir(location, opts = {}) {
   const rootExisted = await exists(location.root);
   try {
-    await mkdir3(location.dir, { recursive: true });
+    await mkdir4(location.dir, { recursive: true });
   } catch (e) {
     throw new PptwiseError(
       `cannot create the output directory ${location.dir}: ${e.message}
@@ -1737,7 +1814,7 @@ async function prepareWorkspaceDir(location, opts = {}) {
     );
   }
   if (rootExisted || location.configured || opts.gitIgnore === false) return [];
-  const ignoreEntry = ignoreEntryFor(basename3(location.root));
+  const ignoreEntry = ignoreEntryFor(basename4(location.root));
   const outcome = await ensureGitIgnored(location.anchor, ignoreEntry, opts.runGit);
   if (outcome.kind === "appended") {
     return [
@@ -1759,7 +1836,7 @@ async function pruneRenderedSvgs(dir) {
     return 0;
   }
   const stale = entries.filter((name) => RENDERED_SVG_PATTERN.test(name));
-  await Promise.all(stale.map((name) => unlink(join4(dir, name))));
+  await Promise.all(stale.map((name) => unlink(join5(dir, name))));
   return stale.length;
 }
 var WORKSPACE_IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp"]);
@@ -1776,7 +1853,7 @@ async function scanWorkspaceAssets(assetsDir) {
   for (const name of names) {
     const ext = extname3(name).toLowerCase();
     if (ext === ".json" || !WORKSPACE_IMAGE_EXTS.has(ext)) continue;
-    const id = basename3(name, extname3(name));
+    const id = basename4(name, extname3(name));
     const previous = sourceFile.get(id);
     if (previous !== void 0) {
       throw new PptwiseError(
@@ -1784,63 +1861,336 @@ async function scanWorkspaceAssets(assetsDir) {
       );
     }
     sourceFile.set(id, name);
-    images2[id] = { src: join4(assetsDir, name) };
+    images2[id] = { src: join5(assetsDir, name) };
   }
   return images2;
 }
 
-// src/cli/commands.ts
-async function loadStyleFile(path2) {
-  const raw = await loadIrFile(path2);
-  const r = StyleOverrideSchema.safeParse(raw);
-  if (!r.success) {
-    const detail = r.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
-    throw new PptwiseError(`invalid style file ${path2}:
-${detail}`);
+// src/cli/theme-resolve.ts
+import { dirname as dirname4, join as join6, resolve as resolve6 } from "path";
+var WORKSPACE_THEMES_DIRNAME = "themes";
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) return value.map(sortKeysDeep);
+  if (value !== null && typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = sortKeysDeep(value[key]);
+    }
+    return sorted;
   }
-  return r.data;
+  return value;
 }
-async function loadThemeFile(path2) {
+function menusEqual(a, b) {
+  return JSON.stringify(sortKeysDeep(a)) === JSON.stringify(sortKeysDeep(b));
+}
+function assertThemeId(id) {
+  if (!THEME_ID_PATTERN.test(id)) {
+    throw new PptwiseError(`invalid theme id "${id}". ${THEME_ID_CONSTRAINT}`);
+  }
+}
+async function readThemeFile(path2) {
   const raw = await loadIrFile(path2, "theme");
-  return registerBrandThemeFile(parseBrandThemeFile(raw, path2));
+  return parseBrandThemeFile(raw, path2);
+}
+function isCanonicalThemeId(name) {
+  return CANONICAL_THEME_IDS.includes(name);
+}
+function menuForThemeId(id) {
+  const def = getThemeDefinition(id);
+  return def.menu;
 }
-async function registerDeckThemeFile(deckDir) {
-  const themePath = join5(deckDir, THEME_FILENAME);
-  if (await pathExists(themePath)) await loadThemeFile(themePath);
+function publicStyle(style, id) {
+  const colors = { ...style.colors };
+  const fonts = {
+    heading: [...style.fonts.heading],
+    body: [...style.fonts.body]
+  };
+  if (style.fonts.mono !== void 0) fonts.mono = [...style.fonts.mono];
+  const out = {
+    id,
+    colors,
+    fonts,
+    defaultBackgrounds: structuredClone(style.defaultBackgrounds)
+  };
+  if (style.allowCustomBackground !== void 0) out.allowCustomBackground = style.allowCustomBackground;
+  if (style.shape !== void 0) {
+    const shape = {};
+    if (style.shape.radius !== void 0) shape.radius = style.shape.radius;
+    if (style.shape.gapScale !== void 0) shape.gapScale = style.shape.gapScale;
+    if (style.shape.typeScale !== void 0) shape.typeScale = style.shape.typeScale;
+    if (Object.keys(shape).length > 0) out.shape = shape;
+  }
+  return out;
+}
+function themeFileFromPreset(presetId, identity) {
+  const copy = copyThemePreset(presetId, identity.id);
+  const file = {
+    version: 2,
+    id: identity.id,
+    label: identity.label ?? copy.label,
+    style: publicStyle(copy.style, identity.id),
+    brand: copy.brand,
+    occasions: copy.occasions !== void 0 ? [...copy.occasions] : void 0,
+    identity: copy.identity,
+    menu: copy.menu
+  };
+  return ThemeFileSchema.parse(file);
+}
+async function tryParseThemeFile(path2) {
+  const raw = await loadIrFile(path2, "theme");
+  const parsed = ThemeFileSchema.safeParse(raw);
+  return parsed.success ? parsed.data : void 0;
+}
+async function acceptThemeFile(path2, file) {
+  installThemeFile(file);
+  return { kind: "file", id: file.id, path: path2, file };
+}
+async function acceptIfNameMatches(path2, name, file) {
+  if (file.id !== name) return void 0;
+  return acceptThemeFile(path2, file);
+}
+async function resolveDeckThemeFile(deckDir, name) {
+  const boundPath = join6(deckDir, THEME_FILENAME);
+  if (await pathExists(boundPath)) {
+    const file = await readThemeFile(boundPath);
+    const hit = await acceptIfNameMatches(boundPath, name, file);
+    if (hit !== void 0) return hit;
+  }
+  const namedTheme = join6(deckDir, `${name}.theme.json`);
+  if (await pathExists(namedTheme)) {
+    const file = await readThemeFile(namedTheme);
+    const hit = await acceptIfNameMatches(namedTheme, name, file);
+    if (hit !== void 0) return hit;
+  }
+  const namedJson = join6(deckDir, `${name}.json`);
+  if (await pathExists(namedJson)) {
+    const file = await tryParseThemeFile(namedJson);
+    if (file !== void 0) {
+      const hit = await acceptIfNameMatches(namedJson, name, file);
+      if (hit !== void 0) return hit;
+    }
+  }
+  return void 0;
+}
+async function resolveWorkspaceThemeFile(startDir, name) {
+  let dir = resolve6(startDir);
+  for (; ; ) {
+    const candidates = [
+      join6(dir, WORKSPACE_THEMES_DIRNAME, `${name}.theme.json`),
+      join6(dir, WORKSPACE_THEMES_DIRNAME, `${name}.json`),
+      join6(dir, WORKSPACE_THEMES_DIRNAME, name, THEME_FILENAME)
+    ];
+    for (const candidate of candidates) {
+      if (!await pathExists(candidate)) continue;
+      const isLooseJson = candidate.endsWith(`${name}.json`) && !candidate.endsWith(`${name}.theme.json`);
+      if (isLooseJson) {
+        const file2 = await tryParseThemeFile(candidate);
+        if (file2 !== void 0) {
+          const hit2 = await acceptIfNameMatches(candidate, name, file2);
+          if (hit2 !== void 0) return hit2;
+        }
+        continue;
+      }
+      const file = await readThemeFile(candidate);
+      const hit = await acceptIfNameMatches(candidate, name, file);
+      if (hit !== void 0) return hit;
+    }
+    const parent = dirname4(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
 }
-function describeThemeSource(opts, projectHit, userHit) {
-  if (opts.theme !== void 0) return "--theme";
-  if (projectHit?.config.theme !== void 0) return projectHit.path;
-  if (userHit?.config.theme !== void 0) return userHit.path;
-  return "the deck's own theme";
+async function resolveThemeByName(name, opts) {
+  assertThemeId(name);
+  if (opts.deckDir !== void 0) {
+    const deckHit = await resolveDeckThemeFile(opts.deckDir, name);
+    if (deckHit !== void 0) return deckHit;
+  }
+  const workspaceHit = await resolveWorkspaceThemeFile(opts.startDir, name);
+  if (workspaceHit !== void 0) return workspaceHit;
+  if (isCanonicalThemeId(name)) return { kind: "builtin", id: name };
+  const places = [
+    opts.deckDir !== void 0 ? `deck directory ${opts.deckDir}` : void 0,
+    `workspace ${WORKSPACE_THEMES_DIRNAME}/ walking up from ${resolve6(opts.startDir)}`,
+    "built-in presets"
+  ].filter((place) => place !== void 0);
+  throw new PptwiseError(`unknown theme "${name}". Searched ${places.join(", ")}.`);
+}
+var REBIND_SUFFIX = "A same-menu color fork is allowed. A different menu is a new theme. Start over from the theme layer (keep intent, narrative, and harvested materials, rewrite the spec).";
+async function assertThemeRebind(deckDir, resolved) {
+  if (deckDir === void 0) return;
+  const boundPath = resolve6(join6(deckDir, THEME_FILENAME));
+  if (!await pathExists(boundPath)) return;
+  if (resolved.kind === "file" && resolve6(resolved.path) === boundPath) return;
+  const bound = parseBrandThemeFile(await loadIrFile(boundPath, "theme"), boundPath);
+  const nextId = resolved.id;
+  const nextMenu = resolved.kind === "file" ? resolved.file.menu : menuForThemeId(resolved.id);
+  if (menusEqual(bound.menu, nextMenu)) return;
+  throw new PptwiseError(`cannot rebind theme "${bound.id}" to "${nextId}": menus differ. ${REBIND_SUFFIX}`);
+}
+async function registerThemeSelection(name, opts) {
+  if (name === void 0 || name.length === 0) return void 0;
+  return resolveThemeByName(name, opts);
+}
+function themeNameFromUnknown(raw) {
+  if (typeof raw !== "object" || raw === null) return void 0;
+  const theme2 = raw.theme;
+  return typeof theme2 === "string" ? theme2 : void 0;
+}
+
+// src/cli/fixtures/theme-try-sample.ts
+var THEME_TRY_SAMPLE_IR = {
+  version: "5",
+  filename: "northstar-review",
+  theme: { id: "consulting" },
+  slides: [
+    {
+      type: "cover",
+      heading: "Northstar Review",
+      subheading: "Q3 operating report for the board"
+    },
+    {
+      type: "chapter",
+      heading: "The Quarter"
+    },
+    {
+      type: "content",
+      kind: "points",
+      heading: "What we decided",
+      components: [
+        {
+          type: "bullets",
+          items: [
+            "Hold hiring at 42",
+            "Cut the analytics rebuild",
+            "Share the support rotation"
+          ]
+        }
+      ]
+    },
+    {
+      type: "content",
+      kind: "list",
+      heading: "Open workstreams",
+      components: [
+        {
+          type: "bullets",
+          items: [
+            "EU residency addendum",
+            "Partner invite flow",
+            "Invoice localization"
+          ]
+        }
+      ]
+    },
+    {
+      type: "content",
+      kind: "comparison",
+      heading: "Build vs buy",
+      components: [
+        {
+          type: "comparison",
+          columns: ["Build", "Buy"],
+          rows: [
+            { label: "Time to first report", cells: ["14 weeks", "3 weeks"] },
+            { label: "Year-one cost", cells: ["$420k", "$180k"] },
+            { label: "Lock-in", cells: ["None", "Vendor roadmap"] }
+          ]
+        }
+      ]
+    },
+    {
+      type: "content",
+      kind: "process",
+      heading: "How we ship",
+      components: [
+        {
+          type: "steps",
+          items: [
+            { title: "Scope", text: "One page, one owner" },
+            { title: "Build", text: "Two-week slices" },
+            { title: "Prove", text: "A number in production" }
+          ]
+        }
+      ]
+    },
+    {
+      type: "content",
+      kind: "data",
+      heading: "Pipeline by stage",
+      components: [
+        {
+          type: "chart",
+          chart_type: "bar",
+          series: [
+            {
+              name: "Qualified",
+              data: [
+                { x: "Discover", y: 42 },
+                { x: "Propose", y: 19 },
+                { x: "Close", y: 11 }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      type: "content",
+      kind: "statement",
+      heading: "We will not add a fourth product line this year",
+      components: [
+        {
+          type: "blockquote",
+          text: "Three products is the house."
+        }
+      ]
+    },
+    {
+      type: "content",
+      kind: "fact",
+      heading: "NPS",
+      components: [
+        {
+          type: "kpi_cards",
+          items: [{ value: "61", label: "trailing 90-day NPS", delta: "up" }]
+        }
+      ]
+    },
+    {
+      type: "ending",
+      heading: "See you Thursday"
+    }
+  ]
+};
+
+// src/cli/commands.ts
+async function registerThemesFromSpecSource(specPath, opts) {
+  if (!await pathExists(specPath)) return;
+  const specRaw = await loadIrFile(specPath, "spec");
+  await registerThemeSelection(themeNameFromUnknown(specRaw), opts);
 }
 function resolveDecksDirSource(projectHit, userHit) {
   if (projectHit?.config.decksDir !== void 0) {
-    return { decksDir: resolve6(dirname3(projectHit.path), projectHit.config.decksDir) };
+    return { decksDir: resolve7(dirname5(projectHit.path), projectHit.config.decksDir) };
   }
   return userHit?.config;
 }
+function deckLookupDir(resolvedTarget, isDir) {
+  return isDir ? resolvedTarget : dirname5(resolvedTarget);
+}
 async function applyDeckConfig(raw, opts) {
   if (typeof raw !== "object" || raw === null) return;
   const deck = raw;
   const irTheme = typeof deck.theme === "object" && deck.theme !== null ? deck.theme : {};
-  const themeFileId = opts.themeFilePath !== void 0 ? await loadThemeFile(opts.themeFilePath) : void 0;
-  const [projectHit, userHit] = await Promise.all([
-    opts.projectHit !== void 0 ? Promise.resolve(opts.projectHit) : findConfig(opts.cwd),
-    opts.userHit !== void 0 ? Promise.resolve(opts.userHit) : findUserConfig()
-  ]);
-  const theme = opts.theme ?? themeFileId ?? projectHit?.config.theme ?? userHit?.config.theme ?? irTheme.id;
-  const style = opts.stylePath ? await loadStyleFile(opts.stylePath) : projectHit?.config.style ?? userHit?.config.style ?? irTheme.style;
-  if (theme !== void 0) {
-    const installedThemeIds = getInstalledThemeIds();
-    if (!installedThemeIds.includes(theme)) {
-      throw new PptwiseError(
-        `unknown theme "${theme}" (from ${describeThemeSource(opts, projectHit, userHit)}) \u2014 available: ${installedThemeIds.join(", ")} (see \`pptwise themes\`)`
-      );
-    }
-  }
-  if (theme === void 0 && style === void 0) return;
-  deck.theme = { ...irTheme, id: theme, ...style !== void 0 ? { style } : {} };
+  const authoredName = opts.specTheme ?? (opts.fromDeckDir ? void 0 : typeof irTheme.id === "string" ? irTheme.id : void 0);
+  if (authoredName === void 0) return;
+  const resolved = await resolveThemeByName(authoredName, { startDir: opts.cwd, deckDir: opts.deckDir });
+  await assertThemeRebind(opts.deckDir, resolved);
+  deck.theme = {
+    ...irTheme,
+    id: resolved.id
+  };
 }
 function mergeWorkspaceImages(raw, extras) {
   if (typeof raw !== "object" || raw === null) return raw;
@@ -1856,30 +2206,32 @@ async function loadWorkspaceStock(cwd, projectHit, resolvedTarget, isDir) {
     target: resolvedTarget,
     isDir
   });
-  const workspaceAssetsDir = join5(location.dir, ASSETS_DIRNAME);
+  const workspaceAssetsDir = join7(location.dir, ASSETS_DIRNAME);
   const images2 = await scanWorkspaceAssets(workspaceAssetsDir);
   return { workspaceAssetsDir, images: images2 };
 }
 async function loadDeckTarget(arg, cwd, projectHit, userHit) {
   const target = await resolveDeckTarget(arg, resolveDecksDirSource(projectHit, userHit), cwd);
   if (await isDeckDirectory(target)) {
-    await registerDeckThemeFile(target);
-    const { ir, deckDir } = await readDeckDir(target);
+    await registerThemesFromSpecSource(join7(target, SPEC_FILENAME), { startDir: cwd, deckDir: target });
+    const { ir, deckDir, specTheme, specPath } = await readDeckDir(target);
     const stock2 = await loadWorkspaceStock(cwd, projectHit, deckDir, true);
     return {
       raw: mergeWorkspaceImages(ir, stock2.images),
       baseDir: deckDir,
       isDir: true,
       resolvedTarget: deckDir,
-      workspaceAssetsDir: stock2.workspaceAssetsDir
+      workspaceAssetsDir: stock2.workspaceAssetsDir,
+      specTheme,
+      specPath
     };
   }
   const raw = await loadIrFile(target);
-  const resolvedFile = resolve6(target);
+  const resolvedFile = resolve7(target);
   const stock = await loadWorkspaceStock(cwd, projectHit, resolvedFile, false);
   return {
     raw: mergeWorkspaceImages(raw, stock.images),
-    baseDir: dirname3(resolvedFile),
+    baseDir: dirname5(resolvedFile),
     isDir: false,
     resolvedTarget: resolvedFile,
     workspaceAssetsDir: stock.workspaceAssetsDir
@@ -1887,8 +2239,16 @@ async function loadDeckTarget(arg, cwd, projectHit, userHit) {
 }
 async function loadValidatedDeckIr(target, cwd) {
   const [projectHit, userHit] = await Promise.all([findConfig(cwd), findUserConfig()]);
-  const { raw, baseDir, workspaceAssetsDir } = await loadDeckTarget(target, cwd, projectHit, userHit);
-  await applyDeckConfig(raw, { cwd, projectHit, userHit });
+  const { raw, baseDir, workspaceAssetsDir, isDir, resolvedTarget, specTheme, specPath } = await loadDeckTarget(target, cwd, projectHit, userHit);
+  await applyDeckConfig(raw, {
+    cwd,
+    projectHit,
+    userHit,
+    specTheme,
+    specPath,
+    fromDeckDir: isDir,
+    deckDir: deckLookupDir(resolvedTarget, isDir)
+  });
   const v = validateIr(raw);
   if (!v.ok) {
     throw new PptwiseError(
@@ -1902,11 +2262,12 @@ ${formatIssues(v.errors)}`
 async function runRender(irPath, opts) {
   const cwd = opts.cwd ?? process.cwd();
   const [projectHit, userHit] = await Promise.all([findConfig(cwd), findUserConfig()]);
-  const { raw, baseDir, isDir, resolvedTarget, workspaceAssetsDir } = await loadDeckTarget(irPath, cwd, projectHit, userHit);
+  const { raw, baseDir, isDir, resolvedTarget, workspaceAssetsDir, specTheme, specPath } = await loadDeckTarget(irPath, cwd, projectHit, userHit);
   await applyDeckConfig(raw, {
-    theme: opts.theme,
-    themeFilePath: opts.themeFilePath,
-    stylePath: opts.stylePath,
+    specTheme,
+    specPath,
+    fromDeckDir: isDir,
+    deckDir: deckLookupDir(resolvedTarget, isDir),
     cwd,
     projectHit,
     userHit
@@ -1922,8 +2283,8 @@ ${formatIssues(v.errors)}`);
   const extraNotes = [];
   let output;
   if (opts.output !== void 0) {
-    output = resolve6(cwd, opts.output);
-    await mkdir4(dirname3(output), { recursive: true });
+    output = resolve7(cwd, opts.output);
+    await mkdir5(dirname5(output), { recursive: true });
   } else {
     const location = resolveWorkspaceLocation({
       cwd,
@@ -1933,9 +2294,9 @@ ${formatIssues(v.errors)}`);
       isDir
     });
     extraNotes.push(...await prepareWorkspaceDir(location, { gitIgnore: opts.gitIgnore, runGit: opts.runGit }));
-    output = join5(location.dir, `${location.slug}.pptx`);
+    output = join7(location.dir, `${location.slug}.pptx`);
   }
-  await writeFile3(output, bytes);
+  await writeFile4(output, bytes);
   const ok = `wrote ${output} (${v.ir.slides.length} slides, ${bytes.length} bytes)`;
   const notes = [...extraNotes, warningsNote(v.warnings), normalizedNote(v.normalized)].filter(
     (n) => n !== void 0
@@ -1959,10 +2320,18 @@ function placeholderNote(ir) {
   const refs = placeholders.map(({ slide, page }) => slide.id ? `${slide.id} (page ${page})` : `page ${page}`).join(", ");
   return `note: ${placeholders.length} unfilled placeholder page${placeholders.length === 1 ? "" : "s"}: ${refs}`;
 }
-async function runValidate(irPath, cwd = process.cwd(), opts = {}) {
+async function runValidate(irPath, cwd = process.cwd()) {
   const [projectHit, userHit] = await Promise.all([findConfig(cwd), findUserConfig()]);
-  const { raw, baseDir, isDir, workspaceAssetsDir } = await loadDeckTarget(irPath, cwd, projectHit, userHit);
-  await applyDeckConfig(raw, { themeFilePath: opts.themeFilePath, cwd, projectHit, userHit });
+  const { raw, baseDir, isDir, resolvedTarget, workspaceAssetsDir, specTheme, specPath } = await loadDeckTarget(irPath, cwd, projectHit, userHit);
+  await applyDeckConfig(raw, {
+    specTheme,
+    specPath,
+    fromDeckDir: isDir,
+    deckDir: deckLookupDir(resolvedTarget, isDir),
+    cwd,
+    projectHit,
+    userHit
+  });
   const v = validateIr(raw);
   if (!v.ok)
     throw new PptwiseError(
@@ -2002,8 +2371,16 @@ function formatAuditReport(report, ir) {
 async function runAudit(target, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const [projectHit, userHit] = await Promise.all([findConfig(cwd), findUserConfig()]);
-  const { raw, baseDir, workspaceAssetsDir } = await loadDeckTarget(target, cwd, projectHit, userHit);
-  await applyDeckConfig(raw, { themeFilePath: opts.themeFilePath, cwd, projectHit, userHit });
+  const { raw, baseDir, workspaceAssetsDir, isDir, resolvedTarget, specTheme, specPath } = await loadDeckTarget(target, cwd, projectHit, userHit);
+  await applyDeckConfig(raw, {
+    specTheme,
+    specPath,
+    fromDeckDir: isDir,
+    deckDir: deckLookupDir(resolvedTarget, isDir),
+    cwd,
+    projectHit,
+    userHit
+  });
   const v = validateIr(raw);
   if (!v.ok) {
     throw new PptwiseError(
@@ -2047,8 +2424,16 @@ function formatAssetBriefReport(brief) {
 async function runAssetBrief(target, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const [projectHit, userHit] = await Promise.all([findConfig(cwd), findUserConfig()]);
-  const { raw, baseDir, workspaceAssetsDir } = await loadDeckTarget(target, cwd, projectHit, userHit);
-  await applyDeckConfig(raw, { cwd, projectHit, userHit });
+  const { raw, baseDir, workspaceAssetsDir, isDir, resolvedTarget, specTheme, specPath } = await loadDeckTarget(target, cwd, projectHit, userHit);
+  await applyDeckConfig(raw, {
+    specTheme,
+    specPath,
+    fromDeckDir: isDir,
+    deckDir: deckLookupDir(resolvedTarget, isDir),
+    cwd,
+    projectHit,
+    userHit
+  });
   const v = validateIr(raw);
   if (!v.ok) {
     throw new PptwiseError(
@@ -2062,7 +2447,8 @@ ${formatIssues(v.errors)}`
 }
 async function runSpecValidate(specPath) {
   const raw = await loadIrFile(specPath, "spec");
-  await registerDeckThemeFile(dirname3(resolve6(specPath)));
+  const specDir = dirname5(resolve7(specPath));
+  await registerThemeSelection(themeNameFromUnknown(raw), { startDir: specDir, deckDir: specDir });
   const v = validateSpec(raw);
   if (!v.ok) {
     throw new PptwiseError(formatInvalidSpecError(v.errors));
@@ -2070,21 +2456,121 @@ async function runSpecValidate(specPath) {
   const spec2 = v.spec;
   const axes = resolveNarrative(spec2.narrative);
   const ok = `OK \u2014 ${spec2.pages.length} pages, narrative ${axes.strategy}/${axes.pacing}/${axes.audience}, theme "${resolveSpecThemeId(spec2)}"`;
+  const lines = [ok];
+  for (const w of v.warnings ?? []) {
+    lines.push(`warning: ${w.path ? `${w.path}: ` : ""}${w.message}`);
+  }
   const aliasNote = normalizedNote(v.normalized);
-  return aliasNote ? `${ok}
-${aliasNote}` : ok;
+  if (aliasNote) lines.push(aliasNote);
+  return lines.join("\n");
 }
 function runSchema(mode) {
-  const schema = mode === "style" ? styleJsonSchema() : mode === "spec" ? specJsonSchema() : irJsonSchema();
+  const schema = mode === "spec" ? specJsonSchema() : irJsonSchema();
   return JSON.stringify(schema, null, 2);
 }
 function runThemes(asJson) {
   const themes = listThemes();
-  if (asJson) return JSON.stringify(themes, null, 2);
+  if (asJson) {
+    return JSON.stringify(
+      themes.map((t) => {
+        const rec = Object.hasOwn(THEME_OCCASIONS, t.id) ? THEME_OCCASIONS[t.id] : void 0;
+        return {
+          id: t.id,
+          label: t.label,
+          colors: t.colors,
+          occasions: rec?.occasions ?? [],
+          identity: rec?.identity ?? null
+        };
+      }),
+      null,
+      2
+    );
+  }
   return themes.map((t) => `${t.id.padEnd(12)} ${t.label}`).join("\n");
 }
+function layoutCapacity(slots) {
+  let sum = 0;
+  let any = false;
+  for (const slot of slots) {
+    if (slot.capacity !== void 0) {
+      sum += slot.capacity;
+      any = true;
+    }
+  }
+  return any ? sum : void 0;
+}
+function listLayouts() {
+  return Object.values(LAYOUT_REGISTRY).map((layout) => {
+    const capacity = layoutCapacity(layout.slots);
+    const row = {
+      id: layout.id,
+      slideTypes: layout.slideTypes,
+      slots: layout.slots.map((slot) => {
+        const compact = { name: slot.name, accepts: slot.accepts };
+        if (slot.capacity !== void 0) compact.capacity = slot.capacity;
+        return compact;
+      })
+    };
+    if (capacity !== void 0) row.capacity = capacity;
+    return row;
+  });
+}
+function runLayouts(asJson) {
+  const layouts = listLayouts();
+  if (asJson) return JSON.stringify(layouts, null, 2);
+  const rows = layouts.map((l) => ({
+    id: l.id,
+    types: l.slideTypes.join(","),
+    cap: l.capacity !== void 0 ? String(l.capacity) : "-",
+    slots: l.slots.map((s) => s.name).join(", ")
+  }));
+  const idWidth = Math.max(...rows.map((r) => r.id.length));
+  const typesWidth = Math.max(...rows.map((r) => r.types.length));
+  const capWidth = Math.max(...rows.map((r) => r.cap.length));
+  return rows.map(
+    (r) => `${r.id.padEnd(idWidth + 2)}${r.types.padEnd(typesWidth + 2)}${r.cap.padEnd(capWidth + 2)}${r.slots}`
+  ).join("\n");
+}
 function defaultThemeIdFor(output) {
-  return slugify(basename4(output).replace(/\.theme\.json$|\.json$/i, ""));
+  return slugify(basename5(output).replace(/\.theme\.json$|\.json$/i, ""));
+}
+async function defaultThemeOutputPath(id, cwd) {
+  assertThemeId(id);
+  const project = await findConfig(cwd);
+  const root = project !== null ? dirname5(project.path) : resolve7(cwd);
+  return join7(root, WORKSPACE_THEMES_DIRNAME, `${id}.theme.json`);
+}
+async function resolveThemeWriteTarget(opts) {
+  if (opts.output !== void 0) {
+    const output = resolve7(opts.cwd, opts.output);
+    const id = opts.id ?? defaultThemeIdFor(output);
+    assertThemeId(id);
+    return { id, output };
+  }
+  if (opts.id !== void 0) {
+    assertThemeId(opts.id);
+    return { id: opts.id, output: await defaultThemeOutputPath(opts.id, opts.cwd) };
+  }
+  throw new PptwiseError("pass --id or -o so the theme file has a name");
+}
+async function themeFileFromResolved(resolved, identity) {
+  if (resolved.kind === "builtin") {
+    return themeFileFromPreset(resolved.id, identity);
+  }
+  const copy = structuredClone(resolved.file);
+  copy.id = identity.id;
+  copy.style = { ...copy.style, id: identity.id };
+  if (identity.label !== void 0) copy.label = identity.label;
+  return ThemeFileSchema.parse(copy);
+}
+function rethrowBrandColorError(error, id) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (/colors\.|contrast ratio|calibrate/i.test(message)) {
+    throw new PptwiseError(
+      `${message}. Run \`pptwise theme new --from <preset> --id ${id}\`, adjust the copied theme colors by hand, then bind that theme`
+    );
+  }
+  throw error;
 }
 async function runBrandExtract(file, opts) {
   let bytes;
@@ -2094,31 +2580,123 @@ async function runBrandExtract(file, opts) {
     throw new PptwiseError(`cannot read template file: ${file}`);
   }
   const id = opts.id ?? defaultThemeIdFor(opts.output);
-  if (CANONICAL_THEME_IDS.includes(id)) {
-    throw new PptwiseError(
-      `theme id "${id}" collides with a built-in pptwise theme \u2014 pick a different id with --id (or a different output filename)`
+  assertThemeId(id);
+  let extracted;
+  try {
+    extracted = await extractBrandTheme(bytes, { id, label: opts.label });
+  } catch (error) {
+    rethrowBrandColorError(error, id);
+  }
+  const from = opts.from ?? "consulting";
+  const cwd = dirname5(resolve7(opts.output));
+  const donorResolved = await resolveThemeByName(from, { startDir: cwd });
+  const donor = await themeFileFromResolved(donorResolved, { id: extracted.id, label: extracted.label });
+  let theme2;
+  try {
+    theme2 = forkTheme(
+      donor,
+      {
+        primary: extracted.style.colors.primary,
+        accent: extracted.style.colors.accent,
+        bg: extracted.style.colors.bg,
+        text: extracted.style.colors.text,
+        surface: extracted.style.colors.surface,
+        chartPalette: extracted.style.colors.chartPalette
+      },
+      { id: extracted.id, label: extracted.label, fonts: extracted.style.fonts }
     );
+  } catch (error) {
+    rethrowBrandColorError(error, id);
   }
-  const theme = await extractBrandTheme(bytes, { id, label: opts.label });
-  const outPath = resolve6(opts.output);
-  await mkdir4(dirname3(outPath), { recursive: true });
-  await writeFile3(outPath, JSON.stringify(theme, null, 2) + "\n");
-  const c = theme.style.colors;
+  const outPath = resolve7(opts.output);
+  await writeThemeFile(outPath, theme2, opts.force === true);
+  const c = theme2.style.colors;
   const lines = [
-    `wrote ${opts.output} (theme "${theme.id}", label "${theme.label}")`,
+    `wrote ${opts.output} (theme "${theme2.id}", label "${theme2.label}")`,
     `  colors: bg ${c.bg}, text ${c.text}, primary ${c.primary}, accent ${c.accent}, muted ${c.muted} (derived), ${c.chartPalette.length} chart colors`,
-    `  fonts: heading "${theme.style.fonts.heading[0]}", body "${theme.style.fonts.body[0]}"`,
-    `use it: pptwise render <deck> --theme-file ${opts.output} \u2014 or drop it into a deck project directory as ${THEME_FILENAME} and reference "${theme.id}" as the deck's theme`
+    `  fonts: heading "${theme2.style.fonts.heading[0]}", body "${theme2.style.fonts.body[0]}"`,
+    `Drop the file in a deck ${THEME_FILENAME} or workspace themes/ and set spec.theme to "${theme2.id}".`
   ];
-  try {
-    assertContrastFloor(theme.id, theme.style);
-  } catch (e) {
-    lines.push(
-      `warning: this theme will be refused at load time \u2014 ${e instanceof Error ? e.message : String(e)}. Edit the written file's colors (darker text, or a lighter bg) before using it`
-    );
-  }
   return lines.join("\n");
 }
+async function runThemeNew(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const { id, output } = await resolveThemeWriteTarget({ id: opts.id, output: opts.output, cwd });
+  const resolved = await resolveThemeByName(opts.from, { startDir: cwd });
+  const file = await themeFileFromResolved(resolved, { id, label: opts.label });
+  await writeThemeFile(output, file, opts.force === true);
+  return `wrote ${output} (theme "${file.id}"). Set spec.theme to "${file.id}".`;
+}
+async function runThemeFork(name, opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const { id, output } = await resolveThemeWriteTarget({ id: opts.id, output: opts.output, cwd });
+  const resolved = await resolveThemeByName(name, { startDir: cwd });
+  const source = await themeFileFromResolved(resolved, { id, label: opts.label });
+  const file = forkTheme(
+    source,
+    { primary: opts.primary, bg: opts.bg, accent: opts.accent, text: opts.text, surface: opts.surface },
+    { id, label: opts.label ?? source.label }
+  );
+  await writeThemeFile(output, file, opts.force === true);
+  return `wrote ${output} (theme "${file.id}"). Set spec.theme to "${file.id}".`;
+}
+function parseThemeTryIds(raw) {
+  const ids = raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+  if (ids.length < 2 || ids.length > 4) {
+    throw new PptwiseError(`pptwise theme try expects 2-4 theme ids, got ${ids.length}`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (seen.has(id)) throw new PptwiseError(`pptwise theme try has duplicate theme id "${id}"`);
+    seen.add(id);
+  }
+  return ids;
+}
+function contactSheetSlidesFromIr(ir, svgs) {
+  return ir.slides.map((slide, index) => {
+    const type = slide.type ?? "content";
+    const label = type === "content" && typeof slide.kind === "string" ? slide.kind : type;
+    return { type, label, svg: svgs[index] };
+  });
+}
+async function runThemeTry(idsRaw, opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const ids = parseThemeTryIds(idsRaw);
+  const columns = [];
+  for (const name of ids) {
+    const resolved = await resolveThemeByName(name, { startDir: cwd });
+    const raw = structuredClone(THEME_TRY_SAMPLE_IR);
+    raw.theme = { id: resolved.id };
+    const v = validateIr(raw);
+    if (!v.ok) throw new PptwiseError(`invalid IR:
+${formatIssues(v.errors)}`);
+    const ir = v.ir;
+    const svgs = ir.slides.map((_, index) => renderSlideSvg(ir, index));
+    columns.push({ id: resolved.id, slides: contactSheetSlidesFromIr(ir, svgs) });
+  }
+  let resolvedOut;
+  const extraNotes = [];
+  if (opts.output !== void 0) {
+    resolvedOut = resolve7(cwd, opts.output);
+    await mkdir5(resolvedOut, { recursive: true });
+  } else {
+    const projectHit = await findConfig(cwd);
+    const location = resolveWorkspaceLocation({
+      cwd,
+      projectConfigPath: projectHit?.path,
+      outDir: projectHit?.config.outDir,
+      target: "theme-try",
+      isDir: true
+    });
+    extraNotes.push(...await prepareWorkspaceDir(location, { gitIgnore: opts.gitIgnore, runGit: opts.runGit }));
+    resolvedOut = location.dir;
+  }
+  const htmlPath = join7(resolvedOut, "contact-sheet.html");
+  await writeFile4(htmlPath, buildContactSheetHtml({ title: "theme try", themes: columns }));
+  const ok = `wrote contact sheet to ${htmlPath}`;
+  return extraNotes.length > 0 ? `${ok}
+${extraNotes.join("\n")}` : ok;
+}
 function runNarratives(asJson) {
   if (asJson) {
     return JSON.stringify(
@@ -2141,29 +2719,32 @@ function runNarratives(asJson) {
   const axesWidth = Math.max(...rows.map((r) => r.axes.length));
   return rows.map((r) => `${r.id.padEnd(idWidth + 2)}${r.axes.padEnd(axesWidth + 2)}${r.themes}`).join("\n");
 }
-var CONFIG_TEMPLATE = {
-  theme: "consulting",
-  style: {
-    colors: { primary: "#0B5FFF", accent: "#FF6A00" }
-  }
-};
+var CONFIG_TEMPLATE = {};
 async function runInit(cwd = process.cwd()) {
-  const target = join5(cwd, CONFIG_FILENAME);
+  const target = join7(cwd, CONFIG_FILENAME);
   try {
-    await writeFile3(target, JSON.stringify(CONFIG_TEMPLATE, null, 2) + "\n", { flag: "wx" });
+    await writeFile4(target, JSON.stringify(CONFIG_TEMPLATE, null, 2) + "\n", { flag: "wx" });
   } catch (e) {
     if (e.code === "EEXIST") {
       throw new PptwiseError(`${target} already exists \u2014 edit it instead`);
     }
     throw e;
   }
-  return `wrote ${target} \u2014 themes: \`pptwise themes\`, style schema: \`pptwise schema --style\``;
+  return `wrote ${target} \u2014 themes: \`pptwise themes\``;
 }
 async function renderDeckSlides(target, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const [projectHit, userHit] = await Promise.all([findConfig(cwd), findUserConfig()]);
-  const { raw, baseDir, isDir, resolvedTarget, workspaceAssetsDir } = await loadDeckTarget(target, cwd, projectHit, userHit);
-  await applyDeckConfig(raw, { themeFilePath: opts.themeFilePath, cwd, projectHit, userHit });
+  const { raw, baseDir, isDir, resolvedTarget, workspaceAssetsDir, specTheme, specPath } = await loadDeckTarget(target, cwd, projectHit, userHit);
+  await applyDeckConfig(raw, {
+    specTheme,
+    specPath,
+    fromDeckDir: isDir,
+    deckDir: deckLookupDir(resolvedTarget, isDir),
+    cwd,
+    projectHit,
+    userHit
+  });
   const v = validateIr(raw);
   if (!v.ok) throw new PptwiseError(`invalid IR:
 ${formatIssues(v.errors)}`);
@@ -2196,35 +2777,35 @@ async function buildDeckPreview(target, opts = {}) {
   const { html, findings, checks } = buildDeckAuditAndHtml(rendered.ir, rendered.svgs);
   return { ...rendered, html, findings, checks };
 }
+async function resolvePreviewOutDir(cwd, outDir, resolvedTarget, isDir, opts) {
+  if (outDir !== void 0) {
+    const resolvedOut = resolve7(cwd, outDir);
+    await mkdir5(resolvedOut, { recursive: true });
+    return { resolvedOut, extraNotes: [] };
+  }
+  const projectHit = await findConfig(cwd);
+  const location = resolveWorkspaceLocation({
+    cwd,
+    projectConfigPath: projectHit?.path,
+    outDir: projectHit?.config.outDir,
+    target: resolvedTarget,
+    isDir
+  });
+  const extraNotes = await prepareWorkspaceDir(location, { gitIgnore: opts.gitIgnore, runGit: opts.runGit });
+  await pruneRenderedSvgs(location.dir);
+  return { resolvedOut: location.dir, extraNotes };
+}
 async function runPreview(irPath, outDir, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const { ir, svgs, normalized, isDir, resolvedTarget } = await renderDeckSlides(irPath, {
-    cwd,
-    themeFilePath: opts.themeFilePath
+    cwd
   });
-  const extraNotes = [];
-  let resolvedOut;
-  if (outDir !== void 0) {
-    resolvedOut = resolve6(cwd, outDir);
-    await mkdir4(resolvedOut, { recursive: true });
-  } else {
-    const projectHit = await findConfig(cwd);
-    const location = resolveWorkspaceLocation({
-      cwd,
-      projectConfigPath: projectHit?.path,
-      outDir: projectHit?.config.outDir,
-      target: resolvedTarget,
-      isDir
-    });
-    extraNotes.push(...await prepareWorkspaceDir(location, { gitIgnore: opts.gitIgnore, runGit: opts.runGit }));
-    await pruneRenderedSvgs(location.dir);
-    resolvedOut = location.dir;
-  }
+  const { resolvedOut, extraNotes } = await resolvePreviewOutDir(cwd, outDir, resolvedTarget, isDir, opts);
   const svgNames = [];
   for (let i = 0; i < ir.slides.length; i++) {
     const name = `${String(i + 1).padStart(3, "0")}-${ir.slides[i].type}.svg`;
     svgNames.push(name);
-    await writeFile3(join5(resolvedOut, name), svgs[i]);
+    await writeFile4(join7(resolvedOut, name), svgs[i]);
   }
   const ok = `wrote ${ir.slides.length} SVG files to ${resolvedOut}`;
   const notes = [...extraNotes];
@@ -2232,8 +2813,8 @@ async function runPreview(irPath, outDir, opts = {}) {
   if (aliasNote) notes.push(aliasNote);
   if (opts.htmlOut) {
     const { html, findings, checks } = buildDeckAuditAndHtml(ir, svgs);
-    const htmlPath = join5(resolvedOut, "preview.html");
-    await writeFile3(htmlPath, html);
+    const htmlPath = join7(resolvedOut, "preview.html");
+    await writeFile4(htmlPath, html);
     const hasPlaceholder = ir.slides.some((s) => s.placeholder);
     const manifest = buildPreviewManifest({
       title: ir.filename,
@@ -2251,8 +2832,8 @@ async function runPreview(irPath, outDir, opts = {}) {
       checks,
       auditNote: hasPlaceholder ? "audit skipped \u2014 deck has unfilled placeholder pages" : void 0
     });
-    const manifestPath = join5(resolvedOut, "manifest.json");
-    await writeFile3(manifestPath, `${JSON.stringify(manifest, null, 2)}
+    const manifestPath = join7(resolvedOut, "manifest.json");
+    await writeFile4(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
     notes.push(`note: wrote self-contained preview to ${htmlPath}`);
     notes.push(`note: wrote machine-readable page manifest to ${manifestPath}`);
@@ -2267,7 +2848,7 @@ function withRewrittenAssetPaths(ir, deckDir, outDir) {
   const images2 = Object.fromEntries(
     Object.entries(ir.assets.images).map(([id, asset]) => {
       if (asset.src.startsWith("data:") || /^https?:\/\//.test(asset.src)) return [id, asset];
-      return [id, { ...asset, src: relative2(outDir, join5(deckDir, asset.src)) }];
+      return [id, { ...asset, src: relative2(outDir, join7(deckDir, asset.src)) }];
     })
   );
   return { ...ir, assets: { images: images2 } };
@@ -2279,25 +2860,18 @@ async function runAssemble(target, opts = {}) {
   if (await pathExists(dir) && !await isDeckDirectory(dir)) {
     throw new PptwiseError(`expected a deck project directory: ${dir}`);
   }
-  if (await isDeckDirectory(dir)) await registerDeckThemeFile(dir);
-  const { ir, generatedSeed, materializedLayoutCount, deckDir } = await readDeckDir(dir);
-  const outPath = opts.output ? resolve6(cwd, opts.output) : join5(deckDir, "deck.json");
-  const outDir = dirname3(outPath);
+  if (await isDeckDirectory(dir)) {
+    await registerThemesFromSpecSource(join7(dir, SPEC_FILENAME), { startDir: cwd, deckDir: dir });
+  }
+  const { ir, deckDir } = await readDeckDir(dir);
+  const outPath = opts.output ? resolve7(cwd, opts.output) : join7(deckDir, "deck.json");
+  const outDir = dirname5(outPath);
   const outIr = outDir === deckDir ? ir : withRewrittenAssetPaths(ir, deckDir, outDir);
-  await mkdir4(outDir, { recursive: true });
-  await writeFile3(outPath, JSON.stringify(outIr, null, 2) + "\n");
+  await mkdir5(outDir, { recursive: true });
+  await writeFile4(outPath, JSON.stringify(outIr, null, 2) + "\n");
   const placeholderCount = outIr.slides.filter((s) => s.placeholder).length;
   const summary = `wrote ${outPath} (${outIr.slides.length} slides, ${placeholderCount} placeholder${placeholderCount === 1 ? "" : "s"})`;
-  const notes = [];
-  if (generatedSeed !== void 0) {
-    notes.push(`note: generated seed ${generatedSeed} \u2014 add "seed": ${generatedSeed} to deck.spec.json for revision stability`);
-  }
-  if (materializedLayoutCount !== void 0) {
-    notes.push(
-      `note: ${materializedLayoutCount} layout${materializedLayoutCount === 1 ? "" : "s"} auto-selected into deck.json \u2014 pin "layout" in a page file to lock one`
-    );
-  }
-  return [summary, ...notes].join("\n");
+  return summary;
 }
 async function runDisassemble(irPath, outDir) {
   const raw = await loadIrFile(irPath);
@@ -2307,203 +2881,41 @@ ${formatIssues(v.errors)}`);
   const { spec: spec2, pages } = disassembleDeck(v.ir);
   const ids = Object.keys(pages);
   for (const id of ids) assertSafeFileSegment(id, "slide id");
-  const specPath = join5(outDir, "deck.spec.json");
-  await mkdir4(outDir, { recursive: true });
+  const specPath = join7(outDir, "deck.spec.json");
+  await mkdir5(outDir, { recursive: true });
   try {
-    await writeFile3(specPath, JSON.stringify(spec2, null, 2) + "\n", { flag: "wx" });
+    await writeFile4(specPath, JSON.stringify(spec2, null, 2) + "\n", { flag: "wx" });
   } catch (e) {
     if (e.code === "EEXIST") {
       throw new PptwiseError(`${specPath} already exists \u2014 refusing to overwrite an existing deck project`);
     }
     throw e;
   }
-  const pagesDir = join5(outDir, "pages");
+  const pagesDir = join7(outDir, "pages");
   try {
     if (ids.length > 0) {
-      await mkdir4(pagesDir, { recursive: true });
+      await mkdir5(pagesDir, { recursive: true });
       await Promise.all(
         ids.map((id) => {
           const content = pages[id];
-          return writeFile3(join5(pagesDir, `${id}.json`), JSON.stringify(content, null, 2) + "\n");
+          return writeFile4(join7(pagesDir, `${id}.json`), JSON.stringify(content, null, 2) + "\n");
         })
       );
     }
     const { count: assetCount, assetsDir } = await writeDeckAssets(
       v.ir.assets.images,
       outDir,
-      dirname3(resolve6(irPath))
+      dirname5(resolve7(irPath))
     );
     const pagesNote = ids.length > 0 ? `${ids.length} page file${ids.length === 1 ? "" : "s"} to ${pagesDir}` : "no pages (every slide was a placeholder)";
     const assetsNote = assetCount > 0 ? `, and ${assetCount} asset file${assetCount === 1 ? "" : "s"} to ${assetsDir}` : "";
     return `wrote ${specPath}, ${pagesNote}${assetsNote}`;
   } catch (e) {
-    await rm(specPath, { force: true }).catch(() => {
+    await rm2(specPath, { force: true }).catch(() => {
     });
     throw e;
   }
 }
-async function runMigrate(input, output, cwd = process.cwd()) {
-  const resolvedInput = resolve6(cwd, input);
-  if (await isDeckDirectory(resolvedInput)) {
-    return runMigrateDeckDir(resolvedInput, output, cwd);
-  }
-  return runMigrateIrFile(resolvedInput, output, cwd);
-}
-function isPlainRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function needsChromeRewrite(raw) {
-  return Object.hasOwn(raw, "chrome");
-}
-function needsBloomRewrite(raw) {
-  const theme = raw.theme;
-  if (theme === "bloom") return true;
-  return isPlainRecord(theme) && theme.id === "bloom";
-}
-function componentListHasLogoWall(components) {
-  return Array.isArray(components) && components.some((component) => isPlainRecord(component) && component.type === "logo_wall");
-}
-function needsLogoWallRewrite(raw) {
-  if (componentListHasLogoWall(raw.components)) return true;
-  if (!Array.isArray(raw.slides)) return false;
-  return raw.slides.some((slide) => isPlainRecord(slide) && componentListHasLogoWall(slide.components));
-}
-function recordHasBannerHeadingPin(obj) {
-  return obj.layout === "banner-heading" || obj.focus === "banner-heading";
-}
-function needsBannerHeadingRewrite(raw) {
-  if (recordHasBannerHeadingPin(raw)) return true;
-  if (Array.isArray(raw.slides) && raw.slides.some((slide) => isPlainRecord(slide) && recordHasBannerHeadingPin(slide))) {
-    return true;
-  }
-  if (Array.isArray(raw.pages) && raw.pages.some((page) => isPlainRecord(page) && recordHasBannerHeadingPin(page))) {
-    return true;
-  }
-  return false;
-}
-function migrateRewriteNote(chrome, bloom, logoWall = false, bannerHeading = false) {
-  const parts = [];
-  if (chrome) parts.push("renamed chrome \u2192 branding");
-  if (bloom) parts.push("relocated bloom \u2192 classroom");
-  if (logoWall) parts.push("rewrote logo_wall \u2192 image_grid");
-  if (bannerHeading) parts.push("rewrote banner-heading \u2192 two-column");
-  return parts.join(", ");
-}
-function applyV4LeftoverRewrites(raw) {
-  return migrateBannerHeadingToTwoColumn(
-    migrateLogoWallToImageGrid(migrateBloomToClassroom(migrateChromeToBranding(raw)))
-  );
-}
-async function listPageJsonNames(dir) {
-  const pagesDir = join5(dir, PAGES_DIRNAME);
-  try {
-    const entries = await readdir3(pagesDir);
-    return entries.filter((name) => name.endsWith(".json")).sort();
-  } catch (e) {
-    if (e.code === "ENOENT") return [];
-    throw e;
-  }
-}
-async function rewriteLeftoverPages(dir, outDir) {
-  const names = await listPageJsonNames(dir);
-  const written = [];
-  let logoWall = false;
-  let bannerHeading = false;
-  for (const name of names) {
-    const src = join5(dir, PAGES_DIRNAME, name);
-    const raw = await loadIrFile(src, "page");
-    if (!isPlainRecord(raw)) continue;
-    const hasLogo = needsLogoWallRewrite(raw);
-    const hasBanner = needsBannerHeadingRewrite(raw);
-    if (!hasLogo && !hasBanner) continue;
-    if (hasLogo) logoWall = true;
-    if (hasBanner) bannerHeading = true;
-    const dest = join5(outDir, PAGES_DIRNAME, name);
-    await writeMigratedJson(dest, migrateBannerHeadingToTwoColumn(migrateLogoWallToImageGrid(raw)));
-    written.push(dest);
-  }
-  return { paths: written, logoWall, bannerHeading };
-}
-async function writeMigratedJson(outPath, data) {
-  await mkdir4(dirname3(outPath), { recursive: true });
-  try {
-    await writeFile3(outPath, JSON.stringify(data, null, 2) + "\n", { flag: "wx" });
-  } catch (e) {
-    if (e.code === "EEXIST") {
-      throw new PptwiseError(`${outPath} already exists \u2014 refusing to overwrite, delete it first or choose a different -o`);
-    }
-    throw e;
-  }
-}
-async function runMigrateDeckDir(dir, output, cwd) {
-  const planPath = join5(dir, PLAN_FILENAME);
-  const sourceSpecPath = join5(dir, SPEC_FILENAME);
-  const outDir = resolve6(cwd, output);
-  const specPath = join5(outDir, SPEC_FILENAME);
-  if (!await pathExists(planPath) && await pathExists(sourceSpecPath)) {
-    const raw2 = await loadIrFile(sourceSpecPath, "spec");
-    const specNeeds = isPlainRecord(raw2) && (needsChromeRewrite(raw2) || needsBloomRewrite(raw2) || needsBannerHeadingRewrite(raw2));
-    const pages2 = await rewriteLeftoverPages(dir, outDir);
-    if (specNeeds && isPlainRecord(raw2)) {
-      const chrome = needsChromeRewrite(raw2);
-      const bloom = needsBloomRewrite(raw2);
-      const bannerHeading = needsBannerHeadingRewrite(raw2);
-      const migrated2 = applyV4LeftoverRewrites(raw2);
-      await writeMigratedJson(specPath, migrated2);
-      const specNote2 = `wrote ${specPath} (${migrateRewriteNote(chrome, bloom, false, bannerHeading)})`;
-      if (pages2.paths.length === 0) return specNote2;
-      return `${specNote2}, wrote ${pages2.paths.length === 1 ? pages2.paths[0] : join5(outDir, PAGES_DIRNAME)} (${migrateRewriteNote(false, false, pages2.logoWall, pages2.bannerHeading)})`;
-    }
-    if (pages2.paths.length > 0) {
-      const target = pages2.paths.length === 1 ? pages2.paths[0] : join5(outDir, PAGES_DIRNAME);
-      return `wrote ${target} (${migrateRewriteNote(false, false, pages2.logoWall, pages2.bannerHeading)})`;
-    }
-    throw new PptwiseError(
-      `${dir} has ${SPEC_FILENAME} but no ${PLAN_FILENAME} \u2014 this deck project is already migrated, nothing to do`
-    );
-  }
-  const raw = await loadIrFile(planPath, "plan");
-  const migrated = migrateDeckPlanToSpec(raw);
-  await writeMigratedJson(specPath, migrated);
-  const pages = await rewriteLeftoverPages(dir, outDir);
-  const specNote = `wrote ${specPath} \u2014 run \`pptwise spec validate ${specPath}\` to confirm it, then delete ${planPath} (a directory with both files present is rejected)`;
-  if (pages.paths.length === 0) return specNote;
-  return `${specNote}, wrote ${pages.paths.length === 1 ? pages.paths[0] : join5(outDir, PAGES_DIRNAME)} (${migrateRewriteNote(false, false, pages.logoWall, pages.bannerHeading)})`;
-}
-async function runMigrateIrFile(filePath, output, cwd) {
-  const raw = await loadIrFile(filePath);
-  const version = typeof raw === "object" && raw !== null ? raw.version : void 0;
-  if (version === "2") {
-    throw new PptwiseError(
-      "pptwise migrate does not support IR v2 (spec \xA715.3: v2 has no real users) \u2014 run `pptwise validate` on the v2 file to see the full v2\u2192v4 combined field mapping and rewrite it by hand"
-    );
-  }
-  const outPath = resolve6(cwd, output);
-  if (version === "3") {
-    const pre = isPlainRecord(raw) ? migrateLogoWallToImageGrid(raw) : raw;
-    const parsed = PptxIRV3Schema.safeParse(pre);
-    if (!parsed.success) {
-      const detail = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n");
-      throw new PptwiseError(`invalid IR v3 file ${filePath}:
-${detail}`);
-    }
-    const migrated = migrateIrV3ToV4(parsed.data);
-    await writeMigratedJson(outPath, migrated);
-    return `wrote ${outPath} (migrated IR v3 \u2192 v4)`;
-  }
-  if (isPlainRecord(raw) && (needsChromeRewrite(raw) || needsBloomRewrite(raw) || needsLogoWallRewrite(raw) || needsBannerHeadingRewrite(raw))) {
-    const chrome = needsChromeRewrite(raw);
-    const bloom = needsBloomRewrite(raw);
-    const logoWall = needsLogoWallRewrite(raw);
-    const bannerHeading = needsBannerHeadingRewrite(raw);
-    const migrated = applyV4LeftoverRewrites(raw);
-    await writeMigratedJson(outPath, migrated);
-    return `wrote ${outPath} (${migrateRewriteNote(chrome, bloom, logoWall, bannerHeading)})`;
-  }
-  throw new PptwiseError(
-    `pptwise migrate converts an IR v3 file (version: "3"), a v4 IR or deck spec still carrying the old chrome field (renamed to branding), the removed bloom theme id (relocated to classroom), a leftover logo_wall component (rewritten to image_grid), or a leftover banner-heading layout pin (rewritten to two-column), or a deck project directory containing ${PLAN_FILENAME} \u2014 got version ${JSON.stringify(version)} in ${filePath} with nothing to migrate`
-  );
-}
 
 // src/cli/secret-input.ts
 import readline from "readline";
@@ -2518,7 +2930,7 @@ async function readSecret(prompt, io = { stdin: process.stdin, stderr: process.s
   return await readHiddenTty(prompt, stdin, stderr);
 }
 function readFirstLine(stdin) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const encoding = stdin.readableEncoding ?? "utf8";
     let buf = "";
     const onData = (chunk) => {
@@ -2526,11 +2938,11 @@ function readFirstLine(stdin) {
       const nl = buf.indexOf("\n");
       if (nl === -1) return;
       cleanup();
-      resolve8(buf.slice(0, nl).replace(/\r$/, "").trim());
+      resolve9(buf.slice(0, nl).replace(/\r$/, "").trim());
     };
     const onEnd = () => {
       cleanup();
-      resolve8(buf.replace(/\r$/, "").trim());
+      resolve9(buf.replace(/\r$/, "").trim());
     };
     const onError = (e) => {
       cleanup();
@@ -2547,7 +2959,7 @@ function readFirstLine(stdin) {
   });
 }
 function readHiddenTty(prompt, stdin, stderr) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const rl = readline.createInterface({ input: stdin, output: stderr, terminal: true });
     const mutable = rl;
     mutable._writeToOutput = () => {
@@ -2565,7 +2977,7 @@ function readHiddenTty(prompt, stdin, stderr) {
         stderr.write("\n");
         const value = answer.trim();
         if (value === "") reject(new PptwiseError("API key cannot be empty"));
-        else resolve8(value);
+        else resolve9(value);
       });
     });
     rl.on("SIGINT", () => {
@@ -2634,13 +3046,13 @@ async function runConfigShow(opts = {}) {
 
 // src/cli/doctor.ts
 import { lstatSync as lstatSync2 } from "fs";
-import { access, readFile as readFile7, readdir as readdir5 } from "fs/promises";
+import { access, readFile as readFile7, readdir as readdir4 } from "fs/promises";
 import { homedir } from "os";
-import { basename as basename5, join as join7 } from "path";
+import { basename as basename6, join as join9 } from "path";
 
 // src/cli/image-generators.ts
-import { copyFile as copyFile2, readdir as readdir4, stat as stat3 } from "fs/promises";
-import { join as join6 } from "path";
+import { copyFile as copyFile2, readdir as readdir3, stat as stat3 } from "fs/promises";
+import { join as join8 } from "path";
 var GENERATOR_PROBE_TIMEOUT_MS = 2e3;
 var BIN_NAMES = {
   grok: ["grok"],
@@ -2713,12 +3125,12 @@ async function isSniffedImage(path2) {
 async function collectFiles(dir, acc) {
   let entries;
   try {
-    entries = await readdir4(dir, { withFileTypes: true });
+    entries = await readdir3(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const full = join6(dir, entry.name);
+    const full = join8(dir, entry.name);
     if (entry.isDirectory()) {
       await collectFiles(full, acc);
     } else if (entry.isFile()) {
@@ -2902,18 +3314,19 @@ var SKILL_COPY_FILES = [
   "references/validate.zh-CN.md"
 ];
 var SKILL_ROOTS = [
-  { harness: "Claude Code", relative: join7(".claude", "skills") },
-  { harness: "Codex", relative: join7(".codex", "skills") },
-  { harness: "Pi, OpenCode", relative: join7(".agents", "skills") }
+  { harness: "Claude Code", relative: join9(".claude", "skills") },
+  { harness: "Codex", relative: join9(".codex", "skills") },
+  { harness: "Pi, OpenCode", relative: join9(".agents", "skills") }
 ];
 var SELF_TEST_DECK = {
-  version: "4",
+  version: "5",
   filename: "pptwise-doctor-self-test.pptx",
   theme: { id: "consulting" },
   slides: [
     { type: "cover", heading: "pptwise doctor", subheading: "self-test render" },
     {
       type: "content",
+      kind: "points",
       heading: "Core chain",
       components: [{ type: "bullets", items: ["validate the IR", "render a slide to SVG", "generate the .pptx bytes"] }]
     }
@@ -2941,15 +3354,15 @@ async function scanSkillCopies(home, currentVersion) {
   const scanned = [];
   const copies = [];
   for (const { harness, relative: relative3 } of SKILL_ROOTS) {
-    const root = join7(home, relative3);
+    const root = join9(home, relative3);
     scanned.push(root);
     for (const { dirName, legacy } of [
       { dirName: SKILL_DIR_NAME, legacy: false },
       ...LEGACY_SKILL_DIR_NAMES.map((dirName2) => ({ dirName: dirName2, legacy: true }))
     ]) {
-      const copyDir = join7(root, dirName);
+      const copyDir = join9(root, dirName);
       if (!await pathExists2(copyDir)) continue;
-      const launcherPath = join7(copyDir, "scripts", "run.sh");
+      const launcherPath = join9(copyDir, "scripts", "run.sh");
       let pinned = null;
       let launcher = null;
       try {
@@ -2959,7 +3372,7 @@ async function scanSkillCopies(home, currentVersion) {
       }
       const missing = [];
       for (const rel of SKILL_COPY_FILES) {
-        if (!await pathExists2(join7(copyDir, rel))) missing.push(rel);
+        if (!await pathExists2(join9(copyDir, rel))) missing.push(rel);
       }
       copies.push({
         harness,
@@ -2976,7 +3389,7 @@ async function scanSkillCopies(home, currentVersion) {
   return { scanned, copies };
 }
 async function readInstalledPluginVersion(profileDir) {
-  const pkgPath = join7(profileDir, "node_modules", ...PACKAGE_NAME.split("/"), "package.json");
+  const pkgPath = join9(profileDir, "node_modules", ...PACKAGE_NAME.split("/"), "package.json");
   try {
     const pkg = JSON.parse(await readFile7(pkgPath, "utf8"));
     return typeof pkg.version === "string" ? pkg.version : null;
@@ -2985,22 +3398,22 @@ async function readInstalledPluginVersion(profileDir) {
   }
 }
 async function inspectDsh(home, currentVersion) {
-  const dshHome = join7(home, ".dsh");
+  const dshHome = join9(home, ".dsh");
   if (!await pathExists2(dshHome)) return { applicable: false, home: dshHome, profiles: [] };
-  const profilesDir = join7(dshHome, "profiles");
+  const profilesDir = join9(dshHome, "profiles");
   let entries;
   try {
-    const dirents = await readdir5(profilesDir, { withFileTypes: true });
+    const dirents = await readdir4(profilesDir, { withFileTypes: true });
     entries = dirents.filter((d) => d.isDirectory() && d.name !== "node_modules").map((d) => d.name);
   } catch {
     return { applicable: true, home: dshHome, profiles: [] };
   }
   const profiles = [];
   for (const name of entries.sort()) {
-    const profileDir = join7(profilesDir, name);
+    const profileDir = join9(profilesDir, name);
     let declared;
     try {
-      const pkg = JSON.parse(await readFile7(join7(profileDir, "package.json"), "utf8"));
+      const pkg = JSON.parse(await readFile7(join9(profileDir, "package.json"), "utf8"));
       declared = pkg.dependencies?.[PACKAGE_NAME];
     } catch {
       continue;
@@ -3171,8 +3584,8 @@ async function buildDoctorReport(input = {}) {
     if (copy.legacy) {
       warnings.push({
         check: "skill copy",
-        message: `${copy.path} is a leftover ${basename5(copy.path)} skill copy`,
-        fix: `remove it and install the pptwise skill in ${join7(copy.root, SKILL_DIR_NAME)}`
+        message: `${copy.path} is a leftover ${basename6(copy.path)} skill copy`,
+        fix: `remove it and install the pptwise skill in ${join9(copy.root, SKILL_DIR_NAME)}`
       });
     } else if (copy.stale) {
       warnings.push({
@@ -3234,10 +3647,10 @@ function renderDoctorReport(report) {
   } else {
     for (const copy of report.skills.copies) {
       const state = copy.legacy || copy.stale || copy.pinned === null || copy.missing.length > 0 ? "warn" : "ok";
-      const pin = copy.legacy ? `leftover ${basename5(copy.path)} copy` : copy.pinned === null ? "version unknown" : `pins ${copy.pinned}`;
+      const pin = copy.legacy ? `leftover ${basename6(copy.path)} copy` : copy.pinned === null ? "version unknown" : `pins ${copy.pinned}`;
       lines.push(`  ${mark(state)} ${copy.harness}: ${copy.path} \u2014 ${pin}${copy.stale && !copy.legacy ? " (stale)" : ""}`);
       if (copy.legacy) {
-        lines.push(`      fix: remove it and install the pptwise skill in ${join7(copy.root, SKILL_DIR_NAME)}`);
+        lines.push(`      fix: remove it and install the pptwise skill in ${join9(copy.root, SKILL_DIR_NAME)}`);
       } else if (copy.stale) {
         lines.push(`      fix: ${skillRefreshCommand(copy.path)}`);
       } else if (copy.pinned === null) {
@@ -3353,9 +3766,9 @@ async function runDoctor(opts = {}) {
 }
 
 // src/cli/images.ts
-import { mkdir as mkdir5, mkdtemp, readFile as readFile8, readdir as readdir6, rename, rm as rm2, unlink as unlink2, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir6, mkdtemp, readFile as readFile8, readdir as readdir5, rename as rename2, rm as rm3, unlink as unlink2, writeFile as writeFile5 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname4, join as join8, resolve as resolve7 } from "path";
+import { dirname as dirname6, join as join10, resolve as resolve8 } from "path";
 
 // src/cli/redact.ts
 var KEY_QUERY = /([?&](?:api_)?key=)[^&\s"'<>]*/gi;
@@ -3376,7 +3789,7 @@ var OPENVERSE_SEARCH_URL = "https://api.openverse.org/v1/images/";
 var OPENVERSE_TOKEN_URL = "https://api.openverse.org/v1/auth_tokens/token/";
 var OPENVERSE_PAGE_SIZE = 8;
 var TOKEN_SKEW_MS = 3e4;
-var defaultSleep = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
+var defaultSleep = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
 var tokenCache = /* @__PURE__ */ new Map();
 function userAgent() {
   return `pptwise/${VERSION} (+https://pptwise.com)`;
@@ -3933,7 +4346,7 @@ function parsePhotoRef(ref) {
 }
 async function resolveDeckWorkspace(deckArg, cwd) {
   const [projectHit, userHit] = await Promise.all([findConfig(cwd), findUserConfig()]);
-  const decksDirSource = projectHit?.config.decksDir !== void 0 ? { decksDir: resolve7(dirname4(projectHit.path), projectHit.config.decksDir) } : userHit?.config;
+  const decksDirSource = projectHit?.config.decksDir !== void 0 ? { decksDir: resolve8(dirname6(projectHit.path), projectHit.config.decksDir) } : userHit?.config;
   const target = await resolveDeckTarget(deckArg, decksDirSource, cwd);
   const isDir = await isDeckDirectory(target);
   const location = resolveWorkspaceLocation({
@@ -3943,7 +4356,7 @@ async function resolveDeckWorkspace(deckArg, cwd) {
     target,
     isDir
   });
-  return { location, assetsDir: join8(location.dir, ASSETS_DIRNAME) };
+  return { location, assetsDir: join10(location.dir, ASSETS_DIRNAME) };
 }
 function assertSafeDownloadUrl(url) {
   let parsed;
@@ -4099,8 +4512,8 @@ async function runImagesFetch(ref, opts) {
     if (!apiKey) throw missingKeysError(provider);
   }
   const { assetsDir } = await resolveDeckWorkspace(opts.deck, cwd);
-  const jpgPath = join8(assetsDir, `${opts.as}.jpg`);
-  const jsonPath = join8(assetsDir, `${opts.as}.json`);
+  const jpgPath = join10(assetsDir, `${opts.as}.jpg`);
+  const jsonPath = join10(assetsDir, `${opts.as}.json`);
   if (await pathExists(jpgPath) && await pathExists(jsonPath)) {
     const existing = await readSidecar(jsonPath);
     if (existing && existing.photo_id === photoId && existing.provider === provider) {
@@ -4150,8 +4563,8 @@ async function runImagesFetch(ref, opts) {
   const apiLong = meta.width !== void 0 && meta.height !== void 0 ? Math.max(meta.width, meta.height) : void 0;
   const resize = opts.resizeToJpeg ?? defaultResizeToJpeg;
   const jpeg = await toJpeg(bytes, apiLong, resize);
-  await mkdir5(assetsDir, { recursive: true });
-  await writeFile4(jpgPath, jpeg);
+  await mkdir6(assetsDir, { recursive: true });
+  await writeFile5(jpgPath, jpeg);
   const sidecar = {
     provider,
     photo_id: photoId,
@@ -4167,7 +4580,7 @@ async function runImagesFetch(ref, opts) {
   if (/"apiKey"\s*:/.test(json) || /"key"\s*:/.test(json) || /"clientSecret"\s*:/.test(json)) {
     throw new PptwiseError("internal error: sidecar would have contained a key field");
   }
-  await writeFile4(jsonPath, json);
+  await writeFile5(jsonPath, json);
   return `pinned ${provider}:${photoId} as ${opts.as} \u2192 ${jpgPath}`;
 }
 async function runImagesList(opts) {
@@ -4175,14 +4588,14 @@ async function runImagesList(opts) {
   const { assetsDir } = await resolveDeckWorkspace(opts.deck, cwd);
   let names;
   try {
-    names = (await readdir6(assetsDir)).filter((n) => n.endsWith(".json") && !n.startsWith(".")).sort();
+    names = (await readdir5(assetsDir)).filter((n) => n.endsWith(".json") && !n.startsWith(".")).sort();
   } catch (e) {
     if (e.code === "ENOENT") return "No pinned stock photos.";
     throw e;
   }
   const lines = [];
   for (const name of names) {
-    const sidecar = await readSidecar(join8(assetsDir, name));
+    const sidecar = await readSidecar(join10(assetsDir, name));
     if (!sidecar) continue;
     const assetId = name.slice(0, -".json".length);
     const id = sidecar.photo_id ? `${sidecar.provider}:${sidecar.photo_id}` : sidecar.provider;
@@ -4192,20 +4605,20 @@ async function runImagesList(opts) {
   return lines.length === 0 ? "No pinned stock photos." : lines.join("\n");
 }
 async function writePinnedAsset(assetsDir, assetId, jpeg, sidecar) {
-  await mkdir5(assetsDir, { recursive: true });
-  const jpgPath = join8(assetsDir, `${assetId}.jpg`);
-  const jsonPath = join8(assetsDir, `${assetId}.json`);
-  const tmpJpg = join8(assetsDir, `.${assetId}.jpg.tmp`);
-  const tmpJson = join8(assetsDir, `.${assetId}.json.tmp`);
+  await mkdir6(assetsDir, { recursive: true });
+  const jpgPath = join10(assetsDir, `${assetId}.jpg`);
+  const jsonPath = join10(assetsDir, `${assetId}.json`);
+  const tmpJpg = join10(assetsDir, `.${assetId}.jpg.tmp`);
+  const tmpJson = join10(assetsDir, `.${assetId}.json.tmp`);
   const json = JSON.stringify(sidecar, null, 2) + "\n";
   if (/"apiKey"\s*:/.test(json) || /"key"\s*:/.test(json) || /"clientSecret"\s*:/.test(json)) {
     throw new PptwiseError("internal error: sidecar would have contained a key field");
   }
   try {
-    await writeFile4(tmpJpg, jpeg);
-    await writeFile4(tmpJson, json);
-    await rename(tmpJpg, jpgPath);
-    await rename(tmpJson, jsonPath);
+    await writeFile5(tmpJpg, jpeg);
+    await writeFile5(tmpJson, json);
+    await rename2(tmpJpg, jpgPath);
+    await rename2(tmpJson, jsonPath);
   } catch (e) {
     await unlink2(tmpJpg).catch(() => void 0);
     await unlink2(tmpJson).catch(() => void 0);
@@ -4247,8 +4660,8 @@ async function runImagesGenerate(opts) {
     throw new PptwiseError(`No image generator is enabled. Found but disabled: ${listed}`);
   }
   const { assetsDir } = await resolveDeckWorkspace(opts.deck, cwd);
-  const workdir = await mkdtemp(join8(tmpdir(), "pptwise-gen-"));
-  const dest = join8(workdir, "generated.jpg");
+  const workdir = await mkdtemp(join10(tmpdir(), "pptwise-gen-"));
+  const dest = join10(workdir, "generated.jpg");
   const run = opts.run ?? defaultProcessRunner;
   const attempts = [];
   try {
@@ -4290,7 +4703,7 @@ async function runImagesGenerate(opts) {
     }
     throw new PptwiseError(`All image generators failed: ${attempts.join("; ")}`);
   } finally {
-    await rm2(workdir, { recursive: true, force: true });
+    await rm3(workdir, { recursive: true, force: true });
   }
 }
 
@@ -4298,12 +4711,17 @@ async function runImagesGenerate(opts) {
 import { watch } from "fs";
 import { createServer } from "http";
 import { platform as osPlatform } from "os";
-import { join as join9 } from "path";
+import { dirname as dirname7, join as join11 } from "path";
 var DEFAULT_PORT = 4400;
 var DEBOUNCE_MS = 200;
 var HEARTBEAT_MS = 3e4;
 function watchRoots(resolvedTarget, isDir, extra = []) {
-  const roots = isDir ? [join9(resolvedTarget, SPEC_FILENAME), join9(resolvedTarget, PAGES_DIRNAME), join9(resolvedTarget, ASSETS_DIRNAME)] : [resolvedTarget];
+  const roots = isDir ? [
+    join11(resolvedTarget, SPEC_FILENAME),
+    join11(resolvedTarget, PAGES_DIRNAME),
+    join11(resolvedTarget, ASSETS_DIRNAME),
+    join11(resolvedTarget, THEME_FILENAME)
+  ] : [resolvedTarget];
   return [...roots, ...extra];
 }
 var SERVE_CLIENT_SCRIPT_ID = "pptwise-serve-client";
@@ -4366,7 +4784,7 @@ async function createServeServer(options) {
   if (!Number.isInteger(requestedPort) || requestedPort < 0 || requestedPort > 65535) {
     throw new PptwiseError(`invalid port ${requestedPort} \u2014 expected an integer between 0 and 65535`);
   }
-  const initial = await buildDeckPreview(options.target, { cwd, themeFilePath: options.themeFilePath });
+  const initial = await buildDeckPreview(options.target, { cwd });
   let cachedHtml = injectServeClient(initial.html);
   const sseClients = /* @__PURE__ */ new Set();
   function writeToAll(chunk) {
@@ -4385,7 +4803,7 @@ data: ${JSON.stringify(data)}
   }
   async function rebuild() {
     try {
-      const result = await buildDeckPreview(options.target, { cwd, themeFilePath: options.themeFilePath });
+      const result = await buildDeckPreview(options.target, { cwd });
       cachedHtml = injectServeClient(result.html);
       broadcast("reload", {});
     } catch (e) {
@@ -4424,7 +4842,7 @@ data: ${JSON.stringify(data)}
     }, DEBOUNCE_MS);
   }
   const projectHit = await findConfig(cwd);
-  const workspaceAssets = join9(
+  const workspaceAssets = join11(
     resolveWorkspaceLocation({
       cwd,
       projectConfigPath: projectHit?.path,
@@ -4434,8 +4852,17 @@ data: ${JSON.stringify(data)}
     }).dir,
     ASSETS_DIRNAME
   );
+  const extraWatch = [workspaceAssets];
+  try {
+    const resolvedTheme = await resolveThemeByName(initial.ir.theme.id, {
+      startDir: cwd,
+      deckDir: initial.isDir ? initial.resolvedTarget : dirname7(initial.resolvedTarget)
+    });
+    if (resolvedTheme.kind === "file") extraWatch.push(resolvedTheme.path);
+  } catch {
+  }
   const watchers = [];
-  for (const path2 of watchRoots(initial.resolvedTarget, initial.isDir, [workspaceAssets])) {
+  for (const path2 of watchRoots(initial.resolvedTarget, initial.isDir, extraWatch)) {
     try {
       watchers.push(watch(path2, () => scheduleRebuild()));
     } catch (e) {
@@ -4496,7 +4923,7 @@ function openBrowser(url) {
   }
 }
 async function runServe(target, opts = {}) {
-  const handle = await createServeServer({ target, port: opts.port, cwd: opts.cwd, themeFilePath: opts.themeFilePath });
+  const handle = await createServeServer({ target, port: opts.port, cwd: opts.cwd });
   console.log(`pptwise serve: ${handle.url} (Ctrl+C to stop)`);
   if (opts.open !== false) openBrowser(handle.url);
   process.on("SIGINT", () => {
@@ -4515,7 +4942,7 @@ function fail(e) {
   console.error(e instanceof Error ? e.message : String(e));
   process.exit(1);
 }
-program.command("render").description("Render an IR JSON file, deck project directory, or bare deck name to a .pptx").argument("<target>", "IR JSON file, deck project directory, or bare name under ~/.pptwise/decks").option("-o, --output <file>", "output .pptx path (default: .pptwise/<deck>/<deck>.pptx under the project root)").option("--theme <id>", "override the deck theme (see `pptwise themes`)").option("--theme-file <path>", "load a custom theme file (see `pptwise brand extract`) and render with it").option("--style <path>", "style overrides JSON re-coloring the theme (see `pptwise schema --style`)").option("--draft", "allow unfilled placeholder pages (skip the draft gate)").option(
+program.command("render").description("Render an IR JSON file, deck project directory, or bare deck name to a .pptx").argument("<target>", "IR JSON file, deck project directory, or bare name under ~/.pptwise/decks").option("-o, --output <file>", "output .pptx path (default: .pptwise/<deck>/<deck>.pptx under the project root)").option("--draft", "allow unfilled placeholder pages (skip the draft gate)").option(
   "--allow-dropped-content",
   "export anyway when a page holds more than fits and the layout drops blocks (skip the content-drop gate)"
 ).option("--no-git-ignore", "do not add .pptwise/ to this repository's local exclude file").action(
@@ -4524,9 +4951,6 @@ program.command("render").description("Render an IR JSON file, deck project dire
       console.log(
         await runRender(target, {
           output: opts.output,
-          theme: opts.theme,
-          themeFilePath: opts.themeFile,
-          stylePath: opts.style,
           draft: opts.draft,
           allowDroppedContent: opts.allowDroppedContent,
           gitIgnore: opts.gitIgnore,
@@ -4538,21 +4962,20 @@ program.command("render").description("Render an IR JSON file, deck project dire
     }
   }
 );
-program.command("validate").description("Validate an IR JSON file, deck project directory, or bare deck name against the schema").argument("<target>", "IR JSON file, deck project directory, or bare name under ~/.pptwise/decks").option("--theme-file <path>", "load a custom theme file (see `pptwise brand extract`) before validating").action(async (target, opts) => {
+program.command("validate").description("Validate an IR JSON file, deck project directory, or bare deck name against the schema").argument("<target>", "IR JSON file, deck project directory, or bare name under ~/.pptwise/decks").action(async (target) => {
   try {
-    console.log(await runValidate(target, process.cwd(), { themeFilePath: opts.themeFile }));
+    console.log(await runValidate(target, process.cwd()));
   } catch (e) {
     fail(e);
   }
 });
 program.command("audit").description(
-  "Deterministic geometry audit (overflow, out-of-bounds, low-contrast, overlap, content-truncated, content-dropped), plus an optional --pixels contrast pass \u2014 exits 1 when it finds anything"
-).argument("<target>", "IR JSON file, deck project directory, or bare name under ~/.pptwise/decks").option("--json", "machine-readable output (the full AuditReport)").option("--pixels", "also run the optional pixel-contrast pass over image-backed text (requires sharp)").option("--theme-file <path>", "load a custom theme file (see `pptwise brand extract`) and audit with it").action(async (target, opts) => {
+  "Deterministic geometry audit (overflow, out-of-bounds, low-contrast, overlap, content-truncated, content-dropped, monotony), plus an optional --pixels contrast pass \u2014 exits 1 when it finds anything"
+).argument("<target>", "IR JSON file, deck project directory, or bare name under ~/.pptwise/decks").option("--json", "machine-readable output (the full AuditReport)").option("--pixels", "also run the optional pixel-contrast pass over image-backed text (requires sharp)").action(async (target, opts) => {
   try {
     const { output, hasFindings } = await runAudit(target, {
       json: opts.json,
-      pixels: opts.pixels,
-      themeFilePath: opts.themeFile
+      pixels: opts.pixels
     });
     console.log(output);
     if (hasFindings) process.exit(1);
@@ -4569,15 +4992,8 @@ program.command("asset-brief").description(
     fail(e);
   }
 });
-program.command("schema").description("Print the IR JSON Schema (feed this to a model before it writes IR)").option("--style", "print the style-override schema instead").option("--spec", "print the deck spec schema instead").option("--plan", "removed \u2014 use --spec instead").action((opts) => {
-  if (opts.plan) {
-    fail(new Error("`pptwise schema --plan` has been renamed to `pptwise schema --spec` \u2014 run `pptwise schema --spec` instead"));
-  }
-  console.log(runSchema(opts.spec ? "spec" : opts.style ? "style" : void 0));
-});
-var plan = program.command("plan").description("Removed \u2014 use `pptwise spec` instead");
-plan.command("validate").description("Removed \u2014 use `pptwise spec validate` instead").argument("<file>").action(() => {
-  fail(new Error("`pptwise plan validate` has been renamed to `pptwise spec validate` \u2014 run `pptwise spec validate <file>` instead"));
+program.command("schema").description("Print the IR JSON Schema (feed this to a model before it writes IR)").option("--spec", "print the deck spec schema instead").action((opts) => {
+  console.log(runSchema(opts.spec ? "spec" : void 0));
 });
 var spec = program.command("spec").description("Deck spec commands (spec \xA76)");
 spec.command("validate").description("Validate a deck spec JSON file against the schema and strategy-aware hard gates").argument("<spec.json>").action(async (specPath) => {
@@ -4601,28 +5017,62 @@ program.command("disassemble").description("Split an IR JSON file into a deck pr
     fail(e);
   }
 });
-program.command("migrate").description("Convert a v3 IR file to v4, rewrite chrome \u2192 branding, bloom \u2192 classroom, logo_wall \u2192 image_grid, or banner-heading \u2192 two-column on a v4 IR or deck spec, or convert a deck.plan.json project directory to deck.spec.json \u2014 deterministic, no model").argument("<input>", "IR v3 JSON file, a v4 IR or deck spec still carrying chrome, bloom, logo_wall, or banner-heading, or a deck project directory containing deck.plan.json").requiredOption("-o, --output <output>", "output path \u2014 an IR JSON file for a file input, a directory for a deck-project-directory input").action(async (input, opts) => {
+program.command("themes").description("List built-in themes").option("--json", "machine-readable output").action((opts) => console.log(runThemes(Boolean(opts.json))));
+var theme = program.command("theme").description("Copy, fork, and compare themes");
+theme.command("new").description("Copy a preset or named theme into a self-contained v2 theme file").requiredOption("--from <preset>", "preset or theme name to copy").option("-o, --output <path>", "output theme JSON path").option("--id <id>", "theme id (default: slug of the output filename)").option("--label <label>", "human-readable theme label").option("--force", "overwrite an existing theme file").addHelpText("after", "\nExample:\n  $ pptwise theme new --from consulting -o themes/acme.theme.json").action(async (opts) => {
   try {
-    console.log(await runMigrate(input, opts.output));
+    console.log(await runThemeNew({ from: opts.from, output: opts.output, id: opts.id, label: opts.label, force: opts.force, cwd: process.cwd() }));
   } catch (e) {
     fail(e);
   }
 });
-program.command("themes").description("List built-in themes").option("--json", "machine-readable output").action((opts) => console.log(runThemes(Boolean(opts.json))));
+theme.command("fork").description("Copy a theme and rederive tokens around new anchor colors").argument("<name>", "preset or theme name to fork").requiredOption("--primary <hex>", "new primary color").option("--bg <hex>", "new background color").option("--accent <hex>", "new accent color").option("--text <hex>", "new text color").option("--surface <hex>", "new surface color").option("-o, --output <path>", "output theme JSON path").option("--id <id>", "theme id (default: slug of the output filename)").option("--label <label>", "human-readable theme label").option("--force", "overwrite an existing theme file").addHelpText("after", "\nExample:\n  $ pptwise theme fork acme --primary #0B5FFF -o themes/acme-blue.theme.json").action(
+  async (name, opts) => {
+    try {
+      console.log(
+        await runThemeFork(name, {
+          primary: opts.primary,
+          bg: opts.bg,
+          accent: opts.accent,
+          text: opts.text,
+          surface: opts.surface,
+          output: opts.output,
+          id: opts.id,
+          label: opts.label,
+          force: opts.force,
+          cwd: process.cwd()
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+theme.command("try").description("Render the fitting-room sample across 2-4 themes into a contact sheet").argument("<ids>", "comma-separated theme ids (2-4)").option("-o, --output <dir>", "output directory (default: .pptwise/theme-try/)").addHelpText("after", "\nExample:\n  $ pptwise theme try consulting,swiss,memo").action(async (ids, opts) => {
+  try {
+    console.log(await runThemeTry(ids, { output: opts.output, cwd: process.cwd() }));
+  } catch (e) {
+    fail(e);
+  }
+});
+program.command("layouts").description("List registered layouts").option("--json", "machine-readable output").action((opts) => console.log(runLayouts(Boolean(opts.json))));
 var brand = program.command("brand").description("Brand asset commands \u2014 extract your company's colors/fonts from an Office template");
 brand.command("extract").description(
   "Extract brand colors and fonts from a .thmx/.potx/.pptx file into a pptwise theme file \u2014 runs entirely locally, the file never leaves your machine"
-).argument("<file>", "a .thmx theme, .potx template, or .pptx presentation").requiredOption("-o, --output <file>", "output theme JSON path (e.g. my-brand.theme.json)").option("--id <id>", "theme id to register under (default: slug of the output filename)").option("--label <label>", "human-readable theme label (default: the source theme's color-scheme name)").action(async (file, opts) => {
+).argument("<file>", "a .thmx theme, .potx template, or .pptx presentation").requiredOption("-o, --output <file>", "output theme JSON path (e.g. my-brand.theme.json)").option("--id <id>", "theme id to register under (default: slug of the output filename)").option("--label <label>", "human-readable theme label (default: the source theme's color-scheme name)").option("--from <preset>", "donor preset whose menu is copied (default: consulting)").option("--force", "overwrite an existing theme file").addHelpText("after", "\nExample:\n  $ pptwise brand extract corp.pptx -o themes/acme.theme.json --from consulting").action(async (file, opts) => {
   try {
-    console.log(await runBrandExtract(file, { output: opts.output, id: opts.id, label: opts.label }));
+    console.log(await runBrandExtract(file, {
+      output: opts.output,
+      id: opts.id,
+      label: opts.label,
+      from: opts.from,
+      force: opts.force
+    }));
   } catch (e) {
     fail(e);
   }
 });
 program.command("narratives").description("List named narrative presets (strategy/pacing/audience axes + theme recommendations)").option("--json", "machine-readable output").action((opts) => console.log(runNarratives(Boolean(opts.json))));
-program.command("scenarios").description("Removed \u2014 use `pptwise narratives` instead").action(() => {
-  fail(new Error("`pptwise scenarios` has been renamed to `pptwise narratives` \u2014 run `pptwise narratives` instead"));
-});
 var config = program.command("config").description("User-level settings (API keys for optional stock-photo search)");
 config.command("set <key> [value]").description("Set a user config value. Omit the value for an apiKey or clientSecret to enter it at a hidden prompt").action(async (key, value) => {
   try {
@@ -4693,12 +5143,11 @@ program.command("init").description("Scaffold a pptwise.config.json in the curre
     fail(e);
   }
 });
-program.command("preview").description("Render each slide to an SVG file for visual self-check").argument("<target>", "IR JSON file, deck project directory, or bare name under ~/.pptwise/decks").option("-o, --output <dir>", "output directory (default: .pptwise/<deck>/ under the project root)").option("--html", "also write a self-contained preview.html (all slides inlined \u2014 thumbnail strip, keyboard navigation) for human review").option("--theme-file <path>", "load a custom theme file (see `pptwise brand extract`) and preview with it").option("--no-git-ignore", "do not add .pptwise/ to this repository's local exclude file").action(async (target, opts) => {
+program.command("preview").description("Render each slide to an SVG file for visual self-check").argument("<target>", "IR JSON file, deck project directory, or bare name under ~/.pptwise/decks").option("-o, --output <dir>", "output directory (default: .pptwise/<deck>/ under the project root)").option("--html", "also write a self-contained preview.html (all slides inlined \u2014 thumbnail strip, keyboard navigation) for human review").option("--no-git-ignore", "do not add .pptwise/ to this repository's local exclude file").action(async (target, opts) => {
   try {
     console.log(
       await runPreview(target, opts.output, {
         htmlOut: opts.html,
-        themeFilePath: opts.themeFile,
         gitIgnore: opts.gitIgnore,
         cwd: process.cwd()
       })
@@ -4707,7 +5156,7 @@ program.command("preview").description("Render each slide to an SVG file for vis
     fail(e);
   }
 });
-program.command("serve").description("Serve a live-reloading HTML preview of an IR JSON file, deck project directory, or bare deck name over HTTP").argument("<target>", "IR JSON file, deck project directory, or bare name under ~/.pptwise/decks").option("--port <number>", `port to listen on (default ${DEFAULT_PORT})`).option("--no-open", "do not open the URL in a browser after starting").option("--theme-file <path>", "load a custom theme file (see `pptwise brand extract`) and serve with it").action(async (target, opts) => {
+program.command("serve").description("Serve a live-reloading HTML preview of an IR JSON file, deck project directory, or bare deck name over HTTP").argument("<target>", "IR JSON file, deck project directory, or bare name under ~/.pptwise/decks").option("--port <number>", `port to listen on (default ${DEFAULT_PORT})`).option("--no-open", "do not open the URL in a browser after starting").action(async (target, opts) => {
   try {
     let port;
     if (opts.port !== void 0) {
@@ -4716,7 +5165,7 @@ program.command("serve").description("Serve a live-reloading HTML preview of an
         fail(new Error(`invalid --port value "${opts.port}" \u2014 expected an integer`));
       }
     }
-    await runServe(target, { port, open: opts.open, themeFilePath: opts.themeFile });
+    await runServe(target, { port, open: opts.open });
   } catch (e) {
     fail(e);
   }