slidemind 0.3.13 → 0.3.14

package/src/builders/review.mjs

@@ -46,6 +46,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { buildDeck, openInBrowser } from "./build.mjs";
+import { draftCheckBlocker, verdictBlocker } from "./draft-check.mjs";
 import { resolveSkillForDeck } from "./resolve-skill.mjs";
 import { resolveBrandAsset } from "../bridge/bundle.mjs";
 import {
@@ -502,9 +503,25 @@ export async function runReview({
   // quiet: serveAndOpen's BROWSER: line owns all open/failed messaging.
   open = (url) => openInBrowser(url, { quiet: true }),
   openFailedGraceMs = OPEN_FAILED_GRACE_MS,
+  allowDraftDefects = false,
 } = {}) {
   await buildDeck(deckDir);
 
+  // The gate does not open on defects the last draft check MEASURED (fill
+  // bands, dropped connectors, unused assets) while the slide files are
+  // unchanged since: a warning printed after "task done" is a warning nobody
+  // acts on. Editing the slide re-arms the check; --allow-draft-defects is
+  // the explicit override.
+  if (!allowDraftDefects) {
+    const standing = draftCheckBlocker(deckDir) ?? verdictBlocker(deckDir);
+    if (standing) {
+      throw new Error(
+        `review not opened — ${standing}\n` +
+          "(pass --allow-draft-defects to open the gate anyway)",
+      );
+    }
+  }
+
   // Headless simulation runs (scripts/codex-sim.mjs): approve without a browser.
   // buildDeck still ran above, so lint/build errors surface before the approve.
   if (process.env.SLIDEMIND_GATE_AUTOAPPROVE === "1") {
@@ -613,17 +630,19 @@ export async function runReview({
 function parseArgs(argv) {
   // port null ⇒ derive the deterministic per-deck port; an explicit --port
   // (incl. --port 0 for OS-random) overrides it.
-  const args = { deck: null, port: null };
+  const args = { deck: null, port: null, allowDraftDefects: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--deck" && i + 1 < argv.length) {
       args.deck = argv[++i];
     } else if (a === "--port" && i + 1 < argv.length) {
       args.port = parseInt(argv[++i], 10) || 0;
+    } else if (a === "--allow-draft-defects") {
+      args.allowDraftDefects = true;
     } else if (a === "-h" || a === "--help") {
       process.stdout.write(
-        "Usage: slidemind review <deck> [--port <n>]\n" +
-          "       node src/builders/review.mjs --deck <deck> [--port <n>]\n",
+        "Usage: slidemind review <deck> [--port <n>] [--allow-draft-defects]\n" +
+          "       node src/builders/review.mjs --deck <deck> [--port <n>] [--allow-draft-defects]\n",
       );
       process.exit(0);
     } else {
@@ -641,7 +660,7 @@ function parseArgs(argv) {
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const deckDir = path.resolve(args.deck);
-  await runReview({ deckDir, port: args.port });
+  await runReview({ deckDir, port: args.port, allowDraftDefects: args.allowDraftDefects });
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/src/builders/visual-families.mjs

@@ -18,7 +18,7 @@ export function plannedSlideNumbers(planMarkdown) {
   return [...slides].sort((a, b) => a - b);
 }
 
-export function conceptGenerationWaves(planMarkdown, slideCount) {
+export function conceptGenerationWaves(planMarkdown) {
   const groups = new Map();
   for (const segment of splitPlanMarkdownIntoSegments(planMarkdown)) {
     if (segment.type !== "storyboard" || !segment.data) continue;
@@ -35,14 +35,12 @@ export function conceptGenerationWaves(planMarkdown, slideCount) {
     for (const slide of members.slice(1)) variants.add(slide);
   }
 
-  // Slide 1 is the caller's probe request; everything else the plan names
-  // follows. A plan without parseable storyboards falls back to the count.
+  // Every slide the plan names, slide 1 included. The server derives its own
+  // beat list from the SAME storyboard-canvas blocks, so there is nothing a
+  // request to it could tell us about the deck's size that this does not.
   const planned = plannedSlideNumbers(planMarkdown);
-  const remaining = planned.length
-    ? planned.filter((slide) => slide !== 1)
-    : Array.from({ length: Math.max(0, slideCount - 1) }, (_, i) => i + 2);
   return {
-    firstWave: remaining.filter((slide) => !variants.has(slide)),
-    variants: remaining.filter((slide) => variants.has(slide)),
+    firstWave: planned.filter((slide) => !variants.has(slide)),
+    variants: planned.filter((slide) => variants.has(slide)),
   };
 }

package/src/cli/common.mjs

@@ -0,0 +1,179 @@
+// Shared plumbing for the slidemind CLI command modules (src/cli/*.mjs).
+// Split out of bin/slidemind.mjs verbatim; bin stays the dispatcher.
+
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
+export const SRC_DIR = path.join(PACKAGE_ROOT, "src");
+export const BUILDERS_DIR = path.join(SRC_DIR, "builders");
+export const INSTALLERS_DIR = path.join(SRC_DIR, "installers");
+// The CLI entry point, for commands that re-spawn the CLI (setup → ready).
+export const BIN_PATH = path.join(PACKAGE_ROOT, "bin", "slidemind.mjs");
+
+export function readPackageJson() {
+  return JSON.parse(
+    fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"),
+  );
+}
+
+export function fail(msg, code = 1) {
+  process.stderr.write(`slidemind: ${msg}\n`);
+  process.exit(code);
+}
+
+// The two human checkmarks the CLI enforces itself, so no harness timeout,
+// context loss, or agent rationalisation can walk past a gate: nothing after
+// the plan gate (concepts, build, view-draft, review) runs on an unapproved or
+// since-edited plan, and nothing ships (push, build-pptx) from a preview the
+// user has not approved exactly as it stands. Both fast-fail before any
+// bridge call with the command that clears them.
+export async function requirePlanApproved(deckDir) {
+  const plan = await import(pathToFileURL(path.join(BUILDERS_DIR, "plan.mjs")).href);
+  const why = plan.requirePlanApproved(deckDir);
+  if (why) fail(why);
+}
+
+export async function requireReviewApproved(deckDir) {
+  const review = await import(pathToFileURL(path.join(BUILDERS_DIR, "review.mjs")).href);
+  const why = review.requireReviewApproved(deckDir);
+  if (why) fail(why);
+}
+
+// A render that stalls on "Multiple PowerPoint windows are open" is, for an
+// UNBOUND deck, really a binding problem: bound, the deck renders pane-free
+// and never asks. Name that fix first — the window pick is the workaround.
+export function withUnboundHint(deckDir, err) {
+  const msg = err?.message ?? String(err);
+  if (!/Multiple PowerPoint windows are open/.test(msg)) return msg;
+  if (fs.existsSync(path.join(deckDir, ".bundle-ref.json"))) return msg;
+  const slug = path.basename(deckDir);
+  return (
+    `deck ${slug} is not bound to a corporate design, so the render has to go through an open window. ` +
+    `Bind it once and no window is needed: \`slidemind ready ${slug}\` (or \`--brand <presFP>\` to name the design). ` +
+    `Or pick a window for this run:\n${msg.replace(/^[^\n]*\n/, "")}`
+  );
+}
+
+// The local PowerPoint files `read` and `add-slide --from` accept host-free.
+// All are OPC (zip) OOXML packages with the same ppt/presentation.xml +
+// ppt/slides/ structure — presentation (.pptx/.pptm), template (.potx/.potm),
+// slideshow (.ppsx/.ppsm) — so the src/pptx/ reader/swapper handle them
+// identically. Presentation IDs are opaque and never carry these extensions,
+// so this stays a safe discriminator for "positional is a local file, not a
+// presId".
+export const LOCAL_PPTX_RE = /\.(pptx|pptm|potx|potm|ppsx|ppsm)$/i;
+
+export function resolveDecksDir() {
+  if (process.env.SLIDEMIND_DECKS) {
+    return path.resolve(process.env.SLIDEMIND_DECKS);
+  }
+  return path.resolve(process.cwd(), "decks");
+}
+
+export function resolveDeckArg(arg) {
+  // A user can pass either "decks/foo" (relative to CWD), "/abs/path/foo",
+  // or just "foo" — in which case we look it up under the resolved decks dir.
+  if (!arg) return null;
+  if (path.isAbsolute(arg)) return arg;
+  if (fs.existsSync(path.resolve(process.cwd(), arg))) {
+    return path.resolve(process.cwd(), arg);
+  }
+  const decksDir = resolveDecksDir();
+  return path.join(decksDir, arg);
+}
+
+export function runNode(script, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [script, ...args], {
+      stdio: "inherit",
+      env: process.env,
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${path.basename(script)} exited with code ${code}`));
+    });
+  });
+}
+
+export function splitDeckArg(rest, cmd) {
+  // The first non-flag positional is the deck. Everything else passes
+  // through to the underlying script verbatim.
+  const passthrough = [...rest];
+  let deck = null;
+  for (let i = 0; i < passthrough.length; i++) {
+    if (!passthrough[i].startsWith("-")) {
+      deck = passthrough.splice(i, 1)[0];
+      break;
+    }
+  }
+  if (!deck) fail(`usage: slidemind ${cmd} <deck>`);
+  return { deck, passthrough };
+}
+
+// Live render progress for build-pptx/push (the job protocol streams it; the
+// sync fallback emits nothing). One stderr line per state change — works in
+// plain logs and TTYs alike.
+export function renderProgressPrinter() {
+  let last = "";
+  let queuedAt = null;
+  return (p) => {
+    let line = null;
+    if (p.state === "queued") {
+      queuedAt ??= Date.now();
+      if (Date.now() - queuedAt > 5000) {
+        line = "  render queued behind another render…";
+      }
+    } else if (p.state === "restarted") {
+      line = "  render restarted (backend replica was replaced)…";
+    } else if (p.stage === "assembling") {
+      line = "  assembling deck…";
+    } else if (p.stage === "rendering" && typeof p.total === "number") {
+      line = `  rendering slide ${Math.min((p.done ?? 0) + 1, p.total)}/${p.total}…`;
+    }
+    if (line && line !== last) {
+      last = line;
+      process.stderr.write(`${line}\n`);
+    }
+  };
+}
+
+export function dataUriToPng(dataUri) {
+  const m = /^data:image\/png;base64,(.+)$/.exec(dataUri || "");
+  return m ? Buffer.from(m[1], "base64") : null;
+}
+
+// Keep the deck working against the design as it stands RIGHT NOW: every deck
+// command re-syncs its bound design before it works, so a corporate design that
+// changed mid-session is picked up instead of silently building against the
+// copy `ready` fetched hours ago. The mechanics (etag gate, short timeout,
+// never-throw) live in bundle.mjs; this only reports a design that moved.
+export async function freshenDeckBundle(deckDir) {
+  const bundle = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
+  );
+  const sync = await bundle.refreshDeckBundle(deckDir);
+  if (sync?.changed) {
+    process.stdout.write(
+      `  design bundle updated (${sync.result.downloaded} file(s) changed) — building against the current corporate design\n`,
+    );
+  }
+  return sync;
+}
+
+// Strip the `data:<mime>;base64,` prefix off a data URI and return the raw
+// base64 payload (or null when the URI isn't a base64 data URI we can decode).
+export function base64FromDataUri(dataUri) {
+  if (typeof dataUri !== "string") return null;
+  const m = /^data:[^;,]*;base64,(.*)$/s.exec(dataUri.trim());
+  return m ? m[1] : null;
+}
+
+export async function loadBridgeModule(name) {
+  return import(pathToFileURL(path.join(SRC_DIR, "bridge", `${name}.mjs`)).href);
+}

package/src/cli/concepts.mjs

@@ -0,0 +1,310 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { fail, requirePlanApproved, resolveDeckArg, freshenDeckBundle, base64FromDataUri, SRC_DIR, BUILDERS_DIR } from "./common.mjs";
+
+export const REFERENCE_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+};
+
+// `--concept <image>[@N,M]` / `--style <image>[@N,M]` → one inline reference
+// `{ role, image, slides?, name }` for the concept-images route.
+export function readReferenceArg(role, spec) {
+  if (!spec) fail(`--${role} expects <image>[@slides]`);
+  const at = spec.lastIndexOf("@");
+  const file = at > 0 ? spec.slice(0, at) : spec;
+  const slides =
+    at > 0
+      ? spec
+          .slice(at + 1)
+          .split(",")
+          .map((n) => Number(n.trim()))
+          .filter((n) => Number.isInteger(n) && n > 0)
+      : [];
+  if (at > 0 && slides.length === 0) {
+    fail(`--${role} ${spec}: expected slide numbers after '@', e.g. sketch.png@2,3`);
+  }
+  const mime = REFERENCE_MIME[path.extname(file).toLowerCase()];
+  if (!mime) fail(`--${role} ${file}: expected a png/jpg/webp/gif image`);
+  let bytes;
+  try {
+    bytes = fs.readFileSync(file);
+  } catch {
+    fail(`--${role} ${file}: file not found`);
+  }
+  return {
+    role,
+    image: `data:${mime};base64,${bytes.toString("base64")}`,
+    ...(slides.length > 0 ? { slides } : {}),
+    name: path.basename(file),
+  };
+}
+
+export async function cmdConceptImages(rest) {
+  let deck = null;
+  let force = false;
+  let asJson = false;
+  const references = [];
+  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 name or path");
+    } else if (a === "--force") {
+      force = true;
+    } else if (a === "--json") {
+      asJson = true;
+    } else if (a === "--concept" || a === "--style") {
+      references.push(readReferenceArg(a.slice(2), rest[++i]));
+      // A new user reference changes what the mockups should be.
+      force = true;
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else if (deck === null) {
+      deck = a;
+    } else {
+      fail(`unexpected argument: ${a}`);
+    }
+  }
+  if (!deck) fail("usage: slidemind concepts <deck>");
+
+  const deckDir = resolveDeckArg(deck);
+  const planPath = path.join(deckDir, "plan.md");
+  if (!fs.existsSync(planPath)) {
+    fail(
+      `no plan.md in ${path.relative(process.cwd(), deckDir) || deckDir}. ` +
+        `Run \`slidemind plan ${deck}\` to compose and sign off a plan first.`,
+    );
+  }
+  const planMarkdown = fs.readFileSync(planPath, "utf8");
+  // Every exit ends on ONE machine-readable line — `CONCEPTS: n/m …` — so a
+  // harness that cut the output short, and an agent reading a summary, can
+  // tell "generated", "none available" and "still running" apart without a
+  // double-evidence ritual. --json prints the same facts as a payload.
+  const finish = ({ paths = [], planned = 0, status, reason = null, missing = [], seeded = false, extra = "" }) => {
+    const conceptsDir = path.join(deckDir, "concepts");
+    if (asJson) {
+      process.stdout.write(
+        `${JSON.stringify({ deck: path.basename(deckDir), status, generated: paths.length, planned, paths, missing, reason, conceptsDir, assetPlan: path.join(deckDir, "asset-plan.md"), seededAssetPlan: seeded }, null, 2)}\n`,
+      );
+    } else {
+      if (paths.length) process.stdout.write(paths.join("\n") + "\n");
+      process.stdout.write(
+        `CONCEPTS: ${paths.length}/${planned} ${status}${reason ? ` — ${reason}` : ""}` +
+          (missing.length ? ` (no mockup for slide${missing.length > 1 ? "s" : ""} ${missing.join(", ")} — author from the storyboard)` : "") +
+          (paths.length ? ` — Read each PNG, then rebuild as slide JSX (workflow/create.md).` : "") +
+          `\n${extra}`,
+      );
+    }
+    process.exit(0);
+  };
+  // Mockups are the first post-plan step, so this is where an unapproved or
+  // since-edited plan stops the agent — before any authoring, and before the
+  // fast path below re-prints mockups that would belong to a stale plan.
+  await requirePlanApproved(deckDir);
+  await freshenDeckBundle(deckDir);
+
+  // The slides the plan's storyboards name — the set every step below works
+  // against (fast-path completeness, request waves, pruning, the missing
+  // note). The server's slideCount is a progress figure only: it counts the
+  // beats IT parsed, and a beat it drops must not shrink the request range.
+  const families = await import(
+    pathToFileURL(path.join(BUILDERS_DIR, "visual-families.mjs")).href
+  );
+  const planned = new Set(families.plannedSlideNumbers(planMarkdown));
+
+  // Idempotent fast path: mockups already on disk are re-printed IMMEDIATELY.
+  // Generation takes 1-2 minutes and agent harnesses time commands out and
+  // show the model only the output-so-far — while the detached process still
+  // finishes writing the PNGs. The model's mandated retry then lands here and
+  // gets the full path list within any timeout, instead of racing generation
+  // again (measured: sessions that never saw the paths authored without the
+  // concepts — the single biggest fidelity loss). `--force` regenerates.
+  if (!force) {
+    const conceptsDirEarly = path.join(deckDir, "concepts");
+    let existing = [];
+    try {
+      existing = fs
+        .readdirSync(conceptsDirEarly)
+        .filter((f) => /^concept-slide-\d+\.png$/.test(f))
+        .sort();
+    } catch {}
+    // Only when the on-disk set EXACTLY matches the plan's slide numbering —
+    // a partial or stale set (leftover concept-slide-03.png on a 2-slide
+    // plan) falls through to regeneration, which prunes and refills.
+    const existingNums = new Set(
+      existing.map((f) => Number(f.match(/(\d+)/)[1])),
+    );
+    const matchesPlan =
+      planned.size > 0 &&
+      planned.size === existingNums.size &&
+      [...planned].every((n) => existingNums.has(n));
+    if (existing.length > 0 && matchesPlan) {
+      finish({
+        paths: existing.map((f) => path.join(conceptsDirEarly, f)),
+        planned: planned.size,
+        status: "on disk",
+        reason: "already generated for this plan (--force regenerates)",
+      });
+    }
+  }
+
+  // No storyboards, nothing to generate: the server builds its beats from the
+  // same blocks, so a request would come back with zero images anyway.
+  if (planned.size === 0) {
+    finish({ status: "none", reason: "plan.md has no storyboard-canvas blocks (re-run `slidemind plan` to compose the storyboards)" });
+  }
+
+  const bundle = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
+  );
+  const brandId = bundle.readDeckBundleRef(deckDir)?.presFP ?? null;
+  if (!brandId) {
+    fail(
+      `deck ${deck} is not bound to a corporate design (no .bundle-ref.json). ` +
+        `Run \`slidemind ready ${deck}\` to bind it first.`,
+    );
+  }
+
+  const client = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+  );
+
+  const skipNote = () =>
+    finish({ planned: planned.size, status: "unavailable", reason: "this add-in does not generate concept mockups; author from the storyboards" });
+
+  // Generation is silent for 1–2 min otherwise, and a harness that yields a
+  // long-running command early then hands the agent an empty output it reads
+  // as "no mockups". Say up front what is happening and what to wait for.
+  process.stderr.write(
+    `slidemind: generating concept mockups for ${deck} — this takes 1–2 minutes. ` +
+      `Wait for the concept-slide-NN.png paths below; an empty output so far means still running, ` +
+      `not "no mockups". Do not re-run this command while it is still running.\n`,
+  );
+
+  // Pin the serving backend up front. This is a cached capabilities probe, not
+  // a generation — the deck's slide set comes from the plan's own storyboard
+  // canvases, which is the SAME source the server parses its beats from, so
+  // there is nothing left for a throwaway single-slide request to learn.
+  let backendURL;
+  try {
+    backendURL = await client.resolveConceptBackend();
+  } catch (err) {
+    if (err?.code === "concept_route_unavailable") skipNote();
+    throw err;
+  }
+
+  const slideCount = planned.size;
+  const images = [];
+  const collect = (res) => {
+    if (!Array.isArray(res?.images)) return;
+    for (const img of res.images) {
+      images.push(img);
+      process.stderr.write(
+        `slidemind: concept mockup ${images.length}/${slideCount} ready (slide ${img?.slideNumber})\n`,
+      );
+    }
+  };
+
+  // Family variants depend on their lowest-numbered anchor. Run independent
+  // slides + anchors first, then variants; the server's per-family anchor cache
+  // (keyed by brand + CLI user) is what makes the anchor cross the two waves'
+  // separate requests.
+  const waves = families.conceptGenerationWaves(planMarkdown);
+  const CONCURRENCY = 3;
+  async function runWave(slides) {
+    let cursor = 0;
+    async function worker() {
+      for (;;) {
+        const idx = cursor++;
+        if (idx >= slides.length) return;
+        const n = slides[idx];
+        try {
+          const res = await client.generateConceptImagesForBrand(brandId, {
+            planMarkdown,
+            slideNumbers: [n],
+            references,
+            backendURL,
+            force,
+          });
+          collect(res);
+        } catch (err) {
+          process.stderr.write(
+            `slidemind: concept mockup for slide ${n} failed: ${err?.message ?? err}\n`,
+          );
+        }
+      }
+    }
+    await Promise.all(
+      Array.from({ length: Math.min(CONCURRENCY, slides.length) }, () => worker()),
+    );
+  }
+  await runWave(waves.firstWave);
+  await runWave(waves.variants);
+
+  if (images.length === 0) {
+    finish({ planned: planned.size, status: "generated", reason: "the add-in returned no image for any slide (see the per-slide failures above); author from the storyboards" });
+  }
+
+  const conceptsDir = path.join(deckDir, "concepts");
+  fs.mkdirSync(conceptsDir, { recursive: true });
+  const written = [];
+  const writtenNums = new Set();
+  for (const img of images) {
+    const n = Number(img?.slideNumber);
+    if (!Number.isFinite(n) || n < 1) continue;
+    const b64 = base64FromDataUri(img?.dataUri);
+    if (!b64) continue;
+    const name = `concept-slide-${String(n).padStart(2, "0")}.png`;
+    const abs = path.join(conceptsDir, name);
+    fs.writeFileSync(abs, Buffer.from(b64, "base64"));
+    written.push(abs);
+    writtenNums.add(n);
+  }
+
+  // Drop stale mockups from a previous, longer plan — any concept-slide-NN.png
+  // the plan no longer names (fallback: beyond the server's slideCount).
+  const isStale = (n) =>
+    planned.size > 0 ? !planned.has(n) : n > slideCount;
+  for (const entry of fs.readdirSync(conceptsDir)) {
+    const m = /^concept-slide-(\d+)\.png$/.exec(entry);
+    if (m && isStale(Number(m[1]))) {
+      fs.rmSync(path.join(conceptsDir, entry), { force: true });
+    }
+  }
+  // A planned slide the server returned nothing for is invisible otherwise —
+  // the agent would author it blind without knowing a mockup was expected.
+  const missing = [...planned].filter((n) => !writtenNums.has(n));
+
+  if (written.length === 0) {
+    finish({ planned: planned.size, status: "generated", reason: "the add-in returned images without usable bytes; author from the storyboards", missing });
+  }
+
+  written.sort();
+  // The inventory form is seeded next to the mockups (never over a filled
+  // one): the organism/connector list becomes a file the draft check counts,
+  // not a step the agent may skip.
+  const check = await import(
+    pathToFileURL(path.join(BUILDERS_DIR, "draft-check.mjs")).href
+  );
+  const seeded = check.seedAssetPlan(
+    deckDir,
+    images
+      .filter((img) => writtenNums.has(Number(img?.slideNumber)))
+      .map((img) => ({ slideNumber: Number(img.slideNumber), label: img.label })),
+  );
+  finish({
+    paths: written,
+    planned: planned.size,
+    status: "generated",
+    missing,
+    seeded,
+    extra: seeded
+      ? `Seeded ${path.join(deckDir, check.ASSET_PLAN_FILE)} — fill its regions/organisms/connectors/icons rows per slide from the mockups BEFORE writing any slide.\n`
+      : "",
+  });
+}