slidemind 0.3.13 → 0.3.14

package/src/cli/deck.mjs

@@ -0,0 +1,608 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { fail, requirePlanApproved, requireReviewApproved, resolveDeckArg, runNode, splitDeckArg, renderProgressPrinter, dataUriToPng, freshenDeckBundle, withUnboundHint, SRC_DIR, BUILDERS_DIR } from "./common.mjs";
+
+export async function cmdPlan(rest) {
+  const { deck, passthrough } = splitDeckArg(rest, "plan");
+  await runNode(path.join(BUILDERS_DIR, "plan.mjs"), [
+    "--deck",
+    resolveDeckArg(deck),
+    ...passthrough,
+  ]);
+}
+
+export async function cmdReview(rest) {
+  const { deck, passthrough } = splitDeckArg(rest, "review");
+  const deckDir = resolveDeckArg(deck);
+  await requirePlanApproved(deckDir);
+  await freshenDeckBundle(deckDir);
+  await runNode(path.join(BUILDERS_DIR, "review.mjs"), ["--deck", deckDir, ...passthrough]);
+}
+
+// Generate one regular image via the paired add-in's image model and write it
+// into the deck's assets/. Pane-free: routes by the deck's bound design
+// (.bundle-ref.json), so it works with PowerPoint backgrounded or closed.
+export async function cmdImagen(rest) {
+  let prompt = null;
+  let deck = null;
+  let outName = null;
+  let size = null;
+  let quality = null;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--deck") {
+      deck = rest[++i];
+      if (!deck) fail("--deck expects a deck");
+    } else if (a === "--out" || a === "-o") {
+      outName = rest[++i];
+      if (!outName) fail("--out expects a file name");
+    } else if (a === "--size") {
+      size = rest[++i];
+      if (!["auto", "1024x1024", "1536x1024", "1024x1536"].includes(size ?? "")) {
+        fail("--size expects auto|1024x1024|1536x1024|1024x1536");
+      }
+    } else if (a === "--quality") {
+      quality = rest[++i];
+      if (!["low", "medium", "high", "auto"].includes(quality ?? "")) {
+        fail("--quality expects low|medium|high|auto");
+      }
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else if (prompt === null) {
+      prompt = a;
+    } else {
+      fail(`unexpected argument: ${a} (quote the prompt as one argument)`);
+    }
+  }
+  if (!prompt || !prompt.trim() || !deck) {
+    fail(
+      'usage: slidemind imagen "<prompt>" --deck <deck> [--out <name.png>] ' +
+        "[--size auto|1024x1024|1536x1024|1024x1536] [--quality low|medium|high|auto]",
+    );
+  }
+  const deckDir = resolveDeckArg(deck);
+  const bundleMod = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
+  );
+  const ref = bundleMod.readDeckBundleRef(deckDir);
+  if (!ref?.presFP) {
+    fail(
+      `deck ${path.basename(deckDir)} is not bound to a design yet — run ` +
+        `'slidemind ready ${deck}' first (imagen routes by the deck's bound design).`,
+    );
+  }
+  const client = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+  );
+  process.stdout.write("  generating image (this can take a minute)…\n");
+  let result;
+  try {
+    result = await client.generateImageForBrand(ref.presFP, {
+      prompt,
+      size,
+      quality,
+    });
+  } catch (err) {
+    if (err?.code === "imagen_route_unavailable") {
+      fail(
+        `${err.message}\n  The paired add-in does not offer image generation yet — ` +
+          `it ships with the next add-in update; until then add pictures to assets/ by hand ` +
+          `or via 'slidemind download-result'.`,
+      );
+    }
+    throw err;
+  }
+  const m = /^data:image\/(png|jpe?g);base64,(.+)$/.exec(result?.image ?? "");
+  if (!m) fail("backend returned no image data");
+  const ext = m[1] === "png" ? "png" : "jpeg";
+  const assetsDir = path.join(deckDir, "assets");
+  fs.mkdirSync(assetsDir, { recursive: true });
+  let file = outName;
+  if (!file) {
+    let n = 1;
+    while (fs.existsSync(path.join(assetsDir, `imagen-${n}.${ext}`))) n++;
+    file = `imagen-${n}.${ext}`;
+  }
+  const outPath = path.join(assetsDir, file);
+  fs.writeFileSync(outPath, Buffer.from(m[2], "base64"));
+  process.stdout.write(
+    `Wrote ${path.relative(process.cwd(), outPath)}\n` +
+      `  Reference it from slide props as "assets/${file}" (e.g. summaryImage, illustration).\n`,
+  );
+}
+
+export async function cmdInspectTemplateDeck(rest) {
+  const { deck, passthrough } = splitDeckArg(rest, "inspect-template-deck");
+  let packDir = null;
+  let json = false;
+  let allowUnrenderedFreeform = false;
+  for (let i = 0; i < passthrough.length; i++) {
+    const a = passthrough[i];
+    if (a === "--pack") {
+      packDir = passthrough[++i];
+      if (!packDir) fail("--pack expects a directory");
+    } else if (a === "--json") {
+      json = true;
+    } else if (a === "--allow-unrendered-freeform") {
+      allowUnrenderedFreeform = true;
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else {
+      fail(`unexpected argument: ${a}`);
+    }
+  }
+  if (!packDir) fail("inspect-template-deck requires --pack <dir>");
+
+  const deckDir = resolveDeckArg(deck);
+  const resolveMod = await import(
+    pathToFileURL(path.join(SRC_DIR, "builders", "resolve-skill.mjs")).href
+  );
+  const skill = resolveMod.resolveSkillForDeck(deckDir, {
+    packDir: path.resolve(packDir),
+  });
+  if (skill.mode !== "fill-template") {
+    fail(`pack ${skill.skillDir} is mode ${skill.mode}, not fill-template`);
+  }
+  const engine = await import(
+    pathToFileURL(path.join(SRC_DIR, "pptx", "fill", "engine.mjs")).href
+  );
+  const result = engine.inspectFillTemplateDeck({
+    deckDir,
+    skill,
+    allowUnrenderedFreeform,
+  });
+  const payload = {
+    version: 1,
+    pack: {
+      name: skill.skillName,
+      mode: skill.mode,
+      directory: skill.skillDir,
+      template: result.templateKey,
+      locale: result.locale,
+    },
+    slides: result.sequence,
+    warnings: result.warnings,
+    problems: result.problems,
+  };
+  if (json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    for (const item of result.sequence) {
+      const suffix = item.kind === "master" ? ` → template ${item.no}` : "";
+      process.stdout.write(`${item.file}: ${item.kind}${suffix}\n`);
+    }
+    for (const warning of result.warnings) process.stderr.write(`  warning: ${warning}\n`);
+  }
+  if (result.problems.length) {
+    fail(`inspection failed:\n  - ${result.problems.join("\n  - ")}`);
+  }
+}
+
+export async function cmdBuildPptx(rest) {
+  const { deck, passthrough } = splitDeckArg(rest, "build-pptx");
+  let to = null;
+  let outPath = null;
+  let packDir = null;
+  let force = false;
+  let asJson = false;
+  for (let i = 0; i < passthrough.length; i++) {
+    const a = passthrough[i];
+    if (a === "--force") {
+      force = true;
+    } else if (a === "--json") {
+      asJson = true;
+    } else if (a === "--to") {
+      to = passthrough[++i];
+      if (!to) fail("--to expects a presId");
+    } else if (a === "--pack") {
+      packDir = passthrough[++i];
+      if (!packDir) fail("--pack expects a directory");
+    } else if (a === "--out" || a === "-o") {
+      outPath = passthrough[++i];
+      if (!outPath) fail("--out expects a path");
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else {
+      fail(`unexpected argument: ${a}`);
+    }
+  }
+  const deckDir = resolveDeckArg(deck);
+  if (!fs.existsSync(path.join(deckDir, "slides"))) {
+    fail(`expected 'slides/' folder in ${deckDir}`);
+  }
+
+  // Template packs (mode: fill-template) build LOCALLY: the deck's slides are
+  // declarative fills over a template .pptx that ships in the pack, so no
+  // add-in render is involved and no PowerPoint host is needed. Compose decks
+  // take the bridge path below UNTOUCHED — the mode probe never throws, so a
+  // compose deck with an unmaterialized bundle still self-heals in the render.
+  const resolveMod = await import(
+    pathToFileURL(path.join(SRC_DIR, "builders", "resolve-skill.mjs")).href
+  );
+  const resolveOpts = packDir ? { packDir: path.resolve(packDir) } : {};
+  const deckMode = resolveMod.resolveDeckMode(deckDir, resolveOpts);
+  if (packDir && deckMode.mode !== "fill-template") {
+    fail(`explicit --pack ${path.resolve(packDir)} is mode ${deckMode.mode}, not fill-template`);
+  }
+  // Template packs have no HTML preview to review and carry their own plan
+  // sign-off; compose decks ship only from an approved, unchanged preview.
+  if (deckMode.mode !== "fill-template") {
+    await requireReviewApproved(deckDir);
+    await freshenDeckBundle(deckDir);
+  }
+  if (deckMode.mode === "fill-template") {
+    const skill = resolveMod.resolveSkillForDeck(deckDir, resolveOpts);
+    if (to) {
+      fail(
+        "--to targets a PowerPoint window, but fill-template decks build " +
+          "locally from the pack's template — drop --to (use 'slidemind push' " +
+          "to get slides into a window).",
+      );
+    }
+    // In-deck freeform slides (create-slides JSX next to the master-backed
+    // ones) render to sibling NN.pptx artifacts first — the only step that
+    // talks to the add-in; unchanged freeform slides keep the build offline.
+    const freeform = await import(
+      pathToFileURL(path.join(SRC_DIR, "pptx", "fill", "freeform.mjs")).href
+    );
+    const ff = await freeform.ensureFreeformRenders({
+      deckDir,
+      locale: skill.locale ?? "en",
+      srcDir: SRC_DIR,
+      // Both are the PACK's contract, read from its skill.json — this CLI
+      // knows no layout names and no template-fixed titles of its own.
+      components: {
+        ...(skill.manifest?.components ?? {}),
+        skillDir: skill.skillDir,
+      },
+      policy: skill.manifest?.policy ?? {},
+      onLog: (line) => process.stdout.write(`  ${line}\n`),
+    });
+    for (const w of ff.warnings) process.stderr.write(`  warning: ${w}\n`);
+
+    const engine = await import(
+      pathToFileURL(path.join(SRC_DIR, "pptx", "fill", "engine.mjs")).href
+    );
+    const result = await engine.buildFillTemplateDeck({
+      deckDir,
+      skill,
+      outPath,
+      onLog: (line) => process.stdout.write(`  ${line}\n`),
+    });
+    if (asJson) {
+      process.stdout.write(`${JSON.stringify({ outPath: result.outPath, slideCount: result.slideCount, template: skill.templateKey, windowless: true, warnings: result.warnings ?? [] }, null, 2)}\n`);
+    } else {
+      process.stdout.write(
+        `Wrote ${result.outPath} (${result.slideCount} slides) from template ` +
+          `'${skill.templateKey}' — host-free\n`,
+      );
+    }
+    for (const w of result.warnings ?? []) {
+      process.stderr.write(`  warning: ${w}\n`);
+    }
+    return;
+  }
+
+  // The .pptx is rendered server-side by the add-in (one exporter, one truth).
+  // A bound deck renders pane-free over the brand routes — no PowerPoint
+  // window needed; unbound decks (or --to) resolve through the pane registry.
+  const mod = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "build-and-push.mjs")).href
+  );
+  const result = await mod
+    .buildPptxFile({
+      deckDir,
+      presentationId: to,
+      outPath,
+      force,
+      onProgress: renderProgressPrinter(),
+    })
+    .catch((err) => fail(withUnboundHint(deckDir, err)));
+  if (asJson) {
+    process.stdout.write(
+      `${JSON.stringify({ outPath: result.outPath, slideCount: result.slideCount ?? null, presId: result.presId ?? null, windowless: Boolean(result.windowless), warnings: result.warnings ?? [], skippedSlides: result.skippedSlides ?? [] }, null, 2)}\n`,
+    );
+  } else {
+    process.stdout.write(
+      `Wrote ${result.outPath} (${result.slideCount ?? "?"} slides) via the slidemind add-in` +
+        `${result.windowless ? " (no PowerPoint window needed)" : ""}\n`,
+    );
+  }
+  for (const w of result.warnings ?? []) {
+    process.stderr.write(`  warning: ${w}\n`);
+  }
+  for (const s of result.skippedSlides ?? []) {
+    process.stderr.write(`  skipped ${s.stem}: ${s.reason}\n`);
+  }
+}
+
+export async function cmdViewDraft(rest) {
+  const { deck, passthrough } = splitDeckArg(rest, "view-draft");
+  let to = null;
+  let outDir = null;
+  let open = false;
+  let onlySpec = null;
+  // The server's export gate runs by default: the 422 it would raise at
+  // build-pptx (after the user approved) surfaces here instead. "auto" skips
+  // with a note when the backend is unreachable; --translate insists, and
+  // --no-translate keeps the check purely local.
+  let translate = "auto";
+  let fix = false;
+  let lintOnly = false;
+  let asJson = false;
+  for (let i = 0; i < passthrough.length; i++) {
+    const a = passthrough[i];
+    if (a === "--fix") {
+      fix = true;
+    } else if (a === "--lint-only") {
+      lintOnly = true;
+    } else if (a === "--json") {
+      asJson = true;
+    } else if (a === "--no-translate") {
+      translate = false;
+    } else if (a === "--to") {
+      to = passthrough[++i];
+      if (!to) fail("--to expects a presId");
+    } else if (a === "--out" || a === "-o") {
+      outDir = passthrough[++i];
+      if (!outDir) fail("--out expects a directory");
+    } else if (a === "--open") {
+      open = true;
+    } else if (a === "--translate") {
+      translate = true;
+    } else if (a === "--only") {
+      onlySpec = passthrough[++i];
+      if (!onlySpec) fail("--only expects a slide file or number (comma-separated for several)");
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else {
+      fail(`unexpected argument: ${a}`);
+    }
+  }
+  const deckDir = resolveDeckArg(deck);
+  if (!fs.existsSync(path.join(deckDir, "slides"))) {
+    fail(`expected 'slides/' folder in ${deckDir}`);
+  }
+  // --only: a per-slide builder re-checks its own file. Accepts file names
+  // (`03-loop.jsx`) or slide numbers (`3`, `03`), resolved by numeric prefix.
+  let only = null;
+  if (onlySpec) {
+    const files = fs.readdirSync(path.join(deckDir, "slides")).filter((f) => f.endsWith(".jsx"));
+    only = onlySpec.split(",").map((t) => t.trim()).filter(Boolean).map((t) => {
+      if (files.includes(t)) return t;
+      if (/^\d{1,3}$/.test(t)) {
+        const hit = files.find((f) => Number(/^(\d{1,3})[-_.]/.exec(f)?.[1]) === Number(t));
+        if (hit) return hit;
+      }
+      fail(`--only: no slide file matches '${t}' under ${path.join(deckDir, "slides")}`);
+    });
+  }
+  await requirePlanApproved(deckDir);
+  await freshenDeckBundle(deckDir);
+  // The HTML build runs FIRST — it is what lints every slide against the
+  // bundle's capability table and copies the bundle's corporate-design.css +
+  // assets into the deck, which the type-ramp check below reads. (This is the
+  // work the retired `slidemind build` command used to do in a separate call;
+  // `--fix` is its autofix, folded in with it.)
+  const { buildDeck } = await import(
+    pathToFileURL(path.join(BUILDERS_DIR, "build.mjs")).href
+  );
+  if (fix) {
+    const { fixDeckSlides } = await import(
+      pathToFileURL(path.join(BUILDERS_DIR, "lint-fix.mjs")).href
+    );
+    const fixed = fixDeckSlides(deckDir);
+    if (fixed.fixes > 0) {
+      process.stdout.write(
+        `Autofixed ${fixed.fixes} lint issue(s) in ${fixed.files} slide file(s) — re-read any file before patching it.\n`,
+      );
+    }
+  }
+  await buildDeck(deckDir);
+  if (lintOnly) {
+    if (asJson) process.stdout.write(`${JSON.stringify({ deck: path.basename(deckDir), lint: "clean" })}\n`);
+    else process.stdout.write("Lint clean (no render — drop --lint-only for the draft previews).\n");
+    return;
+  }
+  // Draft previews are produced locally by the add-in's shipped capture engine
+  // (no push, no .pptx) — the same module that hosts the render+push path.
+  const mod = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "build-and-push.mjs")).href
+  );
+  // The capture engine lints every slide again and prints the same lines the
+  // build just did; mute that second copy (its warnings still ride the result).
+  const stderrWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = (chunk, ...args) =>
+    /^\s*\[lint:(warn|error|note)\]/.test(String(chunk)) ? true : stderrWrite(chunk, ...args);
+  let result;
+  try {
+    result = await mod.viewDraft(deckDir, {
+      presentationId: to,
+      onProgress: renderProgressPrinter(),
+      only,
+      // The server's export gate (slot-fit, diagram geometry, connector
+      // endpoints) on the captured slides, verdict only, no .pptx, no review
+      // gate — so a slide is proven buildable before hand-over.
+      translate,
+    });
+  } catch (err) {
+    process.stderr.write = stderrWrite;
+    fail(withUnboundHint(deckDir, err));
+  }
+  process.stderr.write = stderrWrite;
+  // Everything below prints through `out` so --json can hand back one payload
+  // instead of the human lines (the lint lines already went to stderr).
+  const out = asJson ? () => {} : (text) => process.stdout.write(text);
+  const slidesOut = [];
+
+  const previewDir = outDir
+    ? path.resolve(process.cwd(), outDir)
+    : path.join(deckDir, ".draft-preview");
+  fs.mkdirSync(previewDir, { recursive: true });
+
+  // The measured half of the draft check — the same mechanics the add-in's
+  // see_draft runs (fill bands, inventory rows) so a low-effort agent reads
+  // defects as text instead of judging pixels. Images stay CLEAN: no overlay
+  // on the render and none on the concept — a magenta grid dominated both
+  // and hid whether the slide was actually built well; the content area is
+  // enforced by the lint and the slot-fit check, not by eye.
+  const check = await import(
+    pathToFileURL(path.join(BUILDERS_DIR, "draft-check.mjs")).href
+  );
+  const conceptsDir = path.join(deckDir, "concepts");
+  const conceptFor = (fileName) => {
+    const m = /^(\d{1,3})[-_.]/.exec(fileName);
+    if (!m) return null;
+    const file = path.join(conceptsDir, `concept-slide-${String(Number(m[1])).padStart(2, "0")}.png`);
+    return fs.existsSync(file) ? file : null;
+  };
+  const inventory = check.inventoryWarnings(
+    deckDir,
+    (result.slides ?? []).map((s) => s.fileName).filter((f) => f.endsWith(".jsx")),
+  );
+  const deckLevel = inventory.filter((l) => l.includes("] assets/"));
+  // The measured rules come from the add-in's capture engine in the bundle —
+  // the same fill / type-scale / overlap checks see_draft runs in-app.
+  const { loadDraftChecks } = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "capture.mjs")).href
+  );
+  const { resolveBundleDirForDeck } = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
+  );
+  const rules = await loadDraftChecks(resolveBundleDirForDeck(deckDir));
+  if (!rules) {
+    fail(
+      "the design bundle's capture engine exports no draft checks — the connected add-in predates them. Update the add-in deployment, then run `slidemind download-bundle <deck>` and retry.",
+    );
+  }
+  // Type ramp from the deck's own copy of the bundle css (build copies it in).
+  let typeTokens = null;
+  try {
+    typeTokens = rules.typeScaleTokens(
+      fs.readFileSync(path.join(deckDir, "corporate-design.css"), "utf8"),
+    );
+  } catch {
+    typeTokens = null;
+  }
+  const measuredLines = (stem, render) =>
+    [
+      ...rules.fill([{ stem, render }]),
+      ...rules.typeScale([{ stem, render }], typeTokens),
+      ...rules.overlap([{ stem, render }]),
+    ].map((l) => l.trim());
+
+  const written = [];
+  const record = [];
+  let measured = 0;
+  for (const slide of result.slides ?? []) {
+    const png = slide.png ?? (slide.dataUri ? dataUriToPng(slide.dataUri) : null);
+    if (png) {
+      const stem = slide.fileName.replace(/\.[^.]+$/, "");
+      const file = path.join(previewDir, `${stem}.png`);
+      fs.writeFileSync(file, png);
+      written.push(file);
+      const flag = slide.status === "degraded" ? " (DEGRADED)" : "";
+      out(`  ${slide.fileName}${flag} → ${file}\n`);
+      if (slide.note) process.stderr.write(`    note: ${slide.note}\n`);
+      const concept = conceptFor(slide.fileName);
+      const defects =
+        slide.status === "ok"
+          ? [
+              ...measuredLines(stem, slide.render),
+              ...inventory.filter((l) => l.includes(` slides/${slide.fileName} `)),
+              ...(slide.translateErrors ?? []),
+            ]
+          : [];
+      if (concept) {
+        out(
+          `    concept: ${concept} — compare against the render above: every organism present at the same relative position and share, every connector present, no region emptier than in the concept.\n`,
+        );
+      }
+      for (const line of defects) out(`    ${line}\n`);
+      measured += defects.length;
+      slidesOut.push({ file: slide.fileName, status: slide.status, png: file, concept, defects, note: slide.note ?? null });
+      const jsxFile = path.join(deckDir, "slides", slide.fileName);
+      if (slide.status === "ok" && fs.existsSync(jsxFile)) {
+        record.push({ fileName: slide.fileName, hash: check.hashFile(jsxFile), defects });
+      }
+    } else {
+      out(`  ${slide.fileName} — ${slide.note ?? slide.status}\n`);
+      slidesOut.push({ file: slide.fileName, status: slide.status, png: null, concept: null, defects: [], note: slide.note ?? null });
+    }
+  }
+  for (const line of deckLevel) out(`  ${line}\n`);
+  measured += deckLevel.length;
+  const translateRan = translate && result.translateRan !== false;
+  if (translateRan) {
+    const failed = (result.slides ?? []).filter((s) => s.translateErrors?.length).length;
+    out(
+      failed
+        ? `  TRANSLATE GATE: ${failed} slide${failed === 1 ? "" : "s"} refused by the export gate (lines above) — these are the errors build-pptx would stop on.\n`
+        : "  TRANSLATE GATE: every rendered slide passed the export gate (slot-fit, diagram geometry, connector endpoints).\n",
+    );
+    for (const w of result.translateWarnings ?? []) process.stderr.write(`  note: ${w}\n`);
+  }
+  const verdict = check.verdictBlocker(deckDir);
+  if (verdict) {
+    out(
+      `  self-check: ${verdict.replace(/\n\s+/g, "; ")}\n` +
+        "  (under each slide in asset-plan.md: `draft-check:` then `- [x] <organism>` per organism found in the render, `- [ ] <organism> — <what differs>` otherwise; `review` refuses until every organism is ticked [x])\n",
+    );
+  }
+  if (record.length > 0 && !outDir) {
+    // Deck-level asset lines are recorded on the first slide so they stand
+    // until that slide (or the asset plan) changes.
+    if (deckLevel.length > 0) record[0].defects.push(...deckLevel);
+    // A partial run (--only) updates its slides and keeps the others' record.
+    const prior = only ? check.loadDraftCheck(deckDir)?.slides ?? {} : {};
+    const rendered = new Set(record.map((r) => r.fileName));
+    const kept = Object.entries(prior)
+      .filter(([f]) => !rendered.has(f))
+      .map(([fileName, e]) => ({ fileName, hash: e.hash, defects: e.defects ?? [] }));
+    check.saveDraftCheck(deckDir, [...record, ...kept]);
+  }
+  if (written.length === 0) {
+    out(
+      "No draft preview images were produced (no freeform slides to capture).\n",
+    );
+  } else if (measured > 0) {
+    out(
+      `DRAFT CHECK: ${measured} measured defect${measured === 1 ? "" : "s"} (above) — fix them in the JSX and re-run ` +
+        "`slidemind view-draft`; `slidemind review` does not open while they stand. " +
+        `Previews in ${previewDir} — NOT pushed.\n`,
+    );
+  } else {
+    out(
+      `DRAFT CHECK: no measured defects. Wrote ${written.length} draft preview${written.length === 1 ? "" : "s"} to ${previewDir} — NOT pushed. ` +
+        "Now diff each preview against its concept; fix anything visibly wrong in the JSX, then re-run, or 'slidemind review' / 'push' when sound.\n",
+    );
+  }
+  // The capture lints again on its own; those lines already printed above.
+  const warnings = (result.warnings ?? []).filter((w) => !/\[lint:(warn|error|note)\]/.test(w));
+  for (const w of warnings) process.stderr.write(`  warning: ${w}\n`);
+  if (asJson) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          deck: path.basename(deckDir),
+          previewDir,
+          slides: slidesOut,
+          measuredDefects: measured,
+          translateGate: translateRan ? (slidesOut.some((s) => s.defects.some((d) => /:error\]/.test(d))) ? "failed" : "passed") : "skipped",
+          selfCheck: verdict ? "incomplete" : "ok",
+          reviewCanOpen: measured === 0 && !verdict,
+          warnings,
+        },
+        null,
+        2,
+      )}\n`,
+    );
+  }
+  if (open && written.length > 0) {
+    const { openInBrowser } = await import(
+      pathToFileURL(path.join(BUILDERS_DIR, "build.mjs")).href
+    );
+    for (const file of written) openInBrowser(file);
+  }
+}