slidemind 0.0.27

package/src/builders/primitives.json

@@ -0,0 +1,19 @@
+{
+  "version": 1,
+  "description": "The closed registry of components a slide JSX file may compose. The build-time linter rejects any PascalCase JSX tag that is not in this file. Layouts are the only allowed top-level slide component; primitives may appear inside body content of freeform layouts (SlideContent*Blank, SlideQuote*Blank).",
+  "layouts": [
+    "SlideCover",
+    "SlideAgendaBlack",
+    "SlideAgendaBlue",
+    "SlideChapterBlack",
+    "SlideChapterBlue",
+    "SlideClosing",
+    "SlideContentDarkBlank",
+    "SlideContentLightBlank",
+    "SlideQuoteBlack",
+    "SlideQuoteBlackBlank",
+    "SlideQuoteBlue",
+    "SlideQuoteBlueBlank"
+  ],
+  "primitives": []
+}

package/src/builders/resolve-skill.mjs

@@ -0,0 +1,205 @@
+// Discover which skill a deck was authored against, and return the paths the
+// rest of the local preview pipeline (build.mjs, lint-slides.mjs) needs to
+// load layouts, tokens, primitives and assets from.
+//
+// Post-connect, the corporate design (css, layouts, assets) is no longer
+// shipped inside the skill — it lives in the slidemind add-in and is
+// materialized per-CD into a local bundle cache. resolveSkill now resolves
+// those design roots from (in order): the deck-local override, the materialized
+// bundle (keyed by the deck's .bundle-ref.json), then any legacy in-package
+// skill files (back-compat for decks authored before the connect migration).
+//
+// The canonical .pptx render happens SERVER-SIDE in the add-in; these paths
+// only feed the local HTML/editor preview.
+//
+// Lookup order for a deck's skill name:
+//   1. `decks/<slug>/plan.md` frontmatter — `skill:` field.
+//   2. Default: `create-slides`.
+//
+// If a `skills/<skill>/skill.json` manifest exists, optional fields it can
+// declare: `mode`, `templates`, `defaultTemplate`, `designSystem.css`.
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { resolveBundleDirForDeck } from "../bridge/bundle.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
+
+const DEFAULT_SKILL = "create-slides";
+
+// Shipped fallback layout-contract registry for the LOCAL HTML preview.
+// The add-in derives layout contracts from the bundle's layouts directly, so
+// this is only consulted by the local preview when neither the deck nor the
+// materialized bundle carries its own primitives.json.
+const SHIPPED_PRIMITIVES = path.join(__dirname, "primitives.json");
+
+function firstExisting(candidates) {
+  for (const c of candidates) {
+    if (c && fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+// First existing candidate, or `fallback` when none exist. Encodes the
+// deck-override → bundle → skill precedence in one place so every resolved path
+// shares the same lookup rule.
+function firstExistingOr(candidates, fallback) {
+  return firstExisting(candidates) ?? fallback;
+}
+
+export function resolveSkillForDeck(deckDir) {
+  const planMeta = readPlanFrontmatter(deckDir);
+  const skillName = planMeta.skill || DEFAULT_SKILL;
+  const bundleDir = deckDir ? resolveBundleDirForDeck(deckDir) : null;
+  return resolveSkill(skillName, planMeta, { deckDir, bundleDir });
+}
+
+export function resolveSkill(skillName, planMeta = {}, opts = {}) {
+  const skillDir = path.join(PACKAGE_ROOT, "skills", skillName);
+  const manifest = fs.existsSync(skillDir) ? readManifest(skillDir) : {};
+  const cssName = manifest.designSystem?.css || "corporate-design.css";
+
+  // Design roots in precedence order: materialized bundle → (legacy) in-package
+  // skill dir. Deck-local overrides are layered on top per-asset below. A root
+  // only counts if it actually carries design files — otherwise the now
+  // brand-stripped skill dir would mask the "materialize the bundle first"
+  // guidance for a deck that hasn't downloaded one yet.
+  const bundleDir =
+    opts.bundleDir && fs.existsSync(opts.bundleDir) ? opts.bundleDir : null;
+  const designRoots = [
+    bundleDir,
+    fs.existsSync(skillDir) ? skillDir : null,
+  ].filter(
+    (r) =>
+      r &&
+      (fs.existsSync(path.join(r, cssName)) ||
+        fs.existsSync(path.join(r, "layouts"))),
+  );
+  if (designRoots.length === 0) {
+    throw new Error(
+      `No design source for skill "${skillName}". The corporate design now lives ` +
+        `in the slidemind add-in — run 'slidemind download-bundle <deck>' to ` +
+        `materialize it, then retry.`,
+    );
+  }
+
+  const deckLayouts = opts.deckDir ? path.join(opts.deckDir, "layouts") : null;
+  const deckAssets = opts.deckDir ? path.join(opts.deckDir, "assets") : null;
+  const deckPrimitives = opts.deckDir
+    ? path.join(opts.deckDir, "primitives.json")
+    : null;
+
+  const cssFile = firstExistingOr(
+    designRoots.map((r) => path.join(r, cssName)),
+    path.join(designRoots[0], cssName),
+  );
+  const layoutsDir = firstExistingOr(
+    [deckLayouts, ...designRoots.map((r) => path.join(r, "layouts"))],
+    path.join(designRoots[0], "layouts"),
+  );
+  const layoutsCssFile = firstExistingOr(
+    designRoots.map((r) => path.join(r, "layouts", "layouts.css")),
+    path.join(designRoots[0], "layouts", "layouts.css"),
+  );
+  const assetsDir = firstExistingOr(
+    [deckAssets, ...designRoots.map((r) => path.join(r, "assets"))],
+    path.join(designRoots[0], "assets"),
+  );
+  const primitivesPath = firstExistingOr(
+    [
+      deckPrimitives,
+      ...designRoots.map((r) => path.join(r, "primitives.json")),
+      SHIPPED_PRIMITIVES,
+    ],
+    SHIPPED_PRIMITIVES,
+  );
+  // One truth: brand paths mirror the resolved design roots (the bundle IS the
+  // brand source; there is no separate brand skill anymore).
+  const brand = {
+    skillDir: designRoots[0],
+    assetsDir,
+    cssFile,
+    layoutsDir,
+    layoutsCssFile,
+    primitivesPath,
+  };
+
+  // The PPTX slide-master template only fed the now-archived local exporter;
+  // resolve it only if a manifest still declares one and the file exists.
+  const mode = manifest.mode || "compose";
+  let templatePath = null;
+  let templateKey = null;
+  if (manifest.templates) {
+    templateKey =
+      planMeta.template ||
+      manifest.defaultTemplate ||
+      Object.keys(manifest.templates)[0];
+    const rel = manifest.templates[templateKey];
+    const candidate =
+      rel && fs.existsSync(skillDir) ? path.join(skillDir, rel) : null;
+    if (candidate && fs.existsSync(candidate)) templatePath = candidate;
+  }
+
+  return {
+    skillName,
+    skillDir,
+    manifest,
+    mode,
+    cssFile,
+    layoutsDir,
+    assetsDir,
+    primitivesPath,
+    brand,
+    templateKey,
+    templatePath,
+    locale: planMeta.locale || null,
+    packageRoot: PACKAGE_ROOT,
+    bundleDir,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// plan.md frontmatter
+// ---------------------------------------------------------------------------
+
+function readPlanFrontmatter(deckDir) {
+  if (!deckDir) return {};
+  const file = path.join(deckDir, "plan.md");
+  if (!fs.existsSync(file)) return {};
+  const text = fs.readFileSync(file, "utf8");
+  if (!text.startsWith("---")) return {};
+  const end = text.indexOf("\n---", 3);
+  if (end < 0) return {};
+  const body = text.slice(3, end);
+  const out = {};
+  for (const line of body.split("\n")) {
+    const m = line.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.+?)\s*$/);
+    if (m) out[m[1]] = stripQuotes(m[2]);
+  }
+  return out;
+}
+
+function stripQuotes(s) {
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+// ---------------------------------------------------------------------------
+// skill.json manifest
+// ---------------------------------------------------------------------------
+
+function readManifest(skillDir) {
+  const file = path.join(skillDir, "skill.json");
+  if (!fs.existsSync(file)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (err) {
+    throw new Error(`Invalid skill.json in ${skillDir}: ${err.message}`);
+  }
+}

package/src/builders/runtime-applier.js

@@ -0,0 +1,275 @@
+// Runtime applier — consumes decks/<slug>/overrides.json and mutates the
+// live slide DOM to reflect styles, positions, hidden chrome, and
+// user-added free text elements.
+//
+// The overlay loads first (at the end of <body>); this file loads in <head>
+// so its global API is ready by the time overlay.js wires callbacks into it.
+
+(() => {
+  const DECK_ROOT_SEL = "#stage";
+
+  // Shape: { version: 1, slides: { "<slideName>": { styles, positions, hidden, freeElements } } }
+  let overrides = { version: 1, slides: {} };
+  let currentSlide = null;
+  let navObserver = null;
+
+  // We observe the stage so overrides re-apply after every React reconcile.
+  let observer = null;
+  // Drag/resize gestures pause the observer so optimistic inline-style writes
+  // aren't clobbered mid-gesture by an override re-apply triggered by the
+  // mutations the gesture itself causes. Counted so nested pauses are safe.
+  let observerPaused = 0;
+
+  function ensureObserver() {
+    if (observer) return;
+    const stage = document.querySelector(DECK_ROOT_SEL);
+    if (!stage) return;
+    observer = new MutationObserver(() => {
+      if (observerPaused > 0) return;
+      if (currentSlide) applySlide(currentSlide);
+    });
+    observer.observe(stage, { childList: true, subtree: true });
+  }
+
+  function pauseObserver() {
+    observerPaused++;
+  }
+  function resumeObserver() {
+    observerPaused = Math.max(0, observerPaused - 1);
+  }
+
+  function registerOverrides(nextOverrides) {
+    overrides = nextOverrides || { version: 1, slides: {} };
+    if (currentSlide) applySlide(currentSlide);
+  }
+
+  function setCurrentSlide(slideName) {
+    currentSlide = slideName;
+    ensureObserver();
+    applySlide(slideName);
+  }
+
+  function watchDeckNav() {
+    if (navObserver) return;
+    const nav = document.getElementById("nav");
+    if (!nav) return;
+    const sync = () => {
+      const text = nav.textContent || "";
+      const match = text.match(/^\d+\s*\/\s*\d+\s+·\s+(\S+)/);
+      if (match) setCurrentSlide(match[1]);
+    };
+    sync();
+    navObserver = new MutationObserver(sync);
+    navObserver.observe(nav, { childList: true, characterData: true, subtree: true });
+  }
+
+  function applySlide(slideName, rootArg) {
+    const root = rootArg || document.querySelector(DECK_ROOT_SEL);
+    if (!root) return;
+    const slideEl = root.querySelector(".slide") || root;
+    if (!slideEl) return;
+    const o = overrides.slides ? overrides.slides[slideName] : null;
+    // Strip any free elements that don't belong to this slide (cross-slide
+    // leftovers from a previous render). Keep only those in the current set.
+    const wantedFreeIds = new Set(
+      (o && o.freeElements ? o.freeElements.map((f) => f.id) : []),
+    );
+    for (const fe of root.querySelectorAll("[data-free-id]")) {
+      if (!wantedFreeIds.has(fe.getAttribute("data-free-id"))) {
+        fe.remove();
+      }
+    }
+
+    // Clear ghost inline styles from elements that no longer have an
+    // override. Without this, an undo/clear leaves the element pinned at the
+    // old absolute position because we only ever *set* properties.
+    for (const el of root.querySelectorAll("[data-edit-id]")) {
+      if (el.hasAttribute("data-free")) continue;
+      const id = el.getAttribute("data-edit-id");
+      const hasPos = !!(o && o.positions && o.positions[id]);
+      if (!hasPos) {
+        el.style.removeProperty("position");
+        el.style.removeProperty("left");
+        el.style.removeProperty("top");
+        el.style.removeProperty("width");
+        el.style.removeProperty("height");
+        el.style.removeProperty("z-index");
+      }
+      const hasStyle = !!(o && o.styles && o.styles[id]);
+      if (!hasStyle) {
+        el.style.removeProperty("color");
+        el.style.removeProperty("font-size");
+        el.style.removeProperty("font-weight");
+      }
+      const hidden = !!(o && o.hidden && o.hidden[id]);
+      if (!hidden && el.style.display === "none") {
+        el.style.removeProperty("display");
+      }
+    }
+
+    if (!o) return;
+
+    // styles — write what's set, clear what isn't (idempotent).
+    if (o.styles) {
+      for (const editId of Object.keys(o.styles)) {
+        const el = findByEditId(root, editId);
+        if (!el) continue;
+        const s = o.styles[editId];
+        if (s.colorToken) el.style.setProperty("color", `var(${s.colorToken})`);
+        else el.style.removeProperty("color");
+        if (s.fontSizeToken)
+          el.style.setProperty("font-size", `var(${s.fontSizeToken})`);
+        else el.style.removeProperty("font-size");
+        if (s.fontWeight != null)
+          el.style.setProperty("font-weight", String(s.fontWeight));
+        else el.style.removeProperty("font-weight");
+      }
+    }
+
+    // positions — same idempotency rule. Clear any field that's missing so a
+    // partial override (e.g. zIndex-only) can't ghost stale left/top.
+    if (o.positions) {
+      for (const editId of Object.keys(o.positions)) {
+        const el = findByEditId(root, editId);
+        if (!el) continue;
+        const p = o.positions[editId];
+        // We assume any override target is drawn on the absolute-positioned
+        // .slide canvas; set position so our coords take effect even if
+        // the element was laid out by flex/grid inside a Mode B slide.
+        el.style.position = "absolute";
+        if (p.left != null) el.style.left = p.left + "px";
+        else el.style.removeProperty("left");
+        if (p.top != null) el.style.top = p.top + "px";
+        else el.style.removeProperty("top");
+        if (p.width != null) el.style.width = p.width + "px";
+        else el.style.removeProperty("width");
+        if (p.height != null) el.style.height = p.height + "px";
+        else el.style.removeProperty("height");
+        if (p.zIndex != null) el.style.zIndex = String(p.zIndex);
+        else el.style.removeProperty("z-index");
+      }
+    }
+
+    // hidden chrome (logos, page marks, etc. that we don't want on this slide)
+    if (o.hidden) {
+      for (const editId of Object.keys(o.hidden)) {
+        const el = findByEditId(root, editId);
+        if (!el) continue;
+        if (o.hidden[editId]) el.style.display = "none";
+        else el.style.removeProperty("display");
+      }
+    }
+
+    // free elements
+    if (o.freeElements && o.freeElements.length) {
+      for (const fe of o.freeElements) {
+        const wantImage = fe.kind === "image";
+        let el = root.querySelector(`[data-free-id="${cssEscape(fe.id)}"]`);
+        // If the kind switched (e.g. text -> image) the existing node has the
+        // wrong tagName; drop it so we re-create cleanly.
+        if (el) {
+          const isImg = el.tagName === "IMG";
+          if (wantImage !== isImg) {
+            el.remove();
+            el = null;
+          }
+        }
+        if (!el) {
+          el = document.createElement(wantImage ? "img" : "div");
+          el.setAttribute("data-free-id", fe.id);
+          el.setAttribute("data-edit-id", fe.id);
+          el.setAttribute("data-free", "1");
+          if (wantImage) {
+            el.setAttribute("data-free-kind", "image");
+            el.setAttribute("draggable", "false");
+            el.setAttribute("alt", "");
+          }
+          slideEl.appendChild(el);
+        } else if (el.parentNode !== slideEl) {
+          // re-parent if React re-created the slide element
+          slideEl.appendChild(el);
+        }
+        el.style.position = "absolute";
+        el.style.left = (fe.x ?? 100) + "px";
+        el.style.top = (fe.y ?? 100) + "px";
+        if (fe.width != null) el.style.width = fe.width + "px";
+        if (fe.height != null) el.style.height = fe.height + "px";
+        el.style.zIndex = String(fe.zIndex ?? 4);
+        el.style.pointerEvents = "auto";
+        if (wantImage) {
+          // Mode B image free element. PPTX export does NOT support these
+          // (build-pptx.py has no body-builder for arbitrary uploads); warn so
+          // the user knows the deck won't round-trip 1:1 to PowerPoint.
+          if (!el.__warnedImagePptx) {
+            console.warn(
+              "[editor] image free-element will NOT export to .pptx:",
+              { id: fe.id, src: fe.src },
+            );
+            el.__warnedImagePptx = true;
+          }
+          el.style.objectFit = "contain";
+          // Reset any text-mode bleed-through.
+          el.style.color = "";
+          el.style.fontSize = "";
+          el.style.fontWeight = "";
+          el.style.lineHeight = "";
+          el.style.fontFamily = "";
+          el.style.whiteSpace = "";
+          if (fe.src && el.getAttribute("src") !== fe.src) {
+            el.setAttribute("src", fe.src);
+          }
+        } else {
+          el.style.color = fe.colorToken
+            ? `var(${fe.colorToken})`
+            : "var(--fg-2)";
+          el.style.fontSize = fe.fontSizeToken
+            ? `var(${fe.fontSizeToken})`
+            : "var(--fs-body)";
+          el.style.fontWeight = fe.fontWeight ? String(fe.fontWeight) : "400";
+          el.style.lineHeight = "var(--lh-body, 1.45)";
+          el.style.fontFamily = "var(--font-sans)";
+          el.style.whiteSpace = "pre-line";
+          // Only write textContent if the user isn't actively editing this
+          // element (overlay sets contenteditable when editing).
+          if (!el.hasAttribute("contenteditable")) {
+            el.textContent = fe.text || "";
+          }
+        }
+      }
+    }
+  }
+
+  function findByEditId(root, editId) {
+    // Prefer the first visible match. CSS.escape handles slashes and colons
+    // in our id scheme.
+    return root.querySelector(`[data-edit-id="${cssEscape(editId)}"]`);
+  }
+
+  function cssEscape(s) {
+    if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {
+      return CSS.escape(s);
+    }
+    return String(s).replace(/["\\]/g, "\\$&");
+  }
+
+  // Public API for overlay.js
+  window.SlideEditor = window.SlideEditor || {};
+  window.SlideEditor.registerOverrides = registerOverrides;
+  window.SlideEditor.setCurrentSlide = setCurrentSlide;
+  window.SlideEditor.getOverrides = () => overrides;
+  window.SlideEditor.applySlide = applySlide;
+  window.SlideEditor.applyOverridesTo = (root, slideName) =>
+    applySlide(slideName, root);
+  window.SlideEditor.findByEditId = findByEditId;
+  window.SlideEditor.pauseObserver = pauseObserver;
+  window.SlideEditor.resumeObserver = resumeObserver;
+
+  if (window.__SLIDE_EDITOR_OVERRIDES__) {
+    registerOverrides(window.__SLIDE_EDITOR_OVERRIDES__);
+  }
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", watchDeckNav);
+  } else {
+    watchDeckNav();
+  }
+})();

package/src/installers/brand-theme.mjs

@@ -0,0 +1,38 @@
+// Brand truecolor helpers for the installer UI.
+//
+// Tokens lifted directly from skills/create-slides/corporate-design.css
+// so the CLI palette matches the deck output. We bypass clack's own
+// theming (which is locked to util.styleText named colors at link time)
+// by injecting pre-colored glyphs through clack's `log.message({ symbol })`
+// hook instead.
+
+const FORCE_COLOR =
+  process.env.FORCE_COLOR === "1" || process.env.FORCE_COLOR === "true";
+const NO_COLOR =
+  !!process.env.NO_COLOR ||
+  (!FORCE_COLOR && (!process.stdout.isTTY || process.env.TERM === "dumb"));
+
+const tc = (r, g, b) => (s) =>
+  NO_COLOR ? String(s) : `\x1b[38;2;${r};${g};${b}m${s}\x1b[39m`;
+
+const fmt = (open, close) => (s) =>
+  NO_COLOR ? String(s) : `\x1b[${open}m${s}\x1b[${close}m`;
+
+// Brand palette (corporate-design.css → :root)
+export const brand = {
+  techBlue:   tc(0, 0, 255),     // #0000FF  primary
+  techBlue80: tc(51, 51, 255),   // #3333FF
+  techBlue40: tc(153, 153, 255), // #9999FF
+  techBlue20: tc(204, 204, 255), // #CCCCFF
+  black:      tc(0, 0, 0),       // #000000
+  ink:        tc(40, 52, 64),    // #283440  body text / dk2
+  slate:      tc(108, 125, 140), // #6C7D8C  secondary surfaces
+  gray:       tc(182, 189, 204), // #B6BDCC  tertiary
+  fog:        tc(235, 240, 242), // #EBF0F2
+  magenta:    tc(254, 13, 108),  // #FE0D6C  traffic-light / underline
+  green:      tc(0, 200, 0),     // #00C800  emphasis only
+  bold: fmt(1, 22),
+  dim: fmt(2, 22),
+};
+
+export const ANIMATE = !NO_COLOR && process.stdout.isTTY;

package/src/installers/claude.mjs

@@ -0,0 +1,141 @@
+// Install slidemind into Claude Code.
+//
+// Claude Code auto-discovers user-level skills at
+// `~/.claude/skills/<name>/SKILL.md`. The skill itself owns the user-facing
+// plan / create / edit workflow, so we no longer ship separate slash commands
+// — one skill, one source of truth.
+//
+// Layout after install:
+//   ~/.claude/skills/slidemind-create-slides/SKILL.md  + assets, layouts, icons, references, …
+//
+// We also actively unregister any prior `commands/slidemind/` directory and
+// any `mcpServers.slidemind` entry from a past install so re-running converges.
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+  expandHome,
+  installDir,
+  isForce,
+  isLinkMode,
+  listSkills,
+  rmIfExists,
+  ui,
+} from "./lib.mjs";
+
+const NAMESPACE = "slidemind";
+
+function claudeRoot() {
+  return expandHome("~/.claude");
+}
+
+function claudeUserConfigFile() {
+  // User-scope MCP servers live in ~/.claude.json (NOT ~/.claude/settings.json).
+  // The file is large and contains unrelated state, so we read-modify-write
+  // exactly the mcpServers.slidemind entry.
+  return expandHome("~/.claude.json");
+}
+
+function legacyCommandsDir() {
+  return path.join(claudeRoot(), "commands", NAMESPACE);
+}
+
+function skillTarget(skillName) {
+  return path.join(claudeRoot(), "skills", `${NAMESPACE}-${skillName}`);
+}
+
+function loadClaudeConfig() {
+  const file = claudeUserConfigFile();
+  if (!fs.existsSync(file)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8")) || {};
+  } catch {
+    throw new Error(
+      `Claude config at ${file} is not valid JSON; refusing to overwrite.`,
+    );
+  }
+}
+
+function saveClaudeConfig(cfg) {
+  const file = claudeUserConfigFile();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(cfg, null, 2) + "\n");
+}
+
+function unregisterMcpServer() {
+  const file = claudeUserConfigFile();
+  if (!fs.existsSync(file)) return;
+  const cfg = loadClaudeConfig();
+  if (cfg.mcpServers && cfg.mcpServers[NAMESPACE]) {
+    delete cfg.mcpServers[NAMESPACE];
+    if (Object.keys(cfg.mcpServers).length === 0) delete cfg.mcpServers;
+    saveClaudeConfig(cfg);
+  }
+}
+
+function registerMcpServer(packageRoot) {
+  const mcpServer = path.join(packageRoot, "src", "mcp", "server.mjs");
+  const cfg = loadClaudeConfig();
+  cfg.mcpServers = cfg.mcpServers || {};
+  cfg.mcpServers[NAMESPACE] = {
+    type: "stdio",
+    command: "node",
+    args: [mcpServer],
+  };
+  saveClaudeConfig(cfg);
+}
+
+export async function install({ packageRoot, flags }) {
+  const link = isLinkMode(flags);
+  const force = isForce(flags);
+
+  await ui.section("Claude Code", claudeRoot());
+
+  // Drop the legacy ~/.claude/commands/slidemind/ directory if a prior install
+  // created it — the workflow now lives inside the skill.
+  if (fs.existsSync(legacyCommandsDir())) {
+    rmIfExists(legacyCommandsDir());
+    ui.step({ status: "remove", label: "legacy", value: legacyCommandsDir() });
+  }
+
+  for (const skill of listSkills(packageRoot)) {
+    const dest = skillTarget(skill.name);
+    await ui.spin(
+      {
+        label: "skill",
+        value: dest,
+        note: link ? "linking" : "copying",
+        finalNote: link ? "linked" : "copied",
+      },
+      () => installDir({ src: skill.path, dest, link, force }),
+    );
+  }
+
+  // Register the slidemind MCP server so agents can list/push into open
+  // PowerPoint windows via slidemind_list_open_presentations / slidemind_push_deck.
+  registerMcpServer(packageRoot);
+  ui.step({ status: "ok", label: "mcp server", value: claudeUserConfigFile() });
+}
+
+export async function uninstall() {
+  await ui.section("Claude Code", claudeRoot());
+
+  if (fs.existsSync(legacyCommandsDir())) {
+    rmIfExists(legacyCommandsDir());
+    ui.step({ status: "remove", label: "legacy", value: legacyCommandsDir() });
+  }
+
+  const skillsRoot = path.join(claudeRoot(), "skills");
+  if (fs.existsSync(skillsRoot)) {
+    for (const entry of fs.readdirSync(skillsRoot)) {
+      if (entry.startsWith(`${NAMESPACE}-`)) {
+        const target = path.join(skillsRoot, entry);
+        rmIfExists(target);
+        ui.step({ status: "remove", label: "skill", value: target });
+      }
+    }
+  }
+
+  unregisterMcpServer();
+  ui.step({ status: "info", label: "mcp server", value: "unregistered" });
+}