slidemind 0.3.4 → 0.3.12

package/src/builders/plan.mjs

@@ -18,17 +18,12 @@
 //   - comments  -> the user's slide-anchored comments (the agent revises
 //                  plan.md to address them and re-runs).
 //
-// ASYNC REVIEW (the drain loop). A comments round no longer freezes the tab:
-// once the decision is sent the page enters WORKING mode — still readable and
-// navigable, composer still live — and further comments queue in the tab's
-// sessionStorage. When the agent re-runs this command the waiting tab reloads
-// (heartbeat claim) and its boot script POSTs that backlog to
-// /plan-review/backlog. A non-empty backlog resolves the gate AT ONCE with
-// those comments (a "drain round": the command prints DECISION: comments and
-// exits without ever parking), so several consecutive comment rounds are the
-// normal shape of a review. An empty backlog never POSTs and the run parks and
-// blocks, exactly as before. Approve is refused once a backlog arrived in this
-// run — that round is already superseded.
+// ROUNDS ARE SYNCHRONOUS (add-in parity). Send resolves the gate with the
+// comment and the command exits with DECISION: comments; the tab then sits in
+// WORKING mode — readable and navigable, composer and Approve off — until the
+// agent's next `slidemind plan` run reloads it with the revised plan. Nothing is
+// queued behind the agent's back; several consecutive comment rounds are the
+// normal shape of a review.
 //
 // Host-free: the plan gate runs BEFORE any slide exists, so it needs no bundle
 // and no open host. A per-brand orb PNG is used when a bundle happens to be
@@ -57,6 +52,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { openInBrowser } from "./build.mjs";
+import { loadReviewState } from "./review.mjs";
 import { renderPlanMarkdown } from "./plan-md.mjs";
 import { splitPlanFrontmatter } from "./resolve-skill.mjs";
 import {
@@ -67,7 +63,6 @@ import {
   createHeartbeat,
   bundleGateSession,
   normalizeGateComments,
-  serveBacklogPost,
   serveDecisionPost,
   stripModuleSyntax,
   listenWithFallback,
@@ -79,7 +74,7 @@ import {
   POLL_MS,
   POLL_TTL_MS,
 } from "./gate-server.mjs";
-import { resolveBrandAsset } from "../bridge/bundle.mjs";
+import { resolveBrandAsset, resolveBundleDirForDeck } from "../bridge/bundle.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -94,7 +89,12 @@ const STORYBOARD_MARKDOWN_PATH = path.join(__dirname, "storyboard-markdown.mjs")
 const RED_THREAD_BACKBONE_PATH = path.join(__dirname, "red-thread-backbone.mjs");
 const PLAN_MARKDOWN_EDIT_PATH = path.join(__dirname, "plan-markdown-edit.mjs");
 const PLAN_STATE_FILE = "plan-review.json";
-const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+// No decision timeout: the gate returns only on the user's decision (or when
+// no browser could be opened at all — see openFailedGraceMs). An agent cannot
+// proceed past a plan a human has not approved, so the process waits as long as
+// the human does; a harness that backgrounds the call gets the decision when it
+// lands. Pass timeoutMs explicitly to cap the wait (tests).
+const DEFAULT_TIMEOUT_MS = null;
 
 // Escape a </script> sequence so an inlined JSON/JS blob can't break out of the
 // surrounding <script> tag (copied from review.mjs — that module is off-limits
@@ -158,6 +158,39 @@ export function savePlanState(deckDir, state) {
   );
 }
 
+// The human checkmark every post-plan command (concepts, build, view-draft,
+// review) requires — enforced by the CLI, not by the skill's prose. A deck
+// without plan.md is the in-chat single-slide path and passes. Otherwise
+// null = approved and unchanged since (planHash is the one persisted with the
+// decision); else the agent-facing reason plus the command that clears it.
+//
+// The gate binds only until the deck has passed a review: from then on the plan
+// has been executed and plan.md is a record, not a contract — the add-in's
+// manager likewise hands an edit delegation `approvedPlan: null` and never
+// re-gates the old plan. Edits to existing slides are the review gate's job
+// (it re-arms on every slide change); the plan rule for slides added to a
+// reviewed deck stays the skill's, as it is in-app.
+export function requirePlanApproved(deckDir) {
+  const planPath = path.join(deckDir, "plan.md");
+  if (!fs.existsSync(planPath)) return null;
+  if (loadReviewState(deckDir).decision === "approve") return null;
+  const base = path.basename(deckDir);
+  const state = loadPlanState(deckDir);
+  if (state.decision !== "approve") {
+    return (
+      `${base}'s plan is not signed off — a human must approve it first: ` +
+      `run \`slidemind plan ${base}\` and wait for DECISION: approved.`
+    );
+  }
+  if (state.planHash !== hashPlan(planPath)) {
+    return (
+      `${base}/plan.md changed since the user approved it — ` +
+      `re-run \`slidemind plan ${base}\` for a fresh sign-off.`
+    );
+  }
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // harness output
 // ---------------------------------------------------------------------------
@@ -177,26 +210,15 @@ function commentBullet(c) {
 // Render the comments round for the harness — the plan analog of review.mjs's
 // formatCommentsForHarness, on slide-anchored comments instead of spatial pins.
 //
-// The tail is deliberately imperative: the reviewer's tab is LIVE while the
-// agent revises (they can keep reading and keep queueing comments), and those
-// queued comments are only delivered by the next `slidemind plan` run. An agent
-// that ends its turn here strands them, so the re-run instruction says "same
-// turn" and says why more comments may follow.
-export function formatPlanCommentsForHarness(
-  deckDir,
-  comments,
-  { edited = false, drained = false } = {},
-) {
+// The tail is deliberately imperative: the reviewer's tab is waiting on the
+// next `slidemind plan` run — nothing reaches them until it runs. An agent that
+// ends its turn here strands them, so the re-run instruction says "same turn"
+// and says why more comment rounds may follow.
+export function formatPlanCommentsForHarness(deckDir, comments, { edited = false } = {}) {
   const rows = normalizePlanComments(comments);
   const out = [];
   out.push("DECISION: comments");
   out.push("The user requested changes to the plan. Nothing was authored.");
-  if (drained) {
-    out.push(
-      "(These comments were queued while you were revising and arrived with this " +
-        "run — that is why the gate returned immediately instead of waiting.)",
-    );
-  }
   if (edited) {
     out.push(
       "The user also edited plan.md directly — re-read it before revising; the " +
@@ -213,9 +235,8 @@ export function formatPlanCommentsForHarness(
   out.push("Revise plan.md to address ALL comments — change only what the feedback");
   out.push("requires; keep unaffected slides verbatim.");
   out.push(`Then run \`slidemind plan ${path.basename(deckDir)}\` again in the same turn.`);
-  out.push("The reviewer may queue further comments while you revise; they are");
-  out.push("delivered on that next run (it can return immediately with them — that is");
-  out.push("normal, not an error). Do NOT end your turn and do NOT send the user back");
+  out.push("The reviewer then reviews the revised plan — several comment rounds are");
+  out.push("normal, not an error. Do NOT end your turn and do NOT send the user back");
   out.push("to the browser before you re-run the gate.");
   out.push("");
   // Recovery pointer in the tail (truncated captures usually lose the TOP):
@@ -232,11 +253,13 @@ export function formatPlanCommentsForHarness(
 // state (the user stepped away), not a failure — the agent must neither treat
 // it as approval nor abort the task; it wraps up with clear resume instructions.
 export function formatPlanPendingForHarness(deckDir, { timeoutMs, pageLoaded, url } = {}) {
-  const mins = Math.max(1, Math.round((timeoutMs ?? DEFAULT_TIMEOUT_MS) / 60000));
   const base = path.basename(deckDir);
+  const waited = timeoutMs
+    ? `the gate waited ${Math.max(1, Math.round(timeoutMs / 60000))} minutes and the user hasn't answered.`
+    : "the gate closed without an answer from the user.";
   return [
     "DECISION: pending",
-    `No decision yet — the gate waited ${mins} minutes and the user hasn't answered.`,
+    `No decision yet — ${waited}`,
     ...pendingBrowserLines({ pageLoaded, url }),
     "This is NOT an approval and NOT a rejection. Do not author anything.",
     "Close out your turn gracefully:",
@@ -262,6 +285,7 @@ const PLAN_NAMESPACE_EXPORTS = [
   "replaceRenderedMarkdownBlock",
   "splitPlanMarkdownIntoSegments",
   "replaceStoryboardSegment",
+  "setStoryboardLayoutForAll",
   "extractRedThreadMessages",
   "findRedThreadSection",
   "parseStoryboardCanvas",
@@ -278,6 +302,7 @@ const PLAN_NAMESPACE_EXPORTS = [
   "MAX_BLOCKS",
   "MAX_DESIGN_ELEMENT_LENGTH",
   "MAX_CONTENT_LENGTH",
+  "MAX_IMAGE_PROMPT_LENGTH",
 ];
 
 // stripModuleSyntax now lives in gate-server.mjs (both gates bundle browser
@@ -358,6 +383,215 @@ display:block;overflow-x:auto;}
 #plan-root a{color:#a9c2ff;}
 `;
 
+// ---------------------------------------------------------------------------
+// layout picker data
+// ---------------------------------------------------------------------------
+
+const CHROME_ASSET_RE = /^chrome-[\w-]+\.(png|webp|jpe?g)$/i;
+
+// Readable chip per OOXML placeholder type; null = meta chrome drawn as an
+// unlabeled faint outline (footer/date/page number chips would only add noise).
+const PH_OUTLINE_LABELS = {
+  title: "Title",
+  ctrTitle: "Title",
+  subTitle: "Subtitle",
+  body: "Body",
+  obj: "Body",
+  pic: "Image",
+  media: "Image",
+  chart: "Chart",
+  tbl: "Table",
+  dt: null,
+  ftr: null,
+  sldNum: null,
+};
+
+// Chrome placeholder outlines for one layout, host-free: prop names + types
+// from the JSX's `// PLACEHOLDERS:` metadata line, geometry from the generated
+// layouts.css positional rules (`.layout-<slug> .slide__<prop> { left: Npx; … }`
+// on the canonical 1280×720 stage). Best-effort: any parse miss just drops that
+// outline.
+export function parsePlaceholderOutlines(source, layoutsCss) {
+  if (!layoutsCss) return [];
+  const slugMatch = /className="slide(?:\s+slide--dark)?\s+(layout-[a-z0-9-]+)"/.exec(source);
+  const metaMatch = /^\s*\/\/ PLACEHOLDERS: (\{.*\})\s*$/m.exec(source);
+  if (!slugMatch || !metaMatch) return [];
+  let chrome;
+  try {
+    chrome = JSON.parse(metaMatch[1]).chrome;
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(chrome)) return [];
+  const outlines = [];
+  for (const entry of chrome) {
+    if (!entry || typeof entry.prop !== "string") continue;
+    const kebab = entry.prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+    const rule = new RegExp(
+      "\\." + slugMatch[1] + "\\s+\\.slide__" + kebab + "\\s*\\{([^}]*)\\}",
+    ).exec(layoutsCss);
+    if (!rule) continue;
+    const px = (name) => {
+      const m = new RegExp(name + ":\\s*(-?\\d+(?:\\.\\d+)?)px").exec(rule[1]);
+      return m ? Number(m[1]) : null;
+    };
+    const left = px("left");
+    const top = px("top");
+    const width = px("width");
+    const height = px("height");
+    if (left == null || top == null || !width || !height) continue;
+    const b = { x: left / 1280, y: top / 720, w: width / 1280, h: height / 720 };
+    const sane = (v) => Number.isFinite(v) && v >= -0.05 && v <= 1.05;
+    if (!(sane(b.x) && sane(b.y) && sane(b.w) && sane(b.h))) continue;
+    outlines.push({
+      label:
+        typeof entry.type === "string" && entry.type in PH_OUTLINE_LABELS
+          ? PH_OUTLINE_LABELS[entry.type]
+          : null,
+      // Image slots carry their codegen prop name (`image`, `image2`, …) so the
+      // storyboard can author a per-slot `imagePrompts` entry under that key.
+      ...(entry.type === "pic" || entry.type === "media" ? { key: entry.prop } : {}),
+      x: b.x,
+      y: b.y,
+      w: b.w,
+      h: b.h,
+    });
+  }
+  return outlines;
+}
+
+// The per-slide layout picker's option list, resolved host-free from the
+// deck's materialized bundle: componentName from `layouts/<Name>.jsx`, the
+// canvas line from the codegen's `// [CONTENT: …]` annotation (present only on
+// workhorse layouts), the purpose from design.md's Layout Catalog, and the
+// chrome-render thumbnail from `assets/chrome-<Name>.*` served at
+// `/brand/chrome/<file>`. No bundle → `{ layouts: [], chromeDir: null }` and
+// the picker degrades to read-only (the host-free contract holds).
+export function resolvePlanLayouts(deckDir) {
+  const dir = resolveBundleDirForDeck(deckDir);
+  if (!dir) return { layouts: [], chromeDir: null };
+  const layoutsDir = path.join(dir, "layouts");
+  const assetsDir = path.join(dir, "assets");
+  let files;
+  try {
+    files = fs.readdirSync(layoutsDir).filter((f) => f.endsWith(".jsx"));
+  } catch {
+    return { layouts: [], chromeDir: null };
+  }
+
+  // design.md Layout Catalog → `### <Name>` + `- Purpose: …` + `- Content
+  // areas: 1. …; 2. …` (or `none (chrome-only)`). Line scan; catalog entries
+  // are the only place these bullets follow a ### heading in the generated
+  // design.md.
+  const purposes = new Map();
+  const canvases = new Map();
+  try {
+    const md = fs.readFileSync(path.join(dir, "design.md"), "utf8");
+    let current = null;
+    for (const line of md.split(/\r?\n/)) {
+      const heading = /^###\s+(\S+)\s*$/.exec(line);
+      if (heading) {
+        current = heading[1];
+        continue;
+      }
+      if (!current) continue;
+      const purpose = /^- Purpose:\s*(.+)$/.exec(line);
+      if (purpose) purposes.set(current, purpose[1].trim());
+      // Newer add-ins write `- Content areas:`; the deployed one still writes
+      // `- Canvas:` — a bundle from either must feed the picker.
+      const canvas = /^- (?:Content areas|Canvas):\s*(.+)$/.exec(line);
+      if (canvas) canvases.set(current, canvas[1].trim());
+    }
+  } catch {
+    /* no design.md — names + annotations still make a usable picker */
+  }
+
+  let chromeFiles = [];
+  try {
+    chromeFiles = fs.readdirSync(assetsDir).filter((f) => CHROME_ASSET_RE.test(f));
+  } catch {
+    /* no assets dir */
+  }
+  let layoutsCss = "";
+  try {
+    layoutsCss = fs.readFileSync(path.join(layoutsDir, "layouts.css"), "utf8");
+  } catch {
+    /* no positional CSS — placeholder outlines just stay empty */
+  }
+  const chromeByComponent = new Map();
+  for (const file of chromeFiles) {
+    chromeByComponent.set(file.replace(/^chrome-/, "").replace(/\.[^.]+$/, ""), file);
+  }
+
+  const layouts = [];
+  for (const file of files) {
+    const componentName = file.replace(/\.jsx$/, "");
+    let source = "";
+    try {
+      source = fs.readFileSync(path.join(layoutsDir, file), "utf8");
+    } catch {
+      continue;
+    }
+    // The `[CONTENT: …]` annotation is emitted only above a `children` prop —
+    // its presence IS the workhorse test, its text the canvas line, and its
+    // numbers (px on the canonical 1280×720 stage) normalize into the
+    // content-zone rectangles the storyboard frame draws. The head is the
+    // union bbox; a multi-area layout appends `Allowed regions
+    // (content-relative): 1: W×H px @ (x, y); …` — the gaps between those
+    // regions are not writable, so each becomes its own rectangle.
+    const content = /\[CONTENT:\s*([^\]]+)\]/.exec(source);
+    const annotated = content ? content[1].trim() : null;
+    const canvas = canvases.get(componentName) ?? annotated;
+    let canvasBounds = null;
+    let contentAreas = [];
+    const nums = content
+      ? /^(\d+(?:\.\d+)?)\s*[×x]\s*(\d+(?:\.\d+)?)\s*px\s*@\s*\((\d+(?:\.\d+)?),\s*(\d+(?:\.\d+)?)\)/.exec(
+          annotated,
+        )
+      : null;
+    if (nums) {
+      const b = {
+        x: Number(nums[3]) / 1280,
+        y: Number(nums[4]) / 720,
+        w: Number(nums[1]) / 1280,
+        h: Number(nums[2]) / 720,
+      };
+      const sane = (v) => Number.isFinite(v) && v >= 0 && v <= 1.05;
+      const clamp = (r) =>
+        sane(r.x) && sane(r.y) && sane(r.w) && sane(r.h)
+          ? { x: Math.min(r.x, 1), y: Math.min(r.y, 1), w: Math.min(r.w, 1), h: Math.min(r.h, 1) }
+          : null;
+      canvasBounds = clamp(b);
+      const regions = /Allowed regions \(content-relative\):\s*([^.]+)\./.exec(annotated);
+      if (canvasBounds && regions) {
+        const re = /(\d+(?:\.\d+)?)\s*[×x]\s*(\d+(?:\.\d+)?)\s*px\s*@\s*\((-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)\)/g;
+        for (const m of regions[1].matchAll(re)) {
+          const area = clamp({
+            x: (Number(nums[3]) + Number(m[3])) / 1280,
+            y: (Number(nums[4]) + Number(m[4])) / 720,
+            w: Number(m[1]) / 1280,
+            h: Number(m[2]) / 720,
+          });
+          if (area) contentAreas.push(area);
+        }
+      }
+      if (canvasBounds && contentAreas.length === 0) contentAreas = [canvasBounds];
+    }
+    const chrome = chromeByComponent.get(componentName);
+    layouts.push({
+      componentName,
+      purpose: purposes.get(componentName) ?? null,
+      mode: content ? "workhorse" : "purpose-built",
+      canvas,
+      canvasBounds,
+      contentAreas,
+      placeholders: parsePlaceholderOutlines(source, layoutsCss),
+      previewUrl: chrome ? `/brand/chrome/${chrome}` : null,
+    });
+  }
+  return { layouts, chromeDir: chromeFiles.length ? assetsDir : null };
+}
+
 // Build the standalone plan-review page: the rendered markdown in #plan-root
 // (the no-JS fallback and the preview's initial state), the injected overlay
 // config, the bundled plan-review modules, then the overlay script itself.
@@ -375,15 +609,17 @@ export function buildPlanPage({
   round,
   deck,
   ledgerSeed,
+  layouts,
 }) {
   const cfg = safeInlineJson({
     endpoint: "/plan-review",
-    backlogEndpoint: "/plan-review/backlog",
     heartbeat: "/__plan/heartbeat",
     round: round ?? null,
     pollMs: POLL_MS,
     pollTtlMs: POLL_TTL_MS,
     logoMark: logoMark ?? null,
+    // Brand layouts for the per-slide layout picker (empty → picker read-only).
+    layouts: Array.isArray(layouts) ? layouts : [],
     planBody: planBody ?? "",
     bodyStartLine: bodyStartLine ?? 1,
     // deck: the sessionStorage namespace for this deck's comment ledger.
@@ -439,6 +675,8 @@ export async function createPlanReviewServer({
   logoMark = null,
   brandAssetPath = null,
   ledgerSeed = [],
+  layouts = [],
+  chromeDir = null,
   port = 0,
 }) {
   const gate = createDecisionGate({
@@ -460,6 +698,7 @@ export async function createPlanReviewServer({
     round: hb.round,
     deck: path.basename(path.resolve(deckDir)),
     ledgerSeed: normalizePlanComments(ledgerSeed),
+    layouts,
   });
   const deckRoot = path.resolve(deckDir);
 
@@ -467,23 +706,11 @@ export async function createPlanReviewServer({
     const u = new URL(req.url, "http://127.0.0.1");
     const pathname = decodeURIComponent(u.pathname);
 
-    // Both POST routes are gate-server's shared handlers: the backlog drain and
-    // the decision + 409 guard behave identically in both gates. `gate.settled()`
-    // guards BOTH: once one tab's drain or decision resolved this run, a late
-    // POST from another waiting tab is refused instead of being acked and
-    // silently dropped (every waiter reloads into a new round, so two tabs
-    // posting into one run is the normal multi-window case, not an anomaly).
-    if (req.method === "POST" && pathname === "/plan-review/backlog") {
-      serveBacklogPost(req, res, {
-        normalize: normalizePlanComments,
-        isSuperseded: () => gate.settled(),
-        onDrained: (comments) => {
-          gate.resolve({ decision: "comments", comments, editedPlan: null, drained: true });
-        },
-      });
-      return;
-    }
-
+    // The decision POST is gate-server's shared handler: the 409 guard behaves
+    // identically in both gates. `gate.settled()` refuses a late POST from
+    // another waiting tab instead of acking and silently dropping it (every
+    // waiter reloads into a new round, so two tabs posting into one run is the
+    // normal multi-window case, not an anomaly).
     if (req.method === "POST" && pathname === "/plan-review") {
       serveDecisionPost(req, res, {
         normalize: normalizePlanComments,
@@ -493,7 +720,6 @@ export async function createPlanReviewServer({
             decision,
             comments,
             editedPlan: typeof payload.editedPlan === "string" ? payload.editedPlan : null,
-            drained: false,
           });
         },
       });
@@ -521,7 +747,10 @@ export async function createPlanReviewServer({
       // actually opened in front of the user (see gate-server's page-load
       // tracker; serveAndOpen and the pending contract report from it).
       hb.notePageLoad();
-      res.writeHead(200, { "Content-Type": MIME[".html"] });
+      res.writeHead(200, {
+        "Content-Type": MIME[".html"],
+        "Cache-Control": "no-store, max-age=0",
+      });
       res.end(indexHtml);
       return;
     }
@@ -539,7 +768,35 @@ export async function createPlanReviewServer({
           return;
         }
         const ext = path.extname(brandAssetPath).toLowerCase();
-        res.writeHead(200, { "Content-Type": MIME[ext] || "application/octet-stream" });
+        res.writeHead(200, {
+          "Content-Type": MIME[ext] || "application/octet-stream",
+          "Cache-Control": "no-store, max-age=0",
+        });
+        res.end(data);
+      });
+      return;
+    }
+
+    // Layout chrome thumbnails for the picker — served from the materialized
+    // bundle's assets dir, basename-guarded to the chrome-<Name>.<ext> shape.
+    if (pathname.startsWith("/brand/chrome/")) {
+      const name = path.basename(pathname);
+      if (!chromeDir || !CHROME_ASSET_RE.test(name)) {
+        res.writeHead(404);
+        res.end("not found");
+        return;
+      }
+      fs.readFile(path.join(chromeDir, name), (err, data) => {
+        if (err) {
+          res.writeHead(404);
+          res.end("not found");
+          return;
+        }
+        const ext = path.extname(name).toLowerCase();
+        res.writeHead(200, {
+          "Content-Type": MIME[ext] || "application/octet-stream",
+          "Cache-Control": "no-store, max-age=0",
+        });
         res.end(data);
       });
       return;
@@ -614,6 +871,24 @@ export async function runPlanReview({
     return;
   }
 
+  // Headless simulation runs (scripts/codex-sim.mjs): approve without a browser.
+  if (process.env.SLIDEMIND_GATE_AUTOAPPROVE === "1") {
+    savePlanState(deckDir, {
+      version: 3,
+      decision: "approve",
+      comments: [],
+      edited: false,
+      planHash: hashPlan(planPath),
+      at: new Date().toISOString(),
+    });
+    process.stdout.write(
+      "DECISION: approved\n" +
+        "Auto-approved via SLIDEMIND_GATE_AUTOAPPROVE — no human reviewed this plan. " +
+        "Proceed to author the slides.\n",
+    );
+    return { decision: "approve", comments: [] };
+  }
+
   const { frontmatterRaw, body, bodyStartLine } = splitPlanFrontmatter(
     fs.readFileSync(planPath, "utf8"),
   );
@@ -624,6 +899,7 @@ export async function runPlanReview({
   const mark = resolveBrandAsset(deckDir, ["logoMarkDark", "logoMark", "logoMarkLight"]);
   const logoMark = mark ? "/brand/logo" : null;
   const brandAssetPath = mark?.path ?? null;
+  const { layouts, chromeDir } = resolvePlanLayouts(deckDir);
 
   const prev = loadPlanState(deckDir);
 
@@ -637,6 +913,8 @@ export async function runPlanReview({
     // A fresh tab renders the previous round's comments from the persisted file
     // (the plan gate's analogue of review.json's ghost pins).
     ledgerSeed: prev.comments || [],
+    layouts,
+    chromeDir,
     port: wantPort,
   });
   // A waiting tab can only exist when the previous round ended in comments — so
@@ -648,9 +926,8 @@ export async function runPlanReview({
     reuseNoun: "plan tab",
     gateNoun: "plan review",
     waitLine:
-      `Waiting for the user's decision — this command BLOCKS (up to ${Math.round(
-        timeoutMs / 60000,
-      )} min) while they review. A long quiet wait is normal; do not cancel it.`,
+      "Waiting for the user's decision — this command BLOCKS until they decide; there is no " +
+      "timeout. A long quiet wait is normal; do not cancel it, and do nothing else meanwhile.",
   });
 
   let decision;
@@ -721,7 +998,7 @@ export async function runPlanReview({
     }
   } else {
     process.stdout.write(
-      formatPlanCommentsForHarness(deckDir, comments, { edited, drained: !!decision.drained }),
+      formatPlanCommentsForHarness(deckDir, comments, { edited }),
     );
   }
   return decision;