diff --git a/packages/cli/src/commands/preview.test.ts b/packages/cli/src/commands/preview.test.ts
new file mode 100644
index 0000000000..38b02f58e6
--- /dev/null
+++ b/packages/cli/src/commands/preview.test.ts
@@ -0,0 +1,53 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { studioLandingSearch } from "./preview.js";
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+function projectWith(storyboard: string | null, frameFiles: string[] = []): string {
+  const dir = mkdtempSync(join(tmpdir(), "hf-preview-landing-"));
+  tempDirs.push(dir);
+  if (storyboard !== null) writeFileSync(join(dir, "STORYBOARD.md"), storyboard);
+  for (const file of frameFiles) {
+    mkdirSync(join(dir, file, ".."), { recursive: true });
+    writeFileSync(join(dir, file), "<div></div>");
+  }
+  return dir;
+}
+
+const FRAME = (n: number, status: string) =>
+  `## Frame ${n} — F${n}\n- status: ${status}\n- src: compositions/frames/0${n}.html\n\nBeat.\n`;
+
+describe("studioLandingSearch", () => {
+  it("returns no search without a storyboard", () => {
+    expect(studioLandingSearch(projectWith(null))).toBe("");
+  });
+
+  it("lands on the board while sketches are under review (any built frame)", () => {
+    const dir = projectWith(`${FRAME(1, "built")}${FRAME(2, "outline")}`, [
+      "compositions/frames/01.html",
+    ]);
+    expect(studioLandingSearch(dir)).toBe("?view=storyboard");
+  });
+
+  it("lands on the board during pure planning (srcs declared, none exist)", () => {
+    const dir = projectWith(`${FRAME(1, "outline")}${FRAME(2, "outline")}`);
+    expect(studioLandingSearch(dir)).toBe("?view=storyboard");
+  });
+
+  it("lands on the timeline once frames exist without a built status", () => {
+    const dir = projectWith(`${FRAME(1, "outline")}`, ["compositions/frames/01.html"]);
+    expect(studioLandingSearch(dir)).toBe("");
+  });
+
+  it("lands on the timeline for fully animated boards", () => {
+    const dir = projectWith(`${FRAME(1, "animated")}`, ["compositions/frames/01.html"]);
+    expect(studioLandingSearch(dir)).toBe("");
+  });
+});
diff --git a/packages/cli/src/commands/preview.ts b/packages/cli/src/commands/preview.ts
index 598d6e92e9..0b11a65e82 100644
--- a/packages/cli/src/commands/preview.ts
+++ b/packages/cli/src/commands/preview.ts
@@ -19,7 +19,16 @@ export const examples: Example[] = [
   ["List all active preview servers", "hyperframes preview --list"],
   ["Kill all active preview servers", "hyperframes preview --kill-all"],
 ];
-import { existsSync, lstatSync, symlinkSync, unlinkSync, readlinkSync, mkdirSync } from "node:fs";
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  symlinkSync,
+  unlinkSync,
+} from "node:fs";
+import { parseStoryboard, STORYBOARD_FILENAME } from "@hyperframes/core/storyboard";
 import { resolve, dirname, basename, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
@@ -635,9 +644,47 @@ function compactSelectionPayload(selection: StudioSelectionSnapshot): CompactSel
   };
 }
 
-function openStudioBrowser(url: string, projectName: string, options?: BrowserLaunchOptions): void {
+// Land the browser on the Storyboard view while the project is still planning
+// or sketching — the timeline only becomes the right landing once frames are
+// animated (or the storyboard never tracked statuses at all, e.g. beat plans).
+export function studioLandingSearch(projectDir: string): string {
+  const storyboardPath = join(projectDir, STORYBOARD_FILENAME);
+  if (!existsSync(storyboardPath)) return "";
+  let frames;
+  try {
+    frames = parseStoryboard(readFileSync(storyboardPath, "utf8")).frames;
+  } catch {
+    return "";
+  }
+  // Sketch review in progress — the board is the review surface.
+  if (frames.some((f) => f.status === "built")) return "?view=storyboard";
+  // Pure planning stage: frames declare src paths but none are built yet.
+  const srcs = frames
+    .map((f) => f.src)
+    .filter((s): s is string => typeof s === "string" && s.length > 0);
+  const planning =
+    frames.length > 0 &&
+    frames.every((f) => f.status === "outline") &&
+    srcs.length > 0 &&
+    !srcs.some((s) => existsSync(join(projectDir, s)));
+  return planning ? "?view=storyboard" : "";
+}
+
+// The full Studio URL to open or hand to the user: status-aware landing view
+// plus the project hash route. `url` never carries a trailing slash (both the
+// embedded server and the Vite `Local:` match strip it).
+function studioDeepLink(url: string, projectName: string, projectDir: string): string {
+  return `${url}/${studioLandingSearch(projectDir)}#project/${projectName}`;
+}
+
+function openStudioBrowser(
+  url: string,
+  projectName: string,
+  projectDir: string,
+  options?: BrowserLaunchOptions,
+): void {
   if (options?.noOpen) return;
-  openBrowser(`${url}#project/${projectName}`, {
+  openBrowser(studioDeepLink(url, projectName, projectDir), {
     browserPath: options?.browserPath,
     userDataDir: options?.userDataDir,
     remoteDebuggingPort: options?.remoteDebuggingPort,
@@ -719,6 +766,7 @@ function attachStudioReadyHandler(
   child: StudioChildProcess,
   spinner: ReturnType<typeof clack.spinner>,
   projectName: string,
+  projectDir: string,
   options?: BrowserLaunchOptions,
 ): void {
   let detected = false;
@@ -730,7 +778,7 @@ function attachStudioReadyHandler(
     detected = true;
     spinner.stop(c.success("Studio running"));
     printStudioSummary(projectName, url, { footer: "Press Ctrl+C to stop" });
-    openStudioBrowser(url, projectName, options);
+    openStudioBrowser(url, projectName, projectDir, options);
     child.stdout.removeListener("data", handleOutput);
     child.stderr.removeListener("data", handleOutput);
   }
@@ -768,7 +816,7 @@ async function runDevMode(dir: string, options?: StudioLaunchOptions): Promise<v
     stdio: ["ignore", "pipe", "pipe"],
   });
 
-  attachStudioReadyHandler(child, s, pName, options);
+  attachStudioReadyHandler(child, s, pName, dir, options);
   removeSymlinkOnExit(createdSymlink, symlinkPath);
 
   // Kill the child's entire process tree on SIGTERM/SIGINT. Ctrl+C sends
@@ -817,7 +865,7 @@ async function runLocalStudioMode(dir: string, options?: StudioLaunchOptions): P
     stdio: ["ignore", "pipe", "pipe"],
   });
 
-  attachStudioReadyHandler(child, s, pName, options);
+  attachStudioReadyHandler(child, s, pName, dir, options);
   removeSymlinkOnExit(createdSymlink, symlinkPath);
 
   // Same tree-kill handler as dev mode. No-op on Windows (see comment above).
@@ -888,7 +936,7 @@ async function runEmbeddedMode(
     printStudioSummary(pName, url, {
       details: ["Reusing existing server. Use --force-new to start a fresh instance."],
     });
-    openStudioBrowser(url, pName, options);
+    openStudioBrowser(url, pName, dir, options);
     return;
   }
 
@@ -906,7 +954,7 @@ async function runEmbeddedMode(
     ],
     footer: "Press Ctrl+C to stop",
   });
-  openStudioBrowser(url, pName, options);
+  openStudioBrowser(url, pName, dir, options);
 
   // Block until Ctrl+C. Node would normally exit on SIGINT, but the listening
   // HTTP server keeps handles open, so the event loop stays alive after the
diff --git a/packages/studio-server/src/helpers/projectSignature.ts b/packages/studio-server/src/helpers/projectSignature.ts
index 4062a1f143..576c78860a 100644
--- a/packages/studio-server/src/helpers/projectSignature.ts
+++ b/packages/studio-server/src/helpers/projectSignature.ts
@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { lstatSync, readFileSync, readdirSync } from "node:fs";
 import { extname, isAbsolute, relative, resolve } from "node:path";
+import type { ResolvedProject, StudioApiAdapter } from "../types.js";
 
 const SIGNATURE_TEXT_EXTENSIONS = new Set([
   ".cjs",
@@ -137,6 +138,25 @@ function createProjectFingerprint(projectDir: string, files: ProjectSignatureFil
   return hash.digest("hex").slice(0, 24);
 }
 
+/**
+ * Resolve the project signature through the adapter's cached path when the host
+ * provides one (the CLI invalidates its cache from the file watcher), falling
+ * back to a direct computation.
+ */
+export function resolveProjectSignature(adapter: StudioApiAdapter, projectDir: string): string {
+  return adapter.getProjectSignature?.(projectDir) ?? createProjectSignature(projectDir);
+}
+
+/** The shared route opening: resolve the project (null → caller 404s) with its signature. */
+export async function resolveProjectAndSignature(
+  adapter: StudioApiAdapter,
+  projectId: string,
+): Promise<{ project: ResolvedProject; signature: string } | null> {
+  const project = await adapter.resolveProject(projectId);
+  if (!project) return null;
+  return { project, signature: resolveProjectSignature(adapter, project.dir) };
+}
+
 /**
  * Creates a stable preview cache-busting signature for project source plus Studio manifests.
  */
diff --git a/packages/studio-server/src/routes/preview.ts b/packages/studio-server/src/routes/preview.ts
index ebb522dcd6..f9d399f34b 100644
--- a/packages/studio-server/src/routes/preview.ts
+++ b/packages/studio-server/src/routes/preview.ts
@@ -7,7 +7,10 @@ import type { StudioApiAdapter } from "../types.js";
 import { resolveWithinProject } from "../helpers/safePath.js";
 import { getMimeType } from "../helpers/mime.js";
 import { buildSubCompositionHtml } from "../helpers/subComposition.js";
-import { createProjectSignature } from "../helpers/projectSignature.js";
+import {
+  resolveProjectAndSignature,
+  resolveProjectSignature,
+} from "../helpers/projectSignature.js";
 import {
   createStudioMotionRenderBodyScript,
   STUDIO_MOTION_PATH,
@@ -22,10 +25,6 @@ const GSAP_CDN_SCRIPT = `<script src="https://cdn.jsdelivr.net/npm/gsap@${GSAP_C
 const GSAP_CUSTOM_EASE_CDN_SCRIPT = `<script src="https://cdn.jsdelivr.net/npm/gsap@${GSAP_CDN_VERSION}/dist/CustomEase.min.js"></script>`;
 const GSAP_MOTION_PATH_CDN_SCRIPT = `<script src="https://cdn.jsdelivr.net/npm/gsap@${GSAP_CDN_VERSION}/dist/MotionPathPlugin.min.js"></script>`;
 
-function resolveProjectSignature(adapter: StudioApiAdapter, projectDir: string): string {
-  return adapter.getProjectSignature?.(projectDir) ?? createProjectSignature(projectDir);
-}
-
 function injectProjectSignature(html: string, signature: string): string {
   const tag = `<meta name="${PROJECT_SIGNATURE_META}" content="${signature}">`;
   if (html.includes(`name="${PROJECT_SIGNATURE_META}"`)) {
@@ -309,15 +308,15 @@ export function registerPreviewRoutes(api: Hono, adapter: StudioApiAdapter): voi
   // Bundled composition preview
   // fallow-ignore-next-line complexity
   api.get("/projects/:id/preview", async (c) => {
-    const project = await adapter.resolveProject(c.req.param("id"));
-    if (!project) return c.json({ error: "not found" }, 404);
+    const resolved = await resolveProjectAndSignature(adapter, c.req.param("id"));
+    if (!resolved) return c.json({ error: "not found" }, 404);
+    const { project, signature } = resolved;
 
     // fallow-ignore-next-line code-duplication
     const vars = previewVariablesFromRequest(c.req.query("variables"));
     if (vars.error !== undefined) return c.json({ error: vars.error }, 400);
     const previewVariables = vars.values;
 
-    const signature = resolveProjectSignature(adapter, project.dir);
     const etag = `"preview:${signature}${variablesEtagSalt(vars.raw)}"`;
     const ifNoneMatch = c.req.header("If-None-Match");
     if (ifNoneMatch === etag) {
@@ -422,15 +421,14 @@ export function registerPreviewRoutes(api: Hono, adapter: StudioApiAdapter): voi
   // Sub-composition preview
   // fallow-ignore-next-line complexity
   api.get("/projects/:id/preview/comp/*", async (c) => {
-    const project = await adapter.resolveProject(c.req.param("id"));
-    if (!project) return c.json({ error: "not found" }, 404);
+    const resolved = await resolveProjectAndSignature(adapter, c.req.param("id"));
+    if (!resolved) return c.json({ error: "not found" }, 404);
+    const { project, signature } = resolved;
 
     // fallow-ignore-next-line code-duplication
     const vars = previewVariablesFromRequest(c.req.query("variables"));
     if (vars.error !== undefined) return c.json({ error: vars.error }, 400);
     const previewVariables = vars.values;
-
-    const signature = resolveProjectSignature(adapter, project.dir);
     const compPath = decodeURIComponent(
       c.req.path.replace(`/projects/${project.id}/preview/comp/`, "").split("?")[0] ?? "",
     );
diff --git a/packages/studio-server/src/routes/projects.test.ts b/packages/studio-server/src/routes/projects.test.ts
index 7414048bdc..e6a6fcfe32 100644
--- a/packages/studio-server/src/routes/projects.test.ts
+++ b/packages/studio-server/src/routes/projects.test.ts
@@ -58,6 +58,50 @@ function createAdapter(projectDir: string): StudioApiAdapter {
   };
 }
 
+describe("GET /projects/:id/signature", () => {
+  it("returns the adapter's cached signature when provided", async () => {
+    const projectDir = createProjectDir();
+    const app = new Hono();
+    registerProjectRoutes(app, {
+      ...createAdapter(projectDir),
+      getProjectSignature: () => "cached-sig",
+    });
+
+    const response = await app.request("http://localhost/projects/demo/signature");
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual({ signature: "cached-sig" });
+  });
+
+  it("computes a signature that moves when project files change", async () => {
+    const projectDir = createProjectDir();
+    const app = new Hono();
+    registerProjectRoutes(app, createAdapter(projectDir));
+
+    const first = (await (
+      await app.request("http://localhost/projects/demo/signature")
+    ).json()) as {
+      signature: string;
+    };
+    expect(first.signature).toMatch(/^[0-9a-f]{24}$/);
+
+    writeFileSync(join(projectDir, "compositions", "scene.html"), "<html><body>new</body></html>");
+    const second = (await (
+      await app.request("http://localhost/projects/demo/signature")
+    ).json()) as { signature: string };
+    expect(second.signature).not.toBe(first.signature);
+  });
+
+  it("404s for an unknown project", async () => {
+    const app = new Hono();
+    registerProjectRoutes(app, {
+      ...createAdapter(createProjectDir()),
+      resolveProject: async () => null,
+    });
+    const response = await app.request("http://localhost/projects/nope/signature");
+    expect(response.status).toBe(404);
+  });
+});
+
 describe("registerProjectRoutes — composition discovery (#1384)", () => {
   it("excludes HTML inside dot-directories from compositions", async () => {
     const projectDir = createProjectDir();
diff --git a/packages/studio-server/src/routes/projects.ts b/packages/studio-server/src/routes/projects.ts
index 76fb0079ec..b0ca6ad2a5 100644
--- a/packages/studio-server/src/routes/projects.ts
+++ b/packages/studio-server/src/routes/projects.ts
@@ -3,6 +3,7 @@ import { join } from "node:path";
 import type { Hono } from "hono";
 import type { StudioApiAdapter } from "../types.js";
 import { isInHiddenOrVendorDir, walkDir } from "../helpers/safePath.js";
+import { resolveProjectSignature } from "../helpers/projectSignature.js";
 
 const COMPOSITION_ID_RE = /data-composition-id\s*=/;
 
@@ -39,6 +40,15 @@ export function registerProjectRoutes(api: Hono, adapter: StudioApiAdapter): voi
     return c.json(result);
   });
 
+  // Current content signature for a project — a cheap poll target for clients
+  // that refresh themselves when files change on disk (the storyboard board
+  // re-fetches when this differs from the signature its data was loaded with).
+  api.get("/projects/:id/signature", async (c) => {
+    const project = await adapter.resolveProject(c.req.param("id"));
+    if (!project) return c.json({ error: "not found" }, 404);
+    return c.json({ signature: resolveProjectSignature(adapter, project.dir) });
+  });
+
   // Project file tree
   api.get("/projects/:id", async (c) => {
     const project = await adapter.resolveProject(c.req.param("id"));
diff --git a/packages/studio-server/src/routes/storyboard.test.ts b/packages/studio-server/src/routes/storyboard.test.ts
index 94f040c375..a2fd535235 100644
--- a/packages/studio-server/src/routes/storyboard.test.ts
+++ b/packages/studio-server/src/routes/storyboard.test.ts
@@ -106,4 +106,17 @@ Not built yet.
     const { body } = await getStoryboard(dir);
     expect(body.frames[0].srcExists).toBe(false);
   });
+
+  it("carries a project signature in both the absent and present branches", async () => {
+    const dir = makeProject();
+    const absent = await getStoryboard(dir);
+    expect(absent.body.exists).toBe(false);
+    expect(absent.body.signature).toMatch(/^[0-9a-f]{24}$/);
+
+    writeFileSync(join(dir, "STORYBOARD.md"), "## Frame 1\n\nHi.\n");
+    const present = await getStoryboard(dir);
+    expect(present.body.exists).toBe(true);
+    expect(present.body.signature).toMatch(/^[0-9a-f]{24}$/);
+    expect(present.body.signature).not.toBe(absent.body.signature);
+  });
 });
diff --git a/packages/studio-server/src/routes/storyboard.ts b/packages/studio-server/src/routes/storyboard.ts
index 874204208b..519463b295 100644
--- a/packages/studio-server/src/routes/storyboard.ts
+++ b/packages/studio-server/src/routes/storyboard.ts
@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import type { Hono } from "hono";
 import type { StudioApiAdapter } from "../types.js";
 import { resolveWithinProject } from "../helpers/safePath.js";
+import { resolveProjectAndSignature } from "../helpers/projectSignature.js";
 import {
   parseStoryboard,
   SCRIPT_FILENAME,
@@ -45,8 +46,11 @@ export function registerStoryboardRoutes(api: Hono, adapter: StudioApiAdapter):
   // file is absent we return `exists: false` with empty frames rather than 404,
   // so the Studio can render an opt-in empty state.
   api.get("/projects/:id/storyboard", async (c) => {
-    const project = await adapter.resolveProject(c.req.param("id"));
-    if (!project) return c.json({ error: "not found" }, 404);
+    // The signature lets the board bust poster caches and lets the client tell
+    // whether this payload is already current (see /projects/:id/signature).
+    const resolved = await resolveProjectAndSignature(adapter, c.req.param("id"));
+    if (!resolved) return c.json({ error: "not found" }, 404);
+    const { project, signature } = resolved;
 
     const abs = resolveWithinProject(project.dir, STORYBOARD_FILENAME);
     if (!abs || !existsSync(abs)) {
@@ -57,6 +61,7 @@ export function registerStoryboardRoutes(api: Hono, adapter: StudioApiAdapter):
         frames: [],
         warnings: [],
         script: readScript(project.dir),
+        signature,
       });
     }
 
@@ -75,6 +80,7 @@ export function registerStoryboardRoutes(api: Hono, adapter: StudioApiAdapter):
       frames: resolveFrames(project.dir, manifest.frames),
       warnings: manifest.warnings,
       script: readScript(project.dir),
+      signature,
     });
   });
 }
diff --git a/packages/studio/src/components/storyboard/FramePoster.tsx b/packages/studio/src/components/storyboard/FramePoster.tsx
index 722f3dbd65..60d41e044b 100644
--- a/packages/studio/src/components/storyboard/FramePoster.tsx
+++ b/packages/studio/src/components/storyboard/FramePoster.tsx
@@ -10,6 +10,13 @@ export interface FramePosterProps {
   title: string;
   /** `cover` fills+crops (contact-sheet tile); `contain` letterboxes (focus hero). */
   fit?: "cover" | "contain";
+  /**
+   * Project content signature to key the poster URL on. The thumbnail route
+   * regenerates when the frame's source changes, but the browser only refetches
+   * when the URL does — so bake the signature in to pick up fresh posters after
+   * a background board refresh.
+   */
+  posterVersion?: string;
 }
 
 /**
@@ -18,11 +25,19 @@ export interface FramePosterProps {
  * no postMessage seek, and no client-side fps assumption. Shared by the
  * contact-sheet tile and the frame-focus view.
  */
-export function FramePoster({ projectId, src, seconds, title, fit = "cover" }: FramePosterProps) {
+export function FramePoster({
+  projectId,
+  src,
+  seconds,
+  title,
+  fit = "cover",
+  posterVersion,
+}: FramePosterProps) {
   const [failed, setFailed] = useState(false);
   // The <img> is reused (no key) when a tile/hero swaps to a different frame, so a
-  // prior load error would stick. Reset when the poster target changes.
-  useEffect(() => setFailed(false), [src, seconds]);
+  // prior load error would stick. Reset when the poster target changes — including
+  // a new posterVersion, so a frame that failed mid-write retries once it settles.
+  useEffect(() => setFailed(false), [src, seconds, posterVersion]);
   if (failed) {
     return (
       <div className="flex h-full w-full items-center justify-center text-[11px] text-neutral-600">
@@ -30,12 +45,17 @@ export function FramePoster({ projectId, src, seconds, title, fit = "cover" }: F
       </div>
     );
   }
-  const url = buildCompositionThumbnailUrl({
+  let url = buildCompositionThumbnailUrl({
     previewUrl: `/api/projects/${projectId}/preview/comp/${src}`,
     seekTime: seconds,
     duration: 0,
     origin: window.location.origin,
   });
+  if (posterVersion) {
+    const withVersion = new URL(url, window.location.origin);
+    withVersion.searchParams.set("sig", posterVersion);
+    url = withVersion.toString();
+  }
   return (
     <img
       src={url}
diff --git a/packages/studio/src/components/storyboard/StoryboardFrameFocus.tsx b/packages/studio/src/components/storyboard/StoryboardFrameFocus.tsx
index 22300fe6b7..dea27f11f7 100644
--- a/packages/studio/src/components/storyboard/StoryboardFrameFocus.tsx
+++ b/packages/studio/src/components/storyboard/StoryboardFrameFocus.tsx
@@ -19,6 +19,8 @@ export interface StoryboardFrameFocusProps {
   onSaved: () => void;
   /** Select a composition in the timeline (sets active comp + editing file + sidebar highlight). */
   onSelectComposition: (path: string) => void;
+  /** Project signature the board was loaded with (busts the poster cache). */
+  posterVersion?: string;
 }
 
 /**
@@ -39,6 +41,7 @@ export function StoryboardFrameFocus({
   onNavigate,
   onSaved,
   onSelectComposition,
+  posterVersion,
 }: StoryboardFrameFocusProps) {
   const { readProjectFile, writeProjectFile } = useFileManagerContext();
   const { setViewMode } = useViewMode();
@@ -151,6 +154,7 @@ export function StoryboardFrameFocus({
                 seconds={posterTime(frame)}
                 title={title}
                 fit="contain"
+                posterVersion={posterVersion}
               />
             ) : (
               <div className="flex h-full w-full items-center justify-center text-sm text-neutral-600">
diff --git a/packages/studio/src/components/storyboard/StoryboardFrameTile.tsx b/packages/studio/src/components/storyboard/StoryboardFrameTile.tsx
index 62b0173bfb..a128a6fbe8 100644
--- a/packages/studio/src/components/storyboard/StoryboardFrameTile.tsx
+++ b/packages/studio/src/components/storyboard/StoryboardFrameTile.tsx
@@ -7,6 +7,13 @@ export interface StoryboardFrameTileProps {
   frame: StoryboardFrameView;
   /** Open this frame in the full-area focus view. */
   onOpen: (index: number) => void;
+  /** This frame's pending comment draft ("" when none). */
+  commentDraft: string;
+  onCommentDraftChange: (index: number, text: string) => void;
+  /** A submitted comment the agent has not consumed yet (null when none). */
+  pendingComment: string | null;
+  /** Project signature the board was loaded with (busts the poster cache). */
+  posterVersion?: string;
 }
 
 function firstLine(text: string): string {
@@ -26,7 +33,15 @@ function placeholderMessage(frame: StoryboardFrameView): string {
 
 /** A single contact-sheet tile: poster preview + its metadata. Click to focus. */
 // fallow-ignore-next-line complexity
-export function StoryboardFrameTile({ projectId, frame, onOpen }: StoryboardFrameTileProps) {
+export function StoryboardFrameTile({
+  projectId,
+  frame,
+  onOpen,
+  commentDraft,
+  onCommentDraftChange,
+  pendingComment,
+  posterVersion,
+}: StoryboardFrameTileProps) {
   const meta = FRAME_STATUS_META[frame.status];
   const renderable = frame.srcExists && frame.status !== "outline";
   const title = frame.title ?? `Frame ${frame.index}`;
@@ -48,6 +63,7 @@ export function StoryboardFrameTile({ projectId, frame, onOpen }: StoryboardFram
             src={frame.src}
             seconds={posterTime(frame)}
             title={title}
+            posterVersion={posterVersion}
           />
         ) : (
           <FrameTilePlaceholder frame={frame} />
@@ -74,6 +90,19 @@ export function StoryboardFrameTile({ projectId, frame, onOpen }: StoryboardFram
         {frame.duration && <span>{frame.duration}</span>}
         {frame.transitionIn && <span>↘ {frame.transitionIn}</span>}
       </div>
+      <textarea
+        value={commentDraft}
+        onChange={(e) => onCommentDraftChange(frame.index, e.target.value)}
+        rows={2}
+        placeholder="Comment on this frame…"
+        aria-label={`Comment on ${title}`}
+        className="mt-2 w-full resize-none rounded-md border border-neutral-800 bg-neutral-900/60 px-2 py-1.5 text-xs text-neutral-200 placeholder:text-neutral-600 focus:border-sky-700 focus:outline-none"
+      />
+      {pendingComment && (
+        <p className="mt-1 text-[11px] text-sky-400/90">
+          <span className="font-medium">Pending:</span> “{pendingComment}”
+        </p>
+      )}
     </article>
   );
 }
diff --git a/packages/studio/src/components/storyboard/StoryboardGrid.tsx b/packages/studio/src/components/storyboard/StoryboardGrid.tsx
index 9e87e53a2f..d35227bead 100644
--- a/packages/studio/src/components/storyboard/StoryboardGrid.tsx
+++ b/packages/studio/src/components/storyboard/StoryboardGrid.tsx
@@ -1,4 +1,5 @@
 import type { StoryboardFrameView } from "../../hooks/useStoryboard";
+import type { FrameCommentEntry } from "./frameComments";
 import { StoryboardFrameTile } from "./StoryboardFrameTile";
 
 export interface StoryboardGridProps {
@@ -6,10 +7,25 @@ export interface StoryboardGridProps {
   frames: StoryboardFrameView[];
   /** Open a frame in the full-area focus view. */
   onOpenFrame: (index: number) => void;
+  /** Per-frame comment drafts, keyed by frame index. */
+  commentDrafts: Record<number, string>;
+  onCommentDraftChange: (index: number, text: string) => void;
+  /** Submitted comments the agent has not consumed yet. */
+  pendingComments: FrameCommentEntry[] | null;
+  /** Project signature the board was loaded with (busts poster caches). */
+  posterVersion?: string;
 }
 
 /** The contact sheet: ordered frame tiles in a responsive grid. */
-export function StoryboardGrid({ projectId, frames, onOpenFrame }: StoryboardGridProps) {
+export function StoryboardGrid({
+  projectId,
+  frames,
+  onOpenFrame,
+  commentDrafts,
+  onCommentDraftChange,
+  pendingComments,
+  posterVersion,
+}: StoryboardGridProps) {
   if (frames.length === 0) {
     return (
       <div className="mt-8 rounded-lg border border-dashed border-neutral-800 px-6 py-12 text-center text-sm text-neutral-500">
@@ -26,6 +42,12 @@ export function StoryboardGrid({ projectId, frames, onOpenFrame }: StoryboardGri
           projectId={projectId}
           frame={frame}
           onOpen={onOpenFrame}
+          commentDraft={commentDrafts[frame.index] ?? ""}
+          onCommentDraftChange={onCommentDraftChange}
+          pendingComment={
+            pendingComments?.find((entry) => entry.frame === frame.index)?.text ?? null
+          }
+          posterVersion={posterVersion}
         />
       ))}
     </div>
diff --git a/packages/studio/src/components/storyboard/StoryboardLoaded.tsx b/packages/studio/src/components/storyboard/StoryboardLoaded.tsx
index bc1453c4d3..3cd5fc3dc2 100644
--- a/packages/studio/src/components/storyboard/StoryboardLoaded.tsx
+++ b/packages/studio/src/components/storyboard/StoryboardLoaded.tsx
@@ -1,11 +1,13 @@
-import { useMemo, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import type { StoryboardResponse } from "../../hooks/useStoryboard";
+import { Button } from "../ui/Button";
 import { StoryboardDirection } from "./StoryboardDirection";
 import { StoryboardGrid } from "./StoryboardGrid";
 import { StoryboardStatusLegend } from "./StoryboardStatusLegend";
 import { StoryboardScriptPanel } from "./StoryboardScriptPanel";
 import { StoryboardSourceEditor, type SourceFile } from "./StoryboardSourceEditor";
 import { StoryboardFrameFocus } from "./StoryboardFrameFocus";
+import { useFrameComments, type CommentsSubmitState } from "./useFrameComments";
 
 type SubView = "board" | "source";
 
@@ -33,6 +35,14 @@ export function StoryboardLoaded({
   const [subView, setSubView] = useState<SubView>("board");
   const [sourceDirty, setSourceDirty] = useState(false);
   const [focusedIndex, setFocusedIndex] = useState<number | null>(null);
+  const comments = useFrameComments(data.frames);
+  // When the board refreshes off a project change (agent revised frames), the
+  // agent has likely consumed the comments file too — re-check so the pending
+  // banner clears the moment revisions land, not on the next window focus.
+  const { refreshPending } = comments;
+  useEffect(() => {
+    void refreshPending();
+  }, [data.signature, refreshPending]);
   const sourceFiles = useMemo<SourceFile[]>(() => {
     const files: SourceFile[] = [{ path: data.path, label: data.path }];
     if (data.script?.exists) files.push({ path: data.script.path, label: data.script.path });
@@ -72,14 +82,23 @@ export function StoryboardLoaded({
         }
         onSaved={reload}
         onSelectComposition={onSelectComposition}
+        posterVersion={data.signature}
       />
     );
   }
 
   return (
     <div className="flex flex-1 min-h-0 flex-col bg-neutral-950 text-neutral-200">
-      <div className="flex items-center border-b border-neutral-800 px-4 py-2">
+      <div className="flex items-center gap-3 border-b border-neutral-800 px-4 py-2">
         <SubViewToggle value={subView} onChange={changeSubView} />
+        {subView === "board" && (
+          <CommentsSubmitBar
+            draftCount={comments.draftCount}
+            pendingCount={comments.pending?.length ?? 0}
+            submitState={comments.submitState}
+            onSubmit={() => void comments.submit()}
+          />
+        )}
       </div>
       {subView === "board" ? (
         <div className="flex-1 min-h-0 overflow-auto">
@@ -92,6 +111,10 @@ export function StoryboardLoaded({
               projectId={projectId}
               frames={data.frames}
               onOpenFrame={setFocusedIndex}
+              commentDrafts={comments.drafts}
+              onCommentDraftChange={comments.setDraft}
+              pendingComments={comments.pending}
+              posterVersion={data.signature}
             />
             {data.script && <StoryboardScriptPanel script={data.script} />}
           </div>
@@ -107,6 +130,39 @@ export function StoryboardLoaded({
   );
 }
 
+/** Batch-submit the per-frame comment drafts to `.hyperframes/frame-comments.json`. */
+function CommentsSubmitBar({
+  draftCount,
+  pendingCount,
+  submitState,
+  onSubmit,
+}: {
+  draftCount: number;
+  pendingCount: number;
+  submitState: CommentsSubmitState;
+  onSubmit: () => void;
+}) {
+  return (
+    <div className="ml-auto flex items-center gap-3">
+      {pendingCount > 0 && (
+        <span className="text-xs text-sky-300">
+          {pendingCount} comment{pendingCount > 1 ? "s" : ""} pending — reply anything in your agent
+          chat and it will apply them.
+        </span>
+      )}
+      <Button
+        variant="primary"
+        size="sm"
+        loading={submitState === "saving"}
+        disabled={draftCount === 0 || submitState === "saving"}
+        onClick={onSubmit}
+      >
+        {draftCount > 0 ? `Submit comments (${draftCount})` : "Submit comments"}
+      </Button>
+    </div>
+  );
+}
+
 const SUB_VIEWS: Array<{ value: SubView; label: string }> = [
   { value: "board", label: "Board" },
   { value: "source", label: "Source" },
diff --git a/packages/studio/src/components/storyboard/StoryboardView.tsx b/packages/studio/src/components/storyboard/StoryboardView.tsx
index 56310c426e..7920a0b321 100644
--- a/packages/studio/src/components/storyboard/StoryboardView.tsx
+++ b/packages/studio/src/components/storyboard/StoryboardView.tsx
@@ -1,6 +1,7 @@
 import { useState, type ReactNode } from "react";
 import { Copy, Check } from "@phosphor-icons/react";
 import { useStoryboard } from "../../hooks/useStoryboard";
+import { useProjectSignaturePoll } from "../../hooks/useProjectSignaturePoll";
 import { copyTextToClipboard } from "../../utils/clipboard";
 import { Button } from "../ui/Button";
 import { StoryboardLoaded } from "./StoryboardLoaded";
@@ -19,6 +20,10 @@ export interface StoryboardViewProps {
 // fallow-ignore-next-line complexity
 export function StoryboardView({ projectId, onSelectComposition }: StoryboardViewProps) {
   const { data, loading, error, reload } = useStoryboard(projectId);
+  // Keep the board current while an agent writes to the project: when the
+  // project signature moves past the one `data` was loaded with, refetch. Also
+  // upgrades the empty state the moment STORYBOARD.md lands on disk.
+  useProjectSignaturePoll(projectId, data?.signature, reload);
 
   if (loading) return <StoryboardFrame>{<Message>Loading storyboard…</Message>}</StoryboardFrame>;
   if (error) {
@@ -87,12 +92,14 @@ audience: <who it's for>
 ## Frame 1 — <title>
 - duration: 5s
 - transition_in: crossfade
-- status: planned
+- status: outline
 - src: compositions/frames/01-<slug>.html
 
 <A sentence or two: what's on screen and what the narration says.>
 
-Add one \`## Frame N\` section per beat. Keep the arc tight.`;
+Add one \`## Frame N\` section per beat. Keep the arc tight.
+
+Then run the review loop from the hyperframes-core skill (references/review-loop.md): present the plan as a proposal, offer wireframe sketches on this board, and build on the confirmed layouts.`;
 }
 
 function EmptyState({ path }: { path: string }) {
diff --git a/packages/studio/src/components/storyboard/frameComments.test.ts b/packages/studio/src/components/storyboard/frameComments.test.ts
new file mode 100644
index 0000000000..0161d3180a
--- /dev/null
+++ b/packages/studio/src/components/storyboard/frameComments.test.ts
@@ -0,0 +1,95 @@
+import { describe, expect, it } from "vitest";
+import { buildCommentsFile, draftEntries, parseCommentsFile, passForFrames } from "./frameComments";
+
+const frames = [
+  { index: 1, status: "built" as const, src: "compositions/frames/01-hook.html", title: "Hook" },
+  {
+    index: 2,
+    status: "built" as const,
+    src: "compositions/frames/02-thesis.html",
+    title: "Thesis",
+  },
+  { index: 3, status: "built" as const, src: "compositions/frames/03-proof.html", title: "Proof" },
+];
+
+describe("passForFrames", () => {
+  it("maps the furthest status to the review pass", () => {
+    expect(passForFrames([{ status: "outline" }, { status: "outline" }])).toBe("storyboard");
+    expect(passForFrames([{ status: "outline" }, { status: "built" }])).toBe("sketch");
+    expect(passForFrames([{ status: "built" }, { status: "animated" }])).toBe("final");
+  });
+});
+
+describe("draftEntries", () => {
+  it("keeps only non-empty drafts, in board order, with src/title echoed", () => {
+    const entries = draftEntries(frames, { 3: "swap the chart", 1: "  ", 2: "tighter kerning" });
+    expect(entries).toEqual([
+      { frame: 2, src: frames[1]?.src, title: "Thesis", text: "tighter kerning" },
+      { frame: 3, src: frames[2]?.src, title: "Proof", text: "swap the chart" },
+    ]);
+  });
+});
+
+describe("parseCommentsFile", () => {
+  it("reads a well-formed file", () => {
+    const parsed = parseCommentsFile(
+      JSON.stringify({
+        version: 1,
+        pass: "sketch",
+        submitted_at: "2026-07-10T00:00:00Z",
+        comments: [{ frame: 2, text: "hi" }],
+      }),
+    );
+    expect(parsed?.pass).toBe("sketch");
+    expect(parsed?.comments).toEqual([{ frame: 2, src: undefined, title: undefined, text: "hi" }]);
+  });
+
+  it("treats empty or malformed input as no file", () => {
+    expect(parseCommentsFile("")).toBeNull();
+    expect(parseCommentsFile("not json")).toBeNull();
+    expect(parseCommentsFile(JSON.stringify({ comments: "nope" }))).toBeNull();
+  });
+
+  it("drops malformed entries but keeps the valid ones", () => {
+    const parsed = parseCommentsFile(
+      JSON.stringify({ comments: [{ frame: 1, text: "ok" }, { frame: "x" }, null] }),
+    );
+    expect(parsed?.comments).toEqual([{ frame: 1, src: undefined, title: undefined, text: "ok" }]);
+  });
+});
+
+describe("buildCommentsFile", () => {
+  it("merges an unconsumed previous batch: new frames win, others stay", () => {
+    const previous = parseCommentsFile(
+      JSON.stringify({
+        version: 1,
+        pass: "sketch",
+        submitted_at: "2026-07-10T00:00:00Z",
+        comments: [
+          { frame: 1, text: "old note on hook" },
+          { frame: 3, text: "old note on proof" },
+        ],
+      }),
+    );
+    const file = buildCommentsFile(
+      frames,
+      { 3: "new note on proof" },
+      previous,
+      "2026-07-10T01:00:00Z",
+    );
+    expect(file.pass).toBe("sketch");
+    expect(file.submitted_at).toBe("2026-07-10T01:00:00Z");
+    expect(file.comments.map((c) => [c.frame, c.text])).toEqual([
+      [1, "old note on hook"],
+      [3, "new note on proof"],
+    ]);
+  });
+
+  it("writes a fresh batch when no previous file exists", () => {
+    const file = buildCommentsFile(frames, { 2: "tighter" }, null, "2026-07-10T01:00:00Z");
+    expect(file.version).toBe(1);
+    expect(file.comments).toEqual([
+      { frame: 2, src: frames[1]?.src, title: "Thesis", text: "tighter" },
+    ]);
+  });
+});
diff --git a/packages/studio/src/components/storyboard/frameComments.ts b/packages/studio/src/components/storyboard/frameComments.ts
new file mode 100644
index 0000000000..8f9e1361fd
--- /dev/null
+++ b/packages/studio/src/components/storyboard/frameComments.ts
@@ -0,0 +1,115 @@
+import type { FrameStatus } from "@hyperframes/core/storyboard";
+
+/**
+ * Frame comments — the storyboard review's structured feedback channel.
+ *
+ * The board's per-frame comment boxes write one batch file on submit; the
+ * consuming agent revises exactly the frames named, deletes the file, and
+ * re-presents. The file shape is a cross-repo contract — keep it in sync with
+ * skills/hyperframes-core/references/storyboard-format.md § Frame comments.
+ */
+export const FRAME_COMMENTS_PATH = ".hyperframes/frame-comments.json";
+
+export type FrameCommentsPass = "storyboard" | "sketch" | "final";
+
+export interface FrameCommentEntry {
+  /** The frame's 1-based `index` in the manifest — the key. */
+  frame: number;
+  /** Copied from the frame at submit time so a post-submit reorder is detectable. */
+  src?: string;
+  title?: string;
+  text: string;
+}
+
+export interface FrameCommentsFile {
+  version: 1;
+  pass: FrameCommentsPass;
+  submitted_at: string;
+  comments: FrameCommentEntry[];
+}
+
+interface CommentableFrame {
+  index: number;
+  status: FrameStatus;
+  src?: string;
+  title?: string;
+}
+
+/** Which review the batch belongs to — the furthest status present on the board. */
+export function passForFrames(frames: ReadonlyArray<{ status: FrameStatus }>): FrameCommentsPass {
+  if (frames.some((f) => f.status === "animated")) return "final";
+  if (frames.some((f) => f.status === "built")) return "sketch";
+  return "storyboard";
+}
+
+/** The non-empty drafts as file entries, in board order. */
+export function draftEntries(
+  frames: readonly CommentableFrame[],
+  drafts: Readonly<Record<number, string>>,
+): FrameCommentEntry[] {
+  const entries: FrameCommentEntry[] = [];
+  for (const frame of frames) {
+    const text = drafts[frame.index]?.trim();
+    if (!text) continue;
+    entries.push({ frame: frame.index, src: frame.src, title: frame.title, text });
+  }
+  return entries;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function parseCommentEntry(item: unknown): FrameCommentEntry | null {
+  if (!isRecord(item)) return null;
+  if (typeof item.frame !== "number" || typeof item.text !== "string") return null;
+  return {
+    frame: item.frame,
+    src: typeof item.src === "string" ? item.src : undefined,
+    title: typeof item.title === "string" ? item.title : undefined,
+    text: item.text,
+  };
+}
+
+function parsePass(value: unknown): FrameCommentsPass {
+  return value === "sketch" || value === "final" ? value : "storyboard";
+}
+
+/** Tolerant read of an existing comments file — anything malformed counts as "no file". */
+export function parseCommentsFile(raw: string): FrameCommentsFile | null {
+  if (!raw.trim()) return null;
+  let data: unknown;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(data) || !Array.isArray(data.comments)) return null;
+  const comments = data.comments
+    .map(parseCommentEntry)
+    .filter((entry): entry is FrameCommentEntry => entry !== null);
+  return {
+    version: 1,
+    pass: parsePass(data.pass),
+    submitted_at: typeof data.submitted_at === "string" ? data.submitted_at : "",
+    comments,
+  };
+}
+
+/**
+ * One file = the currently pending feedback. A resubmit before the agent
+ * consumed the previous batch keeps the pending entries for frames the new
+ * batch doesn't mention and overwrites the ones it does.
+ */
+export function buildCommentsFile(
+  frames: readonly CommentableFrame[],
+  drafts: Readonly<Record<number, string>>,
+  previous: FrameCommentsFile | null,
+  submittedAt: string,
+): FrameCommentsFile {
+  const fresh = draftEntries(frames, drafts);
+  const freshIndexes = new Set(fresh.map((entry) => entry.frame));
+  const kept = previous?.comments.filter((entry) => !freshIndexes.has(entry.frame)) ?? [];
+  const comments = [...kept, ...fresh].sort((a, b) => a.frame - b.frame);
+  return { version: 1, pass: passForFrames(frames), submitted_at: submittedAt, comments };
+}
diff --git a/packages/studio/src/components/storyboard/useFrameComments.ts b/packages/studio/src/components/storyboard/useFrameComments.ts
new file mode 100644
index 0000000000..c90694993e
--- /dev/null
+++ b/packages/studio/src/components/storyboard/useFrameComments.ts
@@ -0,0 +1,82 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useFileManagerContext } from "../../contexts/FileManagerContext";
+import type { StoryboardFrameView } from "../../hooks/useStoryboard";
+import {
+  FRAME_COMMENTS_PATH,
+  buildCommentsFile,
+  parseCommentsFile,
+  type FrameCommentEntry,
+} from "./frameComments";
+
+export type CommentsSubmitState = "idle" | "saving";
+
+export interface FrameCommentsValue {
+  /** Draft text per frame index — "" / absent means no comment. */
+  drafts: Record<number, string>;
+  setDraft: (index: number, text: string) => void;
+  /** How many frames currently carry a non-empty draft. */
+  draftCount: number;
+  submitState: CommentsSubmitState;
+  /** Write the batch to `.hyperframes/frame-comments.json` and clear the drafts. */
+  submit: () => Promise<void>;
+  /**
+   * Comments already submitted but not yet consumed by the agent (the file
+   * still exists on disk). Refreshed on mount, after submit, and on window
+   * focus — the agent deletes the file once it has applied the feedback.
+   */
+  pending: FrameCommentEntry[] | null;
+  /** Re-read the comments file — callers hook this to board data refreshes. */
+  refreshPending: () => Promise<void>;
+}
+
+/** Per-frame comment drafts + the batch submit that writes the comments file. */
+export function useFrameComments(frames: StoryboardFrameView[]): FrameCommentsValue {
+  const { writeProjectFile, readOptionalProjectFile } = useFileManagerContext();
+  const [drafts, setDrafts] = useState<Record<number, string>>({});
+  const [submitState, setSubmitState] = useState<CommentsSubmitState>("idle");
+  const [pending, setPending] = useState<FrameCommentEntry[] | null>(null);
+
+  const refreshPending = useCallback(async () => {
+    try {
+      const parsed = parseCommentsFile(await readOptionalProjectFile(FRAME_COMMENTS_PATH));
+      setPending(parsed && parsed.comments.length > 0 ? parsed.comments : null);
+    } catch {
+      // Transient read failure — keep whatever is currently shown.
+    }
+  }, [readOptionalProjectFile]);
+
+  useEffect(() => {
+    void refreshPending();
+    const onFocus = () => void refreshPending();
+    window.addEventListener("focus", onFocus);
+    return () => window.removeEventListener("focus", onFocus);
+  }, [refreshPending]);
+
+  const setDraft = useCallback((index: number, text: string) => {
+    setDrafts((prev) => ({ ...prev, [index]: text }));
+  }, []);
+
+  const draftCount = useMemo(
+    () => Object.values(drafts).filter((text) => text.trim().length > 0).length,
+    [drafts],
+  );
+
+  const submit = useCallback(async () => {
+    if (draftCount === 0 || submitState === "saving") return;
+    setSubmitState("saving");
+    try {
+      const previous = parseCommentsFile(await readOptionalProjectFile(FRAME_COMMENTS_PATH));
+      const file = buildCommentsFile(frames, drafts, previous, new Date().toISOString());
+      await writeProjectFile(FRAME_COMMENTS_PATH, `${JSON.stringify(file, null, 2)}\n`);
+      setDrafts({});
+      setPending(file.comments);
+    } catch {
+      // writeProjectFile surfaces save failures through the studio save banner;
+      // just re-arm the button so the user can retry.
+    } finally {
+      setSubmitState("idle");
+    }
+  }, [draftCount, submitState, frames, drafts, readOptionalProjectFile, writeProjectFile]);
+
+  return { drafts, setDraft, draftCount, submitState, submit, pending, refreshPending };
+}
diff --git a/packages/studio/src/hooks/useProjectSignaturePoll.test.tsx b/packages/studio/src/hooks/useProjectSignaturePoll.test.tsx
new file mode 100644
index 0000000000..61c417e607
--- /dev/null
+++ b/packages/studio/src/hooks/useProjectSignaturePoll.test.tsx
@@ -0,0 +1,135 @@
+// @vitest-environment happy-dom
+
+import React, { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useProjectSignaturePoll } from "./useProjectSignaturePoll";
+
+Reflect.set(globalThis, "IS_REACT_ACT_ENVIRONMENT", true);
+
+function HookHost({
+  signature,
+  onChange,
+}: {
+  signature: string | undefined;
+  onChange: () => void;
+}) {
+  useProjectSignaturePoll("demo", signature, onChange);
+  return null;
+}
+
+let root: Root | null = null;
+let container: HTMLElement | null = null;
+
+function mount(signature: string | undefined, onChange: () => void): void {
+  act(() => {
+    if (!root) {
+      container = document.createElement("div");
+      document.body.appendChild(container);
+      root = createRoot(container);
+    }
+    root.render(<HookHost signature={signature} onChange={onChange} />);
+  });
+}
+
+function unmount(): void {
+  if (root) {
+    act(() => root?.unmount());
+    root = null;
+  }
+  container?.remove();
+  container = null;
+}
+
+function mockSignatureResponse(signature: string): ReturnType<typeof vi.fn> {
+  const fetchMock = vi.fn(async () => ({ ok: true, json: async () => ({ signature }) }));
+  vi.stubGlobal("fetch", fetchMock);
+  return fetchMock;
+}
+
+describe("useProjectSignaturePoll", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    unmount();
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it("fires onChange when the polled signature moves past the loaded one", async () => {
+    const fetchMock = mockSignatureResponse("sig-b");
+    const onChange = vi.fn();
+    mount("sig-a", onChange);
+
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(fetchMock).toHaveBeenCalledWith("/api/projects/demo/signature");
+    expect(onChange).toHaveBeenCalledTimes(1);
+  });
+
+  it("stays quiet while the polled signature matches", async () => {
+    mockSignatureResponse("sig-a");
+    const onChange = vi.fn();
+    mount("sig-a", onChange);
+
+    await vi.advanceTimersByTimeAsync(6000);
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it("does not poll before a baseline signature exists", async () => {
+    const fetchMock = mockSignatureResponse("sig-a");
+    const onChange = vi.fn();
+    mount(undefined, onChange);
+
+    await vi.advanceTimersByTimeAsync(6000);
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it("re-arms against the caller's refreshed signature without re-mounting", async () => {
+    mockSignatureResponse("sig-b");
+    const onChange = vi.fn();
+    mount("sig-a", onChange);
+
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(onChange).toHaveBeenCalledTimes(1);
+
+    // The caller refetched and now holds the polled signature — no more firing.
+    mount("sig-b", onChange);
+    await vi.advanceTimersByTimeAsync(6000);
+    expect(onChange).toHaveBeenCalledTimes(1);
+  });
+
+  it("skips ticks while the tab is hidden and re-checks on visibility", async () => {
+    const fetchMock = mockSignatureResponse("sig-b");
+    const onChange = vi.fn();
+    let hidden = true;
+    vi.spyOn(document, "hidden", "get").mockImplementation(() => hidden);
+    mount("sig-a", onChange);
+
+    await vi.advanceTimersByTimeAsync(6000);
+    expect(fetchMock).not.toHaveBeenCalled();
+
+    hidden = false;
+    await act(async () => {
+      document.dispatchEvent(new Event("visibilitychange"));
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(onChange).toHaveBeenCalledTimes(1);
+  });
+
+  it("stops polling after unmount", async () => {
+    mockSignatureResponse("sig-b");
+    const onChange = vi.fn();
+    mount("sig-a", onChange);
+
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(onChange).toHaveBeenCalledTimes(1);
+
+    unmount();
+    await vi.advanceTimersByTimeAsync(10_000);
+    expect(onChange).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/packages/studio/src/hooks/useProjectSignaturePoll.ts b/packages/studio/src/hooks/useProjectSignaturePoll.ts
new file mode 100644
index 0000000000..5692252534
--- /dev/null
+++ b/packages/studio/src/hooks/useProjectSignaturePoll.ts
@@ -0,0 +1,68 @@
+import { useEffect, useRef } from "react";
+import { buildProjectApiPath } from "../utils/projectRouting";
+
+const POLL_INTERVAL_MS = 2000;
+
+/** One poll: the current signature, or null on any failure (skip this tick). */
+async function fetchProjectSignature(projectId: string): Promise<string | null> {
+  try {
+    const res = await fetch(buildProjectApiPath(projectId, "/signature"));
+    if (!res.ok) return null;
+    const body = (await res.json()) as { signature?: string };
+    return typeof body.signature === "string" ? body.signature : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Poll the project's content signature and fire `onChange` when it no longer
+ * matches `currentSignature` — the storyboard board uses this to refresh itself
+ * while an agent writes sketch frames to disk.
+ *
+ * The comparison baseline is the signature the caller's data was loaded with,
+ * so a refetch triggered by `onChange` naturally re-arms the poll with the new
+ * value. Ticks are skipped while the tab is hidden (a visibility flip re-checks
+ * immediately) and while a previous request is still in flight; request
+ * failures are ignored — polling degrades to today's manual-reload behavior.
+ */
+export function useProjectSignaturePoll(
+  projectId: string | null,
+  currentSignature: string | undefined,
+  onChange: () => void,
+): void {
+  const signatureRef = useRef(currentSignature);
+  const onChangeRef = useRef(onChange);
+  signatureRef.current = currentSignature;
+  onChangeRef.current = onChange;
+
+  useEffect(() => {
+    if (!projectId) return;
+    let disposed = false;
+    let inFlight = false;
+
+    const tick = async () => {
+      if (disposed || inFlight || document.hidden) return;
+      // No baseline yet (initial storyboard fetch still loading, or an older
+      // server without the signature field) — nothing to compare against.
+      if (signatureRef.current === undefined) return;
+      inFlight = true;
+      const latest = await fetchProjectSignature(projectId);
+      inFlight = false;
+      if (disposed || latest === null) return;
+      if (latest !== signatureRef.current) onChangeRef.current();
+    };
+
+    const interval = window.setInterval(() => void tick(), POLL_INTERVAL_MS);
+    const onVisibilityChange = () => {
+      if (!document.hidden) void tick();
+    };
+    document.addEventListener("visibilitychange", onVisibilityChange);
+
+    return () => {
+      disposed = true;
+      window.clearInterval(interval);
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    };
+  }, [projectId]);
+}
diff --git a/packages/studio/src/hooks/useStoryboard.ts b/packages/studio/src/hooks/useStoryboard.ts
index 0ba2001614..debac2ead6 100644
--- a/packages/studio/src/hooks/useStoryboard.ts
+++ b/packages/studio/src/hooks/useStoryboard.ts
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import type {
   StoryboardFrame,
   StoryboardGlobals,
@@ -27,6 +27,8 @@ export interface StoryboardResponse {
   frames: StoryboardFrameView[];
   warnings: StoryboardWarning[];
   script?: StoryboardScript;
+  /** Project content signature this payload was derived from (poster cache-bust + change poll). */
+  signature?: string;
 }
 
 export interface UseStoryboardResult {
@@ -39,19 +41,30 @@ export interface UseStoryboardResult {
 /**
  * Load the parsed storyboard manifest for a project. Markdown stays canonical on
  * disk; this fetches the server-derived JSON the storyboard view renders.
+ *
+ * `reload()` refetches in place: the blocking spinner only shows on first load
+ * and project switches, so background refreshes (file-change polling, post-save
+ * reloads) swap data without flashing the board.
  */
 export function useStoryboard(projectId: string | null): UseStoryboardResult {
   const [data, setData] = useState<StoryboardResponse | null>(null);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [reloadKey, setReloadKey] = useState(0);
+  const hasDataRef = useRef(false);
+  const lastProjectRef = useRef<string | null>(null);
 
   const reload = useCallback(() => setReloadKey((k) => k + 1), []);
 
   useEffect(() => {
     if (!projectId) return;
     let cancelled = false;
-    setLoading(true);
+    if (lastProjectRef.current !== projectId) {
+      lastProjectRef.current = projectId;
+      hasDataRef.current = false;
+      setData(null);
+    }
+    if (!hasDataRef.current) setLoading(true);
     setError(null);
 
     // Route through buildProjectApiPath so the (URL-derived) projectId is encoded
@@ -62,10 +75,16 @@ export function useStoryboard(projectId: string | null): UseStoryboardResult {
         return res.json() as Promise<StoryboardResponse>;
       })
       .then((json) => {
-        if (!cancelled) setData(json);
+        if (cancelled) return;
+        hasDataRef.current = true;
+        setData(json);
       })
       .catch((err: unknown) => {
-        if (!cancelled) setError(err instanceof Error ? err.message : "failed to load storyboard");
+        if (cancelled) return;
+        // A failed background refresh keeps the last good board on screen;
+        // the blocking error state is only for loads with nothing to show.
+        if (hasDataRef.current) return;
+        setError(err instanceof Error ? err.message : "failed to load storyboard");
       })
       .finally(() => {
         if (!cancelled) setLoading(false);
diff --git a/skills-manifest.json b/skills-manifest.json
index 82e22e1c56..8c1e178d38 100644
--- a/skills-manifest.json
+++ b/skills-manifest.json
@@ -6,7 +6,7 @@
       "files": 144
     },
     "faceless-explainer": {
-      "hash": "09bc257e79dabebc",
+      "hash": "e92b2d69f90dc859",
       "files": 18
     },
     "figma": {
@@ -14,11 +14,11 @@
       "files": 2
     },
     "general-video": {
-      "hash": "67f3dae100541eed",
+      "hash": "a9fc26e52f6acabe",
       "files": 1
     },
     "hyperframes": {
-      "hash": "132596767485f923",
+      "hash": "47f82d8393592344",
       "files": 1
     },
     "hyperframes-animation": {
@@ -26,12 +26,12 @@
       "files": 99
     },
     "hyperframes-cli": {
-      "hash": "8ca3bef87f169ba1",
+      "hash": "3debfac5d7216214",
       "files": 7
     },
     "hyperframes-core": {
-      "hash": "511a6283a5dbd7ea",
-      "files": 14
+      "hash": "25fa15b7ec6b8ff1",
+      "files": 15
     },
     "hyperframes-creative": {
       "hash": "d60c84ddca9ea6db",
@@ -46,8 +46,8 @@
       "files": 10
     },
     "media-use": {
-      "hash": "f6f3af6648b1bd81",
-      "files": 122
+      "hash": "89d1719ed24ae7da",
+      "files": 128
     },
     "motion-graphics": {
       "hash": "0f1ac928e387a74c",
@@ -58,11 +58,11 @@
       "files": 132
     },
     "pr-to-video": {
-      "hash": "a93fde2b33b26e75",
+      "hash": "1f64a03c4dacf0f6",
       "files": 22
     },
     "product-launch-video": {
-      "hash": "14404973ef5d38a0",
+      "hash": "01acd1cb59d1dab7",
       "files": 20
     },
     "remotion-to-hyperframes": {
diff --git a/skills/faceless-explainer/SKILL.md b/skills/faceless-explainer/SKILL.md
index 2f965990e8..25c0781b78 100644
--- a/skills/faceless-explainer/SKILL.md
+++ b/skills/faceless-explainer/SKILL.md
@@ -31,7 +31,9 @@ Initialize only if `hyperframes.json` is missing. Name `<project>` from the topi
 
 **Confirm the brief** in two rounds — through the question UI when the environment has one, conversationally otherwise. The intro text states **message** (the explainer's thesis, in one sentence) and **language**. Skip a question only when the user's request already answered it. (`VO_MODE` is asked in Step 1 only when a script was pasted.)
 
-**Round 1 — mode.** One question, asked first. Skip it when the request already carried a signal ("surprise me" / "just build it"):
+**Check for a recipe first.** Before any question, run `node ../media-use/scripts/recipe.mjs list --hyperframes . --workflow faceless-explainer`. On a match (the user named one, said "like last time", or the list has one for this workflow), ask one question before the mode — one match: use recipe <name> (approved <date>)?; several: list them all and ask which one, or none. Adopting one answers the brief from the recipe — state those values as locked fields with "from recipe <name>" receipts, skip Step 2 (`recipe.mjs use` copies its frame.md in), and draft Step 3 from its storyboard skeleton. The mode question still follows, and the review gates still run — a recipe fills in answers, not approvals. Declined or no match: proceed to Round 1.
+
+**Round 1 — mode.** One question, asked first **and alone** — wait for the answer before any Round 2 question goes out; never bundle the brief questions into the same message. Skip it when the request already carried a signal ("surprise me" / "just build it"):
 
 - **Collaborative (recommended)** — confirm the key choices together before building.
 - **Autonomous** — every decision is made for the user, each stated with its reason; the only remaining question is preview-before-render.
@@ -44,9 +46,9 @@ Autonomous → ask nothing more. State the locked brief (all fields + receipts)
 - **Length — how long?** Recommend inside the 30–90s sweet spot, scaled to how much the text actually teaches, with its basis.
 - **Destination — where will it play?** YouTube / embed → 16:9 · X / LinkedIn / Instagram feed → 1:1 · Shorts / TikTok → 9:16.
 
-A "go" accepts all recommended defaults.
+Before asking, read the remembered defaults — brief contract § 2: a remembered value becomes the recommended option, its receipt naming the source project. A "go" accepts all recommended defaults.
 
-**Gate:** `hyperframes.json` exists, and the brief fields (angle, length, destination → aspect, message, language) are locked; sign-in status was shown (signed in, or continuing offline).
+**Gate:** `hyperframes.json` exists, and the brief fields (angle, length, destination → aspect, message, language) are locked; sign-in status was shown (signed in, or continuing offline); the confirmed answers were recorded as preferences (brief contract § 2).
 
 ---
 
@@ -81,7 +83,7 @@ The script does the rest deterministically: copies the preset's `FRAME.md` → `
 
 A faceless explainer usually has **no brand colors/fonts** (`tokens.json` colors/fonts empty) → the script keeps the preset's own palette, a complete shippable design. Only when the user named brand colors/fonts add them to `tokens.json` before running, and only adjust `frame.md` by hand afterward if a mapping truly needs it.
 
-**Gate:** `build-frame.mjs` exited 0 — `frame.md` exists from a named preset, and (when the preset ships one) `.hyperframes/caption-skin.html` exists as the caption skin source.
+**Gate:** `build-frame.mjs` exited 0 — `frame.md` exists from a named preset, and (when the preset ships one) `.hyperframes/caption-skin.html` exists as the caption skin source; the chosen preset was recorded as a preference (`--key style_preset --workflow <this workflow>`, brief contract § 2).
 
 ---
 
@@ -93,7 +95,7 @@ Read `../hyperframes-creative/references/story-spine.md` (hook language, value-b
 
 Use `story-design.md` for the explainer structure (concept / how-to / listicle / story), hook strategy, clarity techniques, emotional beats, the type-enum mapping, and `VO_MODE`. The video's sequence comes from **narrative design, not the input text's paragraph order** — reorder, merge, omit, compress. As a **soft guide**, consult the role→blueprint menu in `../hyperframes-animation/blueprints-index.md`: for each beat, write the voiceover in the shape its candidate blueprint implies and tag that candidate `blueprint:` id when one fits. Teaching truth still decides which beats exist — never force a beat to fit a blueprint, and never invent a beat just because a proven shape is available. Faceless visuals are invented downstream, so frames do **not** carry an asset inventory: leave `asset_candidates` empty unless the user supplied a real `public/<basename>` image. Use the exact required fields from the storyboard and script references.
 
-After drafting, present the plan as a proposal per story-spine § 3: open by echoing **"This video tells [audience] that [message]"**, then the frame table — one row per frame: frame · beat (type, duration) · on screen · why (its `narrativeRole`, traced to the message). In that same message ask the user two things: (a) to approve or request changes, and (b) whether they want a live preview of the storyboard scaffold (`npx hyperframes preview`) — open it only on a yes. Iterate until approved, and carry the preview choice to Step 6. This is a **checkpoint gate** (brief contract § 1): in autonomous mode, post the same summary as a heads-up and proceed — the preview question is asked once, at Step 6.
+After drafting, run the review loop's plan pass — `../hyperframes-core/references/review-loop.md` § 1: open the board (don't ask whether to), present the plan as a proposal, and ask the two questions — approve or change, and **sketches first** (recommended) or skip. Feedback loops through chat or the board's comments file until approved. This is a **checkpoint gate** (brief contract § 1): in autonomous mode there is no board and nothing to ask — post the same summary as a heads-up and proceed; sketches collapse into the build, and the one preview question comes at Step 6.
 
 **Gate:** `STORYBOARD.md` exists, every frame has the required narrative fields, `SCRIPT.md` exists when narration is needed, and the user approved the frame-by-frame plan (autonomous: the summary was posted as a heads-up).
 
@@ -105,7 +107,7 @@ Goal: Generate narration, word timings, music, and audio metadata from the appro
 
 Start audio after Step 3 approval. Run it in the background, then continue to Step 4. (Sign-in status was already shown in Step 0; the engine falls back automatically.)
 
-**Choose the narration voice from the user's ask before invoking.** If the request named a voice, gender, or tone, pick a matching voice id and pass it with `--voice <id>`. The pipeline default is otherwise **Marcia (female)** on HeyGen / `am_michael` on Kokoro — so a request like "a male voice" is silently ignored unless you pass the flag. Voice ids are provider-specific; resolve against whichever provider Step 0's sign-in status selected: **HeyGen** (signed in) via `node ../media-use/audio/scripts/heygen-tts.mjs --list` (or `GET /v3/voices?engine=starfish`); **Kokoro** (offline) via the voice table in `../media-use/audio/references/tts.md` (prefixes `am_`/`bm_` male, `af_`/`bf_` female). Omit `--voice` only when the user expressed no preference.
+**Choose the narration voice from the user's ask before invoking.** If the request named a voice, gender, or tone, pick a matching voice id and pass it with `--voice <id>`. The pipeline default is otherwise **Marcia (female)** on HeyGen / `am_michael` on Kokoro — so a request like "a male voice" is silently ignored unless you pass the flag. Voice ids are provider-specific; resolve against whichever provider Step 0's sign-in status selected: **HeyGen** (signed in) via `node ../media-use/audio/scripts/heygen-tts.mjs --list` (or `GET /v3/voices?engine=starfish`); **Kokoro** (offline) via the voice table in `../media-use/audio/references/tts.md` (prefixes `am_`/`bm_` male, `af_`/`bf_` female). When the user expressed no preference, fall back to the remembered voice (brief contract § 2) before the pipeline default, and say which one you used; omit `--voice` only when neither names one. When the user explicitly picked a voice this run, record it (`prefs.mjs record --key voice`).
 
 `node <SKILL_DIR>/scripts/audio.mjs --script ./SCRIPT.md --storyboard ./STORYBOARD.md --hyperframes . --out ./audio_meta.json --voice <voice-id> &`
 
@@ -121,6 +123,8 @@ If there is no narration and no `SCRIPT.md`, skip voice generation. BGM may stil
 
 Goal: Add the visual direction, layout intent, and motion choices to each storyboard frame.
 
+**Sketch the board first (collaborative only).** The moment the plan is approved, run the sketch pass — `../hyperframes-core/references/review-loop.md` § 2 (don't wait on Step 3.1; sketches don't use timings): wireframe every frame yourself, mark each `built`, pause for the one layout question when the board is full, and revise only the sketches named until the board is confirmed. Only then write the visual design below onto the confirmed layouts. In autonomous mode, or when the user chose to skip sketches at Step 3, skip this pass — frames go straight from `outline` to `animated` at Step 5.
+
 Edit `STORYBOARD.md` in place. Do not create another storyboard. Use `frame.md` as source of truth for color, type, layout feel, and style.
 
 Read `references/visual-design.md`, `../hyperframes-animation/blueprints-index.md`, `references/motion-language.md`, and `../hyperframes-animation/rules-index.md`. Use `visual-design.md` for the method (the time-coded shot sequence, the inline Layout vocabulary, and the invented-visual treatment), plus the required `## Video direction` block. Use `../hyperframes-animation/blueprints-index.md` to pick each frame's shot shape. Use `motion-language.md` (the motion vocabulary + the motion doctrine) and `../hyperframes-animation/rules-index.md` (valid rule names) for motion — do not invent motion names.
@@ -129,7 +133,7 @@ For every frame, write a **time-coded shot sequence** into `STORYBOARD.md` per `
 
 Do not change story, script, `transition_in`, or the source text. Do not write HTML in this step. There is **no asset-staging step** — faceless visuals are built by the workers in Step 5. If the user supplied a real `public/<basename>` image, reference it by path in the relevant frame's `focal`/`roles`; otherwise nothing to stage.
 
-**Gate:** every frame has a time-coded shot sequence whose reveals are paced to the voiceover (no front-loading); each frame names its invented `focal` and/or `roles`; `## Video direction` exists.
+**Gate:** every frame has a time-coded shot sequence whose reveals are paced to the voiceover (no front-loading); each frame names its invented `focal` and/or `roles`; `## Video direction` exists. Collaborative: the sketch board was confirmed.
 
 ---
 
@@ -147,7 +151,7 @@ Duration sync is mechanical: real voice duration wins; silent frames keep estima
 
 Before dispatch, read `sub-agents/frame-worker.md` and `../hyperframes-core/references/subagent-dispatch.md`. Dispatch one sub-agent per frame, in parallel if possible; otherwise run workers in waves. Each worker gets exactly one frame.
 
-Each worker context must include `PROJECT_DIR`, `frame_id`, canvas size, caption status and keep-out band if captions are enabled, and `RULES_DIR` as the absolute path to this skill's `../hyperframes-animation/rules/`. Each worker reads `frame.md`, its own `## Frame N` block from `STORYBOARD.md`, the local rule recipe (`../hyperframes-animation/rules/<id>.md`) for each cited motion, and the frame's blueprint template (`../hyperframes-animation/blueprints/<id>.md`). Each worker writes only `compositions/frames/NN-*.html`. Workers must never edit `STORYBOARD.md`.
+Each worker context must include `PROJECT_DIR`, `frame_id`, whether the frame has a **confirmed sketch** on disk, canvas size, caption status and keep-out band if captions are enabled, and `RULES_DIR` as the absolute path to this skill's `../hyperframes-animation/rules/`. Each worker reads `frame.md`, its own `## Frame N` block from `STORYBOARD.md`, the confirmed sketch when one exists (keep its layout — frame-worker § When a confirmed sketch exists), the local rule recipe (`../hyperframes-animation/rules/<id>.md`) for each cited motion, and the frame's blueprint template (`../hyperframes-animation/blueprints/<id>.md`). Each worker writes only `compositions/frames/NN-*.html`. Workers must never edit `STORYBOARD.md`.
 
 **Full-bleed backgrounds ride on a `class="clip"` layer, never the `#root`.** A frame's ground (color field / gradient / grid) is its own full-duration background clip — a `background` set on the `#root` / `data-composition-id` element is clip-gated to the frame's window and is not a dependable ground, so dark content can land on the black host `body` and render invisible. The video's base ground is painted by the assembler from `frame.md`'s `canvas` color onto the index `#root`. (Full rule + self-check: `sub-agents/frame-worker.md`.)
 
@@ -161,7 +165,7 @@ After audio timings exist, build captions in the background and assemble the ind
 
 `captions.mjs` uses the project's `.hyperframes/caption-skin.html` (copied in Step 2) as the caption look, injecting brand tokens from `frame.md`; with no skin present it renders the built-in default pill. `captions: skipped (<reason>)` is valid. Continue without captions when explicitly skipped.
 
-**Gate:** every frame is marked `animated`, `index.html` exists, and captions are built or explicitly skipped.
+**Gate:** every frame is marked `animated` (collaborative: the sketch board was confirmed at Step 4), `index.html` exists, and captions are built or explicitly skipped.
 
 ---
 
@@ -189,7 +193,7 @@ If a command fails, surface stderr and stop — don't pile on recovery commands.
 
 **Known false-positive — do not chase it.** `inspect` may report a handful of `text_box_overflow` errors of ~1–4px on the **caption** highlight words (selector `#caption-word-*` / `.caption-line`). The caption pill uses a deliberately snug `line-height` (set once in `scripts/captions.mjs`) and has **no `overflow:hidden`**, so a heavy display glyph's ink spills a few px into the pill's own padding — nothing is actually clipped. Treat these as expected and proceed. Do **not** inflate the caption `line-height` (it balloons the pill, which is worse). Only act on a `text_box_overflow` when it names a **frame** element (`#el-NN-*`), not a caption word.
 
-After checks pass, pause for user review. The video is assembled, viewable, and editable in Studio. Manage preview only once across Step 3 and Step 6: open it if the user asked earlier, offer it if they declined earlier, and do not ask again if they are already reviewing in Studio. In autonomous mode this is the one question the mode keeps: ask "preview first, or render?" — open the preview on yes, render on no — then deliver the MP4 with the contact sheet and the frame ids so revisions can target a single frame.
+After checks pass, pause for user review — the review loop's final look (`../hyperframes-core/references/review-loop.md` § 4): one question, on the Studio that has been open since Step 3 — render now, or what changes? (Autonomous: the one kept question, preview first or render.) Then deliver the MP4 with the contact sheet and the frame ids so revisions can target a single frame.
 
 Preview: `npx hyperframes preview`
 
diff --git a/skills/faceless-explainer/sub-agents/frame-worker.md b/skills/faceless-explainer/sub-agents/frame-worker.md
index 1528410b67..b9155942d3 100644
--- a/skills/faceless-explainer/sub-agents/frame-worker.md
+++ b/skills/faceless-explainer/sub-agents/frame-worker.md
@@ -25,6 +25,10 @@
 
 **OUTPUT** — `compositions/frames/<frame_id>.html`, one self-contained sub-composition. Writing it (past the self-check below) is your **terminal action** — you do not edit `STORYBOARD.md`, mint audio, assemble the index, run the CLI, or report back. The orchestrator picks up the file and marks the frame's `status`.
 
+## When a confirmed sketch exists
+
+In collaborative runs the orchestrator wireframes the board first, so your target file may already exist as the frame's **user-confirmed wireframe** — your dispatch says whether it does (a file found on a retry is your own prior output, not a sketch). Read it first and **keep its composition**: the placement, hierarchy, and copy were approved — don't move or drop them. Everything else is yours to finish: the full `frame.md` treatment (the sketch is deliberately unstyled), the finished invented visuals where the sketch used plain blocks, and the motion — map each Scene onto a timeline phase, reveal each piece on its `voiceover` cue with `fromTo` entrances, adding DOM only where a phase needs it. The frame's landed state must still read as the approved wireframe, fully dressed.
+
 ## You do NOT decide
 
 These belong to other steps — touching them collides with a sibling or breaks an upstream contract:
diff --git a/skills/general-video/SKILL.md b/skills/general-video/SKILL.md
index 9b4abe8165..65517518f1 100644
--- a/skills/general-video/SKILL.md
+++ b/skills/general-video/SKILL.md
@@ -24,7 +24,7 @@ metadata: { "tags": "orchestrator, general-video, fallback, freeform, compositio
 
 ### Discovery — open-ended requests only
 
-For vague, exploratory requests ("make something for our brand", "a cool intro") — understand intent before picking colors:
+For vague, exploratory requests ("make something for our brand", "a cool intro") — understand intent before picking colors. Read the remembered defaults first (`hyperframes-core/references/brief-contract.md` § 2, Remembered defaults): a remembered destination or audience becomes the recommended answer, its receipt naming the source project. A named recipe goes further — "like last time" or a recipe name: `media-use` → `scripts/recipe.mjs use` fills design, structure, and brief from the frozen bundle (confirm with one question first).
 
 - **Audience** — who watches? developers / executives / general consumers?
 - **Platform** — where does it play? social (15s) / website hero / product demo / internal?
@@ -64,6 +64,8 @@ Before writing HTML, think at a high level:
 5. **Layout** — build the end state first (see below).
 6. **Animate** — then add motion via `hyperframes-animation`.
 
+**Plan on a board when there's a story to review.** For a multi-scene narrative piece in collaborative mode — or whenever the user asks for a storyboard — don't keep the plan in your head: write it as `STORYBOARD.md` (`hyperframes-core/references/storyboard-format.md`; one `## Frame N` per scene, `status: outline`, a declared `src`) and run the review loop (`hyperframes-core/references/review-loop.md`): the board opens itself, the plan is presented as a proposal, wireframe sketches are offered before the full build, and each scene is marked `built` as its sketch lands and `animated` as you finish it. The sketch pass is this skill's layout-before-animation with the user watching — the confirmed wireframe **is** the end state you then animate. Single-scene pieces, trivial edits, and autonomous runs skip the board and plan inline as above.
+
 ## Layout Before Animation
 
 Position every element where it sits at its **most visible moment** — fully entered, correctly placed, not yet exiting. Write that as static HTML + CSS first. **No GSAP yet.**
diff --git a/skills/hyperframes-cli/references/preview-render.md b/skills/hyperframes-cli/references/preview-render.md
index 212910fcef..3833d5db8f 100644
--- a/skills/hyperframes-cli/references/preview-render.md
+++ b/skills/hyperframes-cli/references/preview-render.md
@@ -21,6 +21,10 @@ http://localhost:<port>/#project/<project-name>
 
 Use the actual port and project directory name; treat `index.html` as source-code context, not the preview surface. For example, after `npx hyperframes preview --port 3017` in `codex-openai-video`, report `http://localhost:3017/#project/codex-openai-video`.
 
+To land the user on the **Storyboard view** instead of the timeline, put `?view=storyboard` ahead of the hash: `http://localhost:<port>/?view=storyboard#project/<project-name>`. Hand this URL whenever the storyboard is the thing to review and nothing is assembled yet — before `index.html` exists, the timeline stage has nothing to show, so the bare project URL opens on an empty player.
+
+Two ways a handed URL turns out dead — check both before handing it back: the URL is missing its `#project/<project-name>` hash (Studio loads but has no project to open), or the server is not actually running. `preview` is a long-running process — start it from the project directory as a background task, and if that task reports it exited ("completed"), the server is down: restart it, don't hand out the link.
+
 ### Agent context from Studio selection
 
 `preview --context` and `preview --selection` are the agent bridge into a running Studio session. They do **not** start a new server; they find the active preview server for the current project, read agent-useful state from Studio, print it, and exit.
diff --git a/skills/hyperframes-core/SKILL.md b/skills/hyperframes-core/SKILL.md
index 9df077c6d5..3e8e333572 100644
--- a/skills/hyperframes-core/SKILL.md
+++ b/skills/hyperframes-core/SKILL.md
@@ -22,6 +22,7 @@ This skill is the **technical contract** — how to build one hyperframes projec
 | `references/determinism-rules.md`    | build a seekable timeline; determinism bans; the animatable-property allowlist; layout / text fit                       |
 | `references/full-screen-motion.md`   | author full-frame motion with shared backgrounds                                                                        |
 | `references/storyboard-format.md`    | author a `STORYBOARD.md` plan (+ the parsed manifest)                                                                   |
+| `references/review-loop.md`          | run the plan → sketch → build review passes on a live board — shared by every storyboard-planning workflow              |
 | `references/brief-contract.md`       | conduct a creation workflow's intake — interaction mode (collaborative / autonomous), shared brief fields, asking rules |
 | `references/script-format.md`        | author the optional `SCRIPT.md` locked narration                                                                        |
 | `references/subagent-dispatch.md`    | map subagent dispatch verbs (parallel fan-out / background / wait) to your harness                                      |
diff --git a/skills/hyperframes-core/references/brief-contract.md b/skills/hyperframes-core/references/brief-contract.md
index 5707bc2421..5b2d6cf52b 100644
--- a/skills/hyperframes-core/references/brief-contract.md
+++ b/skills/hyperframes-core/references/brief-contract.md
@@ -20,6 +20,8 @@ There are two modes. Default: **collaborative**.
 3. **Quality gates** (`lint` / `validate` / `inspect`, capture completeness, fetch failures, workflow-specific verification checklists) — never skip these in any mode. Errors still stop the run. Reasoning like "autonomous means bias toward action, so I'll skip verification" misuses the mode — bias toward action applies to deciding _what to build_, not _whether to verify_.
 4. **Routing and sign-in decisions** — wrong routing is a quality problem: an ambiguous-intent confirmation, such as `/slideshow`'s "is this a deck?", still happens in autonomous mode. Auth sign-in follows `/media-use` → Preflight: show the status as-is; collaborative waits for the user's choice, while autonomous notes it and continues offline.
 
+**The comments channel.** At any checkpoint gate, feedback arrives two ways and means one thing: chat, or — when the user is reviewing in Studio — a comments file at `.hyperframes/frame-comments.json` (shape: `storyboard-format.md` § Frame comments). Either way: revise exactly the frames named, delete the file once handled, re-present. Feedback on one frame never widens into rebuilding frames nobody named. A board submit is **silent** — nothing notifies the agent — so when handing the board, say that one reply here (anything, even "done") picks the comments up, and when a checkpoint reply arrives, **check the file before the words**.
+
 **Autonomous is not silent.** Every question absorbed by the mode becomes a decision with a receipt — state the choice and its one-line reason inline as you go. Final delivery always includes the contact sheet, so review happens after the fact instead of not happening at all.
 
 ## 2. Field registry
@@ -38,11 +40,15 @@ The shared brief fields. Each workflow's SKILL.md declares which fields it uses,
 | `angle`       | what kind of story (workflow enum)                                    | workflow-specific values; recommend one with a receipt                                                                                                                                                                           |
 | `narration`   | yes / minimal / no (+ workflow slots such as `VO_MODE`)               | workflow-specific                                                                                                                                                                                                                |
 
+**Remembered defaults.** Confirmed answers are memory. `media-use` keeps them in two tiers — the project's `.media/preferences.json` (committed, so the whole team inherits it) and the personal `~/.media/preferences.json` (a value earns the personal tier by being confirmed in two different projects). Before Round 2, read the merged view — `media-use` → `scripts/prefs.mjs get` — and let a remembered value become the recommended option, with a receipt that names its source: "1:1 — you confirmed this in world-cup-explained". Memory changes the default, never the question: every ask-marked field still gets asked, and what the request says this time always beats what the user picked last time. In autonomous mode a remembered value becomes the decided value, receipt included, in the heads-up.
+
+Record only what the user actually confirmed. After the brief gate locks, `prefs.mjs record` each ask-marked answer; after the design step, the chosen preset (`--key style_preset --workflow <w>`); the voice only when the user explicitly picked one — a default nobody chose is not an answer. A "go" that accepts the recommended defaults counts as confirmation: the user saw them and let them stand. The first time a project records anything, say so in the gate's confirmation — one line, "I'll remember these as your defaults — next time they're the recommended answers" — and never repeat it; from then on the receipts carry the reminder. `mode` is remembered like any other field, but memory only reorders Round 1's options — Round 1 itself is never skipped by a remembered mode (§ 3).
+
 ## 3. Question rules
 
 The executable question script lives in each workflow's Step 0 as a literal two-round template. This section defines only the invariants that script satisfies:
 
-- **Round 1 asks the mode** — one question, skipped when the request already carried a signal. Autonomous → no further questions: state the locked brief (all fields + receipts) as a heads-up and build straight through; the one remaining question, before render, is "preview first, or render?". Collaborative → Round 2.
+- **Round 1 asks the mode** — one question, sent **alone**: wait for the answer before any Round 2 question goes out, and never bundle field questions into the same message (a field question hedged "only if collaborative" is the tell that the rounds got merged). Skipped when the request already carried a signal. Autonomous → no further questions: state the locked brief (all fields + receipts) as a heads-up and build straight through; the one remaining question, before render, is "preview first, or render?". Collaborative → Round 2.
 - **Round 2 asks the workflow's ask-marked fields** — one question per field, recommended option first, each with its receipt. Skip a question only when the user already answered that field in their request; inference is not an answer.
 - **Receipts.** Every recommended option states its basis — "~40s — small change, +44/−13 across 12 files"; "square 1:1 — you named the X/LinkedIn feed as the destination".
 - **Channel.** Native question UI when the environment has one; otherwise plain text as one numbered list. "go" accepts all defaults.
diff --git a/skills/hyperframes-core/references/review-loop.md b/skills/hyperframes-core/references/review-loop.md
new file mode 100644
index 0000000000..9eac2abb8b
--- /dev/null
+++ b/skills/hyperframes-core/references/review-loop.md
@@ -0,0 +1,41 @@
+# The review loop — plan, sketch, build
+
+How a collaborative run earns fidelity one pass at a time: the plan is reviewed as text on a live board, the layouts as wireframe sketches, and the finished piece as the assembled video — each pass gated on the user before the next one spends more. Autonomous runs skip every gate here and keep exactly one question, right before render.
+
+This is the shared process for any workflow that plans on a storyboard. The contracts it leans on live next door: interaction mode, gate types, and the comments channel in `brief-contract.md`; the `STORYBOARD.md` format, the `outline → built → animated` statuses, and the comments sidecar in `storyboard-format.md`. A workflow's SKILL.md says **when** its steps hit each pass and supplies its **sketch stand-ins** (what the plain blocks represent); how the loop runs is defined here, once.
+
+## § 1 — The plan, on a live board
+
+Open the board before presenting the plan — collaborative review happens on a live board, so don't ask whether to open it: run `npx hyperframes preview` from the project directory in the background, confirm it is serving, and open the Storyboard view — `http://localhost:<port>/?view=storyboard#project/<project-name>`. The plan shows there as frame cards, and the board refreshes itself as work lands — no reload instructions needed.
+
+Present the plan as a proposal (shape: `hyperframes-creative/references/story-spine.md` § 3): open by echoing **"This video tells [audience] that [message]"**, then the frame table — one row per frame: frame · beat (type, duration) · on screen · why (its `narrativeRole`, traced to the message). Hand the board URL with it, noting feedback lands in both places — comment on the board or reply here, one revision loop — and that a board submit still needs one reply here (anything) to get picked up.
+
+In the same message ask two things: **(a)** approve or request changes, and **(b)** **sketches first** (recommended — a quick wireframe look check right after this approval) or skip sketches and build in one go. Iterate until approved — feedback arrives in chat or as the comments file (`brief-contract.md` § 1, the comments channel): revise exactly the frames it names, clear the file, re-present.
+
+This is a **checkpoint gate** (`brief-contract.md` § 1). In autonomous mode there is no board and nothing to ask — post the same summary as a heads-up and proceed; sketches collapse into the build, and the loop's one kept question comes at § 4.
+
+## § 2 — The sketch pass (collaborative, unless skipped)
+
+The moment the plan is approved, wireframe every frame yourself — no sub-agents, no waiting on other steps (sketches don't use timings), straight from the approved frame table.
+
+A sketch is a **wireframe with the real words, not a styled frame**: the frame's layout at its key moment — the actual headline / stat / label text placed where it will live, plain blocks for panels, charts, diagrams, and media (the workflow says what its blocks stand in for), `frame.md`'s background and ink plus one accent on the focal, nothing else. No decoration, no full brand treatment, **no motion** — all of that arrives with the build pass.
+
+Keep each sketch a real composition file at `compositions/frames/NN-*.html` (template wrapper, `data-composition-id`, `#root` styling, one paused **empty** timeline registered at `window.__timelines["<frame_id>"]`) so the Studio poster renders — and the poster is the only picture this pass needs: **run no CLI here** — no `snapshot`, no `lint` / `validate`, no rendering. A sketch is a few dozen lines of HTML; the whole board lands in minutes.
+
+Mark each frame `built` as its sketch lands — the user's open board fills in blue by itself. When every frame is `built`, pause and ask one thing: does the board look right, or which frames change? This is a **checkpoint gate**; the user reviews in Studio (open since § 1 — restart and re-hand the same URL if the server died), and feedback arrives in chat or as the comments file — check the file first when the reply arrives: revise **only the sketches named**, re-present, and loop until the layout is confirmed. Only then does the workflow's visual design get written onto the confirmed layouts.
+
+A confirmed board is also a valid place to **stop**. When the user asked for a storyboard rather than a finished video — a plan to pitch, review, or hand off — the sketched board is the deliverable: confirm it, hand the board URL, and go no further unless asked to build.
+
+In autonomous mode, or when the user chose to skip sketches at § 1, skip this pass — frames go straight from `outline` to `animated` in the build.
+
+## § 3 — Building on confirmed layouts
+
+However the workflow builds — sub-agent workers per frame, or inline scene by scene — a confirmed sketch's **composition is settled**: placement, hierarchy, and copy were approved on the board, so building means dressing that layout (full design treatment, real assets, motion), never redrawing it. Workflows that dispatch workers put "this frame has a **confirmed sketch** on disk" in the worker's context and carry the keep-the-layout rule in their worker prompt; a landed frame must still read as the approved wireframe, fully dressed.
+
+Mark each frame `animated` as it lands. The build gate carries the loop's condition: in collaborative mode, the sketch board was confirmed at § 2.
+
+## § 4 — The final look
+
+After the workflow's checks pass, pause for the user. In collaborative mode Studio has been open since § 1 — do not ask about previews; hand the project URL again (the timeline view now holds the assembled video) and ask one thing: render now, or what changes? In autonomous mode this is the one question the mode keeps: ask "preview first, or render?" — open the preview on yes, render on no. Render only on approval.
+
+**After approval, offer the recipe — once.** An approved run is a proven bundle. At delivery, offer to freeze it: `media-use` → `scripts/recipe.mjs freeze --name <name> --workflow <workflow>` keeps the design spec, the storyboard skeleton (structure kept, content blanked), and the confirmed brief values, and the next run of this type starts from it (each workflow's Step 0 checks for a matching recipe). When the freeze lands, teach the recall in the confirmation — "Saved as **<name>** (v<N>). Next time say _make another <name>_, or just _like last time_." — the name is something the system reminds the user of, never something they must remember. In autonomous mode don't ask — name the freeze command in the delivery note instead.
diff --git a/skills/hyperframes-core/references/storyboard-format.md b/skills/hyperframes-core/references/storyboard-format.md
index b69d50f920..a1d5fadef0 100644
--- a/skills/hyperframes-core/references/storyboard-format.md
+++ b/skills/hyperframes-core/references/storyboard-format.md
@@ -56,6 +56,35 @@ The read API also adds `srcExists` per frame and attaches the optional `SCRIPT.m
 
 Optional, free-form, **not parsed into the manifest** — the locked-narration file that drives TTS. Its format is defined in `references/script-format.md`, and it is absent for videos with no narration/TTS. The per-frame `voiceover` above is the storyboard's own narration guide.
 
+## Frame comments — `.hyperframes/frame-comments.json`
+
+The storyboard review's **structured feedback channel** — the file Studio's per-frame comment boxes write on submit (chat feedback follows the same rule — `brief-contract.md` § 1, the comments channel). Like `SCRIPT.md`, it is a sibling of the storyboard, not parsed into the manifest.
+
+```json
+{
+  "version": 1,
+  "pass": "sketch",
+  "submitted_at": "2026-07-09T12:04:00Z",
+  "comments": [
+    {
+      "frame": 3,
+      "src": "compositions/frames/03-mechanism.html",
+      "title": "Mechanism",
+      "text": "Swap the bar chart for a before/after slider."
+    }
+  ]
+}
+```
+
+| Field                    | Meaning                                                                                                             |
+| ------------------------ | ------------------------------------------------------------------------------------------------------------------- |
+| `pass`                   | which review the batch belongs to: `storyboard` (text layer) / `sketch` (static frames) / `final` (assembled video) |
+| `comments[].frame`       | the frame's 1-based `index` in the manifest — the key                                                               |
+| `comments[].src` `title` | copied from the frame at submit time — if frames get reordered after submit, the mismatch shows                     |
+| `comments[].text`        | the feedback, verbatim                                                                                              |
+
+Lifecycle — the whole contract: a workflow finding this file at a checkpoint treats it as the revision feedback — **revise exactly the frames named, delete the file, re-present**. Writers create it only on submit; it never lingers across rounds.
+
 ## Example
 
 ```markdown
@@ -93,4 +122,6 @@ The old way: prompt, wait, get something that misses. Establish the pain we remo
 ## Notes
 
 - A frame with `status: outline` and no built `src` renders as an outline placeholder.
+- `built` is the middle rung: the frame's HTML exists and its **layout is confirmed** (a wireframe sketch or better) — motion not yet added. Studio chips it blue.
+- The process that walks these statuses — plan, sketch, build, each pass reviewed on the board — is `review-loop.md`.
 - Multi-line `voiceover` values collapse to one line on save.
diff --git a/skills/hyperframes/SKILL.md b/skills/hyperframes/SKILL.md
index 680c3a848f..028c1890ea 100644
--- a/skills/hyperframes/SKILL.md
+++ b/skills/hyperframes/SKILL.md
@@ -47,8 +47,11 @@ This section knows only the top-level workflows; it does not load their internal
 Routing needs to know **what the video is about** — its input and subject. If that's unspecified ("make a video about our thing" with no URL, product, topic, or asset), ask before entering any workflow — committing to a workflow IS the routing decision. At most two questions:
 
 - **Input** — a product (URL / brief), a general website, a GitHub PR, a topic to explain, or an existing talking-head video?
+- **A saved recipe named?** "use the weekly-changelog recipe" / "like last time" — recipes carry their workflow: `media-use` → `scripts/recipe.mjs list` shows what exists, and a match routes to its workflow with the recipe adopted at Step 0.
 - **Figma source** — if the input is a figma.com URL, `/figma` extracts assets/tokens/(components/storyboard) first, regardless of which workflow below is chosen for the video's shape; that workflow then builds from `/figma`'s output — never by driving Figma via raw MCP tools directly (skips SVG sanitization, provenance, and brand-token binding).
 
+When the request is genuinely exploratory — the user doesn't yet know what they want ("we need a video but I'm not sure what kind", "help me figure this out") — don't interrogate: ask one question at a time (the message first, then audience, then what exists to show), and close by **recommending** a route plus how the run will review — a text storyboard first, on a live board, with optional wireframe sketches before the full build (`hyperframes-core/references/review-loop.md`). The user hears the process before any workflow starts. A clear request skips all of this and routes directly.
+
 **Mode** — if the request carries an ongoing autonomous signal ("surprise me", "decide for me", "just build it"), note it and pass it into the workflow: the whole run goes autonomous and no later step re-asks. With no signal, the workflow asks the mode as its first brief question. Default is collaborative. (`/motion-graphics` is autonomous by design.) Semantics: `hyperframes-core` → `references/brief-contract.md`.
 
 **Spec defaults — state, don't ask** (they never change the route): **aspect** derives from the destination — social feed (X / LinkedIn / Instagram) → square **1:1**, TikTok / Reels / Shorts → **9:16**, YouTube / embed / unknown → **16:9**; narration / caption **language** = the user's. The chosen workflow re-confirms its own specifics at its first step (field semantics: `hyperframes-core` → `references/brief-contract.md`).
@@ -76,6 +79,7 @@ Routing needs to know **what the video is about** — its input and subject. If
 - **Existing footage** — plain spoken-word subtitles → `/embedded-captions`; designed overlay cards → `/talking-head-recut`. Neither edits the footage itself (re-timing / recolor / reframe / reorder / audio is NLE editing — out of scope).
 - **A music track is the input** (an audio file, or a video to pull audio from) with **no narration** → `/music-to-video` — the music's beats/energy drive the pacing. (Narrated pieces stay with the input-matched workflow above; `/motion-graphics` is for short unnarrated motion that isn't music-driven.)
 - **A presentation / pitch deck / interactive deck** (discrete slides, navigation, presenter mode) → `/slideshow` — output is a navigable deck, not a rendered video. An explicit "slideshow" request proceeds directly; an adjacent trigger ("deck / slides / presentation / convert this page") makes `/slideshow` confirm it's a slideshow before authoring, and switch to the appropriate non-slideshow workflow if not.
+- **"I want a storyboard" is a process request, not a route** — it selects the review loop (`hyperframes-core/references/review-loop.md`: the plan on a live board, wireframe sketches, then the build), run collaboratively inside whichever workflow the input picks; with no clearer input, `/general-video` plans on the board. The deliverable may be just the confirmed board — the loop says where to stop.
 - **Length is a guide, not a gate** — intent picks the workflow; go to `/general-video` only when the piece is clearly longer than ~3 min, or is a static / loop / custom format.
 
 ## After picking — guarantee the workflow is installed
diff --git a/skills/media-use/SKILL.md b/skills/media-use/SKILL.md
index 5d2066103d..70b63a1565 100644
--- a/skills/media-use/SKILL.md
+++ b/skills/media-use/SKILL.md
@@ -318,6 +318,30 @@ Assets are cached automatically on resolve. Every resolved/ingested asset is aut
 
 For a _semantically_ similar (not identical) need in another project, the exact-match floor won't fire — use [Reuse before you resolve](#reuse-before-you-resolve): `--candidates` lists the global assets, and `--reuse <sha>` imports the one you pick. This is how a track resolved in one project gets reused in the next when the wording differs.
 
+## Preferences — remembered defaults
+
+The lightweight tier of user memory: confirmed brief answers (destination, aspect, language, mode, voice, style preset) persisted on the same two-tier split as assets — project `.media/preferences.json` (committed, the team inherits it) and personal `~/.media/preferences.json`. A value earns the personal tier by being confirmed in **two different projects**, so a one-off choice never pollutes the global defaults.
+
+```bash
+node <SKILL_DIR>/scripts/prefs.mjs get --hyperframes . --json      # merged view (project overrides user)
+node <SKILL_DIR>/scripts/prefs.mjs record --hyperframes . --key destination --value x-feed
+node <SKILL_DIR>/scripts/prefs.mjs record --hyperframes . --key style_preset --value pin-and-paper --workflow faceless-explainer
+```
+
+Only what the user actually confirmed gets recorded — never an inferred or defaulted value. How workflows consume these (a remembered value becomes the recommended default with a receipt, and never skips a question) is the brief contract's rule: `hyperframes-core/references/brief-contract.md` § 2, Remembered defaults.
+
+## Recipes — frozen video bundles
+
+The heavyweight tier of user memory: one approved run frozen as a named, versioned bundle — `frame.md`, the storyboard skeleton (structure kept, content blanked to per-frame fill-ins), and the confirmed brief values. Same two tiers: project `.media/recipes/<name>/` (committed) and `~/.media/recipes/<name>/` (a freeze is already a confirmed bundle, so it promotes immediately — no two-project rule). Re-freezing a name bumps `version` and archives the old folder as `<name>@v<N>`.
+
+```bash
+node <SKILL_DIR>/scripts/recipe.mjs freeze --hyperframes . --name weekly-promo --workflow product-launch-video
+node <SKILL_DIR>/scripts/recipe.mjs list --hyperframes . --workflow product-launch-video
+node <SKILL_DIR>/scripts/recipe.mjs use --hyperframes . --name weekly-promo   # also: resolve.mjs --type recipe --entity weekly-promo
+```
+
+Workflows offer the freeze once after the final approval (`hyperframes-core/references/review-loop.md` § 4) and check for a match at Step 0. Adopting a recipe fills the brief, the design spec, and the storyboard skeleton — and unlike preferences it may skip the questions it answers: the bundle was approved as a whole, and adoption itself is the question.
+
 ## Usage stats
 
 Use `resolve --stats` for a local, shareable report over the current project's `.media/` manifest, the global `~/.media/` cache, and local resolve misses. Human output is compact; add `--json` for a single machine-readable object, and `--days N` to window timestamped records.
@@ -334,7 +358,11 @@ node <SKILL_DIR>/scripts/resolve.mjs --stats --project . --days 7
 
 - `.media/manifest.jsonl`: machine SSOT, one JSON record per line
 - `.media/index.md`: agent-readable table (id, type, dur, dims, path, description)
+- `.media/preferences.json`: the project's remembered defaults (committed)
 - `~/.media/`: global cross-project reuse cache (content-addressed, SHA-256)
+- `~/.media/preferences.json`: personal remembered defaults (promoted after two projects)
+- `.media/recipes/<name>/`: frozen video bundles — recipe.json + frame.md + storyboard skeleton (committed)
+- `~/.media/recipes/<name>/`: personal recipe tier (promoted on freeze)
 - `~/.media/misses.jsonl`: local-only resolve misses, including intent text for `--stats`
 
 ## Audio engine: voiceover, music, SFX, captions, transcription
diff --git a/skills/media-use/scripts/lib/manifest.mjs b/skills/media-use/scripts/lib/manifest.mjs
index f5aea62b54..296b1cd5a2 100644
--- a/skills/media-use/scripts/lib/manifest.mjs
+++ b/skills/media-use/scripts/lib/manifest.mjs
@@ -26,6 +26,7 @@ const TYPE_DIRS = {
   video: "video",
   grade: "luts",
   lut: "luts",
+  recipe: "recipes",
 };
 
 export function mediaDir(projectDir) {
diff --git a/skills/media-use/scripts/lib/prefs-store.mjs b/skills/media-use/scripts/lib/prefs-store.mjs
new file mode 100644
index 0000000000..b28f34e8d0
--- /dev/null
+++ b/skills/media-use/scripts/lib/prefs-store.mjs
@@ -0,0 +1,176 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+
+/**
+ * Remembered defaults — the lightweight tier of HyperFrames user memory.
+ *
+ * Two files, same shape as the rest of media-use's storage split:
+ * - project `.media/preferences.json` — committed with the repo, so the whole
+ *   team inherits it; written every time a brief answer is confirmed.
+ * - user `~/.media/preferences.json` — personal, cross-repo. A key is promoted
+ *   here only once the same value has been confirmed in two different projects
+ *   (`PROMOTE_AT`), so a one-off choice never pollutes the global defaults.
+ *   Pre-promotion evidence accumulates in the user file's `sightings` ledger —
+ *   project files can't see each other, so the cross-project count has to live
+ *   user-side.
+ *
+ * Consumption contract (brief-contract § 2, Remembered defaults): a remembered
+ * value becomes the recommended option with a receipt naming its source — it
+ * never skips a question, and explicit request content always wins.
+ */
+
+const PREFS_FILE = "preferences.json";
+
+/** Keys the brief contract records; `style_preset` is stored per workflow. */
+export const PREFERENCE_KEYS = [
+  "destination",
+  "aspect",
+  "language",
+  "mode",
+  "voice",
+  "style_preset",
+];
+
+/** A value must be confirmed in this many distinct projects to go user-tier. */
+export const PROMOTE_AT = 2;
+
+export function projectPrefsPath(projectDir) {
+  return join(resolve(projectDir), ".media", PREFS_FILE);
+}
+
+export function userPrefsPath() {
+  return join(homedir(), ".media", PREFS_FILE);
+}
+
+function emptyFile() {
+  return { version: 1, preferences: {}, sightings: {} };
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Tolerant read — a missing or malformed file counts as empty. */
+function readPrefsFile(path) {
+  try {
+    if (!existsSync(path)) return emptyFile();
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!isRecord(parsed)) return emptyFile();
+    return {
+      version: 1,
+      preferences: isRecord(parsed.preferences) ? parsed.preferences : {},
+      sightings: isRecord(parsed.sightings) ? parsed.sightings : {},
+    };
+  } catch {
+    return emptyFile();
+  }
+}
+
+/** Atomic write (tmp + rename) so a crash never leaves a torn file. */
+function writePrefsFile(path, file) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(file, null, 2)}\n`);
+  renameSync(tmp, path);
+}
+
+/** `style_preset` entries are stored per workflow as `style_preset.<workflow>`. */
+export function preferenceKeyFor(key, workflow) {
+  return key === "style_preset" && workflow ? `style_preset.${workflow}` : key;
+}
+
+function validEntry(entry) {
+  return isRecord(entry) && typeof entry.value === "string" && entry.value.length > 0;
+}
+
+/**
+ * The merged view the brief reads: user-tier promoted entries first, project
+ * entries on top (project wins). Each entry carries `source` plus the receipt
+ * material (`confirmed_in`, `updated_at`).
+ */
+export function mergedPreferences(projectDir) {
+  const user = readPrefsFile(userPrefsPath());
+  const project = readPrefsFile(projectPrefsPath(projectDir));
+  const merged = {};
+  for (const [key, entry] of Object.entries(user.preferences)) {
+    if (validEntry(entry)) merged[key] = { ...entry, source: "user" };
+  }
+  for (const [key, entry] of Object.entries(project.preferences)) {
+    if (validEntry(entry)) merged[key] = { ...entry, source: "project" };
+  }
+  return merged;
+}
+
+function dedupe(list) {
+  return [...new Set(list)];
+}
+
+/**
+ * Project tier: same value accumulates confirmations; a changed value starts
+ * provenance over (the old confirmations vouched for the old value).
+ */
+function recordProjectTier(projectDir, fullKey, value, projectName, now) {
+  const path = projectPrefsPath(projectDir);
+  const file = readPrefsFile(path);
+  const previous = file.preferences[fullKey];
+  const keepProvenance = validEntry(previous) && previous.value === value;
+  const confirmedIn = keepProvenance
+    ? dedupe([...(Array.isArray(previous.confirmed_in) ? previous.confirmed_in : []), projectName])
+    : [projectName];
+  file.preferences[fullKey] = { value, confirmed_in: confirmedIn, updated_at: now };
+  writePrefsFile(path, file);
+  return confirmedIn;
+}
+
+/**
+ * User tier: accumulate this sighting in the ledger, and promote the key once
+ * the same value has been confirmed in PROMOTE_AT distinct projects.
+ */
+function recordUserSighting(fullKey, value, projectName, now) {
+  const path = userPrefsPath();
+  const file = readPrefsFile(path);
+  const keySightings = isRecord(file.sightings[fullKey]) ? file.sightings[fullKey] : {};
+  const seenIn = dedupe([
+    ...(Array.isArray(keySightings[value]) ? keySightings[value] : []),
+    projectName,
+  ]);
+  keySightings[value] = seenIn;
+  file.sightings[fullKey] = keySightings;
+  const promoted = seenIn.length >= PROMOTE_AT;
+  if (promoted) {
+    file.preferences[fullKey] = { value, confirmed_in: seenIn, updated_at: now };
+  }
+  writePrefsFile(path, file);
+  return promoted;
+}
+
+/**
+ * Record one confirmed brief answer. Always writes the project tier; feeds the
+ * user tier's sightings ledger and promotes once the same value has been
+ * confirmed in PROMOTE_AT distinct projects. Idempotent per project.
+ */
+export function recordPreference({ projectDir, key, value, workflow }) {
+  if (!PREFERENCE_KEYS.includes(key)) {
+    throw new Error(`unknown preference key: "${key}" (known: ${PREFERENCE_KEYS.join(", ")})`);
+  }
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("a preference needs a non-empty string value");
+  }
+  const fullKey = preferenceKeyFor(key, workflow);
+  const projectName = basename(resolve(projectDir));
+  const trimmed = value.trim();
+  const now = new Date().toISOString();
+
+  const confirmedIn = recordProjectTier(projectDir, fullKey, trimmed, projectName, now);
+
+  // Best-effort — a read-only home directory must never fail a brief.
+  let promoted = false;
+  try {
+    promoted = recordUserSighting(fullKey, trimmed, projectName, now);
+  } catch {
+    // The project record already landed; promotion just waits for next time.
+  }
+
+  return { key: fullKey, value: trimmed, confirmed_in: confirmedIn, promoted };
+}
diff --git a/skills/media-use/scripts/lib/prefs-store.test.mjs b/skills/media-use/scripts/lib/prefs-store.test.mjs
new file mode 100644
index 0000000000..ef83cbd91b
--- /dev/null
+++ b/skills/media-use/scripts/lib/prefs-store.test.mjs
@@ -0,0 +1,157 @@
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  mergedPreferences,
+  preferenceKeyFor,
+  projectPrefsPath,
+  recordPreference,
+  userPrefsPath,
+} from "./prefs-store.mjs";
+
+function sandbox() {
+  const root = mkdtempSync(join(tmpdir(), "mu-prefs-"));
+  const home = join(root, "home");
+  const projectA = join(root, "proj-a");
+  const projectB = join(root, "proj-b");
+  mkdirSync(home, { recursive: true });
+  mkdirSync(projectA, { recursive: true });
+  mkdirSync(projectB, { recursive: true });
+  process.env.HOME = home;
+  return { root, home, projectA, projectB };
+}
+
+function restoreEnv(saved) {
+  for (const k of Object.keys(process.env)) if (!(k in saved)) delete process.env[k];
+  Object.assign(process.env, saved);
+}
+
+function withSandbox(fn) {
+  const savedEnv = { ...process.env };
+  const box = sandbox();
+  try {
+    fn(box);
+  } finally {
+    restoreEnv(savedEnv);
+    rmSync(box.root, { recursive: true, force: true });
+  }
+}
+
+test("record writes the project tier and get merges it as source=project", () => {
+  withSandbox(({ projectA }) => {
+    const result = recordPreference({ projectDir: projectA, key: "destination", value: "x-feed" });
+    assert.equal(result.promoted, false);
+    assert.deepEqual(result.confirmed_in, ["proj-a"]);
+
+    const merged = mergedPreferences(projectA);
+    assert.equal(merged.destination.value, "x-feed");
+    assert.equal(merged.destination.source, "project");
+
+    const onDisk = JSON.parse(readFileSync(projectPrefsPath(projectA), "utf8"));
+    assert.equal(onDisk.preferences.destination.value, "x-feed");
+  });
+});
+
+test("one project never promotes: a fresh project sees nothing user-tier", () => {
+  withSandbox(({ projectA, projectB }) => {
+    recordPreference({ projectDir: projectA, key: "destination", value: "x-feed" });
+    // proj-b has no project entry, and the value was only confirmed once.
+    assert.equal(mergedPreferences(projectB).destination, undefined);
+  });
+});
+
+test("the same value confirmed in two projects promotes to the user tier", () => {
+  withSandbox(({ projectA, projectB }) => {
+    recordPreference({ projectDir: projectA, key: "destination", value: "x-feed" });
+    const second = recordPreference({ projectDir: projectB, key: "destination", value: "x-feed" });
+    assert.equal(second.promoted, true);
+
+    const userFile = JSON.parse(readFileSync(userPrefsPath(), "utf8"));
+    assert.deepEqual(userFile.preferences.destination.confirmed_in.sort(), ["proj-a", "proj-b"]);
+
+    // A third project with no local entry now inherits the promoted default.
+    const projectC = join(projectA, "..", "proj-c");
+    mkdirSync(projectC, { recursive: true });
+    const merged = mergedPreferences(projectC);
+    assert.equal(merged.destination.value, "x-feed");
+    assert.equal(merged.destination.source, "user");
+  });
+});
+
+test("record is idempotent per project — confirmed_in stays deduped", () => {
+  withSandbox(({ projectA }) => {
+    recordPreference({ projectDir: projectA, key: "language", value: "zh" });
+    const again = recordPreference({ projectDir: projectA, key: "language", value: "zh" });
+    assert.deepEqual(again.confirmed_in, ["proj-a"]);
+    assert.equal(again.promoted, false);
+  });
+});
+
+test("a changed value restarts provenance instead of inheriting confirmations", () => {
+  withSandbox(({ projectA, projectB }) => {
+    recordPreference({ projectDir: projectA, key: "destination", value: "x-feed" });
+    recordPreference({ projectDir: projectB, key: "destination", value: "x-feed" });
+    const switched = recordPreference({
+      projectDir: projectA,
+      key: "destination",
+      value: "youtube",
+    });
+    assert.deepEqual(switched.confirmed_in, ["proj-a"]);
+    assert.equal(switched.promoted, false);
+    // The previously promoted value keeps serving other projects until youtube
+    // earns its own two confirmations.
+    const userFile = JSON.parse(readFileSync(userPrefsPath(), "utf8"));
+    assert.equal(userFile.preferences.destination.value, "x-feed");
+  });
+});
+
+test("project tier overrides a promoted user-tier value", () => {
+  withSandbox(({ projectA, projectB }) => {
+    recordPreference({ projectDir: projectA, key: "mode", value: "collaborative" });
+    recordPreference({ projectDir: projectB, key: "mode", value: "collaborative" });
+    recordPreference({ projectDir: projectA, key: "mode", value: "autonomous" });
+    const merged = mergedPreferences(projectA);
+    assert.equal(merged.mode.value, "autonomous");
+    assert.equal(merged.mode.source, "project");
+  });
+});
+
+test("style_preset is keyed per workflow", () => {
+  withSandbox(({ projectA }) => {
+    assert.equal(
+      preferenceKeyFor("style_preset", "faceless-explainer"),
+      "style_preset.faceless-explainer",
+    );
+    assert.equal(preferenceKeyFor("destination", "faceless-explainer"), "destination");
+    recordPreference({
+      projectDir: projectA,
+      key: "style_preset",
+      value: "pin-and-paper",
+      workflow: "faceless-explainer",
+    });
+    const merged = mergedPreferences(projectA);
+    assert.equal(merged["style_preset.faceless-explainer"].value, "pin-and-paper");
+    assert.equal(merged["style_preset"], undefined);
+  });
+});
+
+test("unknown keys and empty values are rejected", () => {
+  withSandbox(({ projectA }) => {
+    assert.throws(() => recordPreference({ projectDir: projectA, key: "vibe", value: "x" }));
+    assert.throws(() => recordPreference({ projectDir: projectA, key: "voice", value: "  " }));
+  });
+});
+
+test("corrupt files are treated as empty instead of crashing", () => {
+  withSandbox(({ projectA, home }) => {
+    mkdirSync(join(projectA, ".media"), { recursive: true });
+    writeFileSync(projectPrefsPath(projectA), "not json");
+    mkdirSync(join(home, ".media"), { recursive: true });
+    writeFileSync(userPrefsPath(), '{"preferences": 42}');
+    assert.deepEqual(mergedPreferences(projectA), {});
+    const result = recordPreference({ projectDir: projectA, key: "language", value: "zh" });
+    assert.equal(result.value, "zh");
+  });
+});
diff --git a/skills/media-use/scripts/lib/recipe-store.mjs b/skills/media-use/scripts/lib/recipe-store.mjs
new file mode 100644
index 0000000000..bfb39d0bf5
--- /dev/null
+++ b/skills/media-use/scripts/lib/recipe-store.mjs
@@ -0,0 +1,294 @@
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { appendRecord, mediaDir, nextId } from "./manifest.mjs";
+import { regenerateIndex } from "./index-gen.mjs";
+import { mergedPreferences } from "./prefs-store.mjs";
+
+/**
+ * Recipes — the heavyweight tier of HyperFrames user memory.
+ *
+ * A recipe is the full confirmed bundle for one video type: the frozen design
+ * spec (`frame.md`), the storyboard skeleton (structure with the content
+ * blanked), and the confirmed brief values — frozen after the run's final
+ * approval, reused to start the next video of the same type from everything
+ * already approved.
+ *
+ * Storage is **named folders**, not content-addressed cache entries: a recipe
+ * is an evolving bundle with a `version`, so re-freezing the same name bumps
+ * the version and archives the old folder as `<name>@v<N>`. Two tiers, same
+ * split as everything else in media-use: project `.media/recipes/<name>/`
+ * (committed) and user `~/.media/recipes/<name>/` (a freeze is already a
+ * confirmed bundle, so it promotes immediately — no two-project rule here).
+ */
+
+/** Frontmatter keys that describe THIS video, not the reusable type. */
+const FRONTMATTER_CONTENT_KEYS = new Set(["message", "audience", "mode"]);
+
+/** Per-frame metadata that is content, not structure. */
+const FRAME_CONTENT_KEYS = new Set([
+  "voiceover",
+  "vo",
+  "voice_over",
+  "narration",
+  "scene",
+  "description",
+  "summary",
+  "caption",
+  "asset_candidates",
+]);
+
+const FRAME_HEADING_RE = /^(#{2,3})\s+(?:frame|beat|scene)\s+\d+/i;
+
+export function projectRecipesDir(projectDir) {
+  return join(mediaDir(projectDir), "recipes");
+}
+
+export function userRecipesDir() {
+  return join(homedir(), ".media", "recipes");
+}
+
+export function slugifyRecipeName(name) {
+  const slug = String(name ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_]+/g, "-")
+    .replace(/[^a-z0-9-]/g, "")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+  if (!slug) throw new Error(`recipe name "${name}" has no usable characters`);
+  return slug;
+}
+
+function frameTitle(headingLine) {
+  const dash = headingLine.split(/\s+—\s+/)[1];
+  if (dash && dash.trim()) return dash.trim();
+  return headingLine.replace(/^#+\s*/, "").trim();
+}
+
+/** Frontmatter: drop the content keys, keep structure/style keys verbatim. */
+function skeletonFrontmatter(lines, out) {
+  if (lines[0]?.trim() !== "---") return 0;
+  out.push(lines[0]);
+  let i = 1;
+  while (i < lines.length && lines[i].trim() !== "---") {
+    const key = lines[i].match(/^(\w+)\s*:/)?.[1]?.toLowerCase();
+    if (!key || !FRONTMATTER_CONTENT_KEYS.has(key)) out.push(lines[i]);
+    i++;
+  }
+  if (i < lines.length) {
+    out.push(lines[i]); // closing ---
+    i++;
+  }
+  return i;
+}
+
+/** One line inside a frame section — returns the replacement lines (may be none). */
+function skeletonFrameLine(line, state, out) {
+  const bulletKey = line.match(/^-\s+(\w+)\s*:/)?.[1]?.toLowerCase();
+  if (bulletKey) {
+    if (bulletKey === "status") out.push("- status: outline");
+    else if (!FRAME_CONTENT_KEYS.has(bulletKey)) out.push(line);
+    return;
+  }
+  if (!line.trim()) {
+    out.push(line);
+    return;
+  }
+  // Frame prose: one placeholder per frame in place of the narrative.
+  if (!state.proseReplaced) {
+    out.push(
+      `<fill in: this video's content for the "${state.title}" beat — keep the layout role, replace the words.>`,
+    );
+    state.proseReplaced = true;
+  }
+}
+
+/**
+ * Skeletonize a STORYBOARD.md: keep the reusable structure (frame count,
+ * durations, transitions, src paths, the Video direction block, style-ish
+ * frontmatter), reset every status to `outline`, and blank the content
+ * (message/audience, narration guides, per-frame prose) down to a fill-in
+ * placeholder that names the frame's role.
+ */
+export function skeletonizeStoryboard(source) {
+  const lines = String(source ?? "").split(/\r?\n/);
+  const out = [];
+  const state = { inFrame: false, proseReplaced: false, title: "" };
+  for (let i = skeletonFrontmatter(lines, out); i < lines.length; i++) {
+    const line = lines[i];
+    if (/^#{2,3}\s/.test(line)) {
+      state.inFrame = FRAME_HEADING_RE.test(line);
+      state.proseReplaced = false;
+      state.title = state.inFrame ? frameTitle(line) : "";
+      out.push(line);
+    } else if (!state.inFrame) {
+      out.push(line);
+    } else {
+      skeletonFrameLine(line, state, out);
+    }
+  }
+  return out.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
+function readRecipeJson(dir) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(dir, "recipe.json"), "utf8"));
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.name !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function prefValue(prefs, key) {
+  return prefs[key]?.value;
+}
+
+/**
+ * Freeze the current project's approved run as a named recipe. Writes the
+ * project-tier folder + a manifest record, then copies to the user tier (a
+ * freeze is already confirmed — it promotes immediately).
+ */
+export function freezeRecipe({ projectDir, name, workflow, blocks }) {
+  if (!workflow || !String(workflow).trim()) throw new Error("freeze needs --workflow");
+  const slug = slugifyRecipeName(name);
+  const root = resolve(projectDir);
+  const frameSpec = join(root, "frame.md");
+  const storyboard = join(root, "STORYBOARD.md");
+  if (!existsSync(frameSpec)) throw new Error("no frame.md to freeze — run the design step first");
+  if (!existsSync(storyboard)) throw new Error("no STORYBOARD.md to freeze");
+
+  const dir = join(projectRecipesDir(root), slug);
+  let version = 1;
+  const previous = existsSync(dir) ? readRecipeJson(dir) : null;
+  if (previous) {
+    version = (Number.isInteger(previous.version) ? previous.version : 1) + 1;
+    const archive = `${dir}@v${previous.version ?? 1}`;
+    rmSync(archive, { recursive: true, force: true });
+    renameSync(dir, archive);
+  }
+  mkdirSync(dir, { recursive: true });
+
+  const prefs = mergedPreferences(root);
+  const recipe = {
+    version,
+    name: slug,
+    workflow: String(workflow).trim(),
+    approved_at: new Date().toISOString(),
+    source_project: basename(root),
+    destination: prefValue(prefs, "destination"),
+    aspect: prefValue(prefs, "aspect"),
+    language: prefValue(prefs, "language"),
+    voice: prefValue(prefs, "voice"),
+    style_preset: prefValue(prefs, `style_preset.${String(workflow).trim()}`),
+    blocks: Array.isArray(blocks) && blocks.length > 0 ? blocks : undefined,
+  };
+
+  writeFileSync(join(dir, "recipe.json"), `${JSON.stringify(recipe, null, 2)}\n`);
+  cpSync(frameSpec, join(dir, "frame.md"));
+  writeFileSync(
+    join(dir, "storyboard-skeleton.md"),
+    `${skeletonizeStoryboard(readFileSync(storyboard, "utf8")).trimEnd()}\n`,
+  );
+
+  const id = nextId(root, "recipe");
+  appendRecord(root, {
+    id,
+    type: "recipe",
+    path: `.media/recipes/${slug}/recipe.json`,
+    entity: slug,
+    description: `recipe: ${slug} (${recipe.workflow}, v${version})`,
+    provenance: { provider: "recipe.freeze", version, source_project: recipe.source_project },
+  });
+  regenerateIndex(root);
+
+  // User tier — best-effort, like every other promotion.
+  try {
+    const userDir = join(userRecipesDir(), slug);
+    mkdirSync(userDir, { recursive: true });
+    cpSync(dir, userDir, { recursive: true, force: true });
+  } catch {
+    // The project-tier freeze already landed.
+  }
+
+  return { id, slug, version, dir };
+}
+
+function scanRecipesDir(dir, source) {
+  if (!existsSync(dir)) return [];
+  const found = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.includes("@v")) continue;
+    const recipe = readRecipeJson(join(dir, entry.name));
+    if (recipe) found.push({ ...recipe, source, dir: join(dir, entry.name) });
+  }
+  return found;
+}
+
+/** Two-tier merged listing (project wins), newest approval first. */
+export function listRecipes({ projectDir, workflow }) {
+  const merged = new Map();
+  for (const recipe of scanRecipesDir(userRecipesDir(), "user")) merged.set(recipe.name, recipe);
+  for (const recipe of scanRecipesDir(projectRecipesDir(resolve(projectDir)), "project")) {
+    merged.set(recipe.name, recipe);
+  }
+  let list = [...merged.values()];
+  if (workflow) list = list.filter((r) => r.workflow === workflow);
+  return list.sort((a, b) =>
+    String(b.approved_at ?? "").localeCompare(String(a.approved_at ?? "")),
+  );
+}
+
+/**
+ * Adopt a recipe into the current project: import the folder from the user
+ * tier when the project doesn't have it, copy its frame.md over the project's,
+ * and hand back the values + the skeleton path for the storyboard draft.
+ */
+export function useRecipe({ projectDir, name }) {
+  const slug = slugifyRecipeName(name);
+  const root = resolve(projectDir);
+  let dir = join(projectRecipesDir(root), slug);
+
+  if (!readRecipeJson(dir)) {
+    const userDir = join(userRecipesDir(), slug);
+    if (!readRecipeJson(userDir)) {
+      const known = listRecipes({ projectDir: root }).map((r) => r.name);
+      throw new Error(
+        `no recipe named "${slug}"${known.length ? ` (known: ${known.join(", ")})` : ""}`,
+      );
+    }
+    mkdirSync(dir, { recursive: true });
+    cpSync(userDir, dir, { recursive: true, force: true });
+    const imported = readRecipeJson(dir);
+    appendRecord(root, {
+      id: nextId(root, "recipe"),
+      type: "recipe",
+      path: `.media/recipes/${slug}/recipe.json`,
+      entity: slug,
+      description: `recipe: ${slug} (${imported.workflow}, v${imported.version})`,
+      provenance: { provider: "recipe.local", imported_from: "user-tier" },
+    });
+    regenerateIndex(root);
+  }
+
+  const recipe = readRecipeJson(dir);
+  cpSync(join(dir, "frame.md"), join(root, "frame.md"));
+  return {
+    recipe,
+    dir,
+    frameSpecPath: "frame.md",
+    skeletonPath: `.media/recipes/${slug}/storyboard-skeleton.md`,
+  };
+}
diff --git a/skills/media-use/scripts/lib/recipe-store.test.mjs b/skills/media-use/scripts/lib/recipe-store.test.mjs
new file mode 100644
index 0000000000..7ce47cb025
--- /dev/null
+++ b/skills/media-use/scripts/lib/recipe-store.test.mjs
@@ -0,0 +1,208 @@
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  freezeRecipe,
+  listRecipes,
+  skeletonizeStoryboard,
+  slugifyRecipeName,
+  useRecipe,
+} from "./recipe-store.mjs";
+import { recordPreference } from "./prefs-store.mjs";
+
+const STORYBOARD = `---
+format: 1080x1080
+message: "Ship a launch video in an afternoon"
+arc: Hook → Problem → Solution
+audience: indie devs on X
+mode: collaborative
+music: upbeat tech
+---
+
+## Frame 1 — Hook
+
+- scene: Big type punches in
+- duration: 3s
+- transition_in: cut
+- status: animated
+- voiceover: "Ship a launch video in an afternoon."
+- src: compositions/frames/01-hook.html
+
+Open cold on the promise. This is the thesis.
+
+## Frame 2 — Proof
+
+- duration: 4s
+- transition_in: crossfade
+- status: animated
+- asset_candidates: dashboard.png
+- src: compositions/frames/02-proof.html
+
+Real dashboard, real numbers.
+Second prose line to collapse.
+
+## Video direction
+
+Punchy, one accent color, hard cuts on the beat.
+`;
+
+function sandbox() {
+  const root = mkdtempSync(join(tmpdir(), "mu-recipes-"));
+  const home = join(root, "home");
+  const project = join(root, "my-launch");
+  mkdirSync(home, { recursive: true });
+  mkdirSync(project, { recursive: true });
+  writeFileSync(join(project, "frame.md"), "# Frame spec\nbackground: #101014\n");
+  writeFileSync(join(project, "STORYBOARD.md"), STORYBOARD);
+  process.env.HOME = home;
+  return { root, home, project };
+}
+
+function restoreEnv(saved) {
+  for (const k of Object.keys(process.env)) if (!(k in saved)) delete process.env[k];
+  Object.assign(process.env, saved);
+}
+
+function withSandbox(fn) {
+  const savedEnv = { ...process.env };
+  const box = sandbox();
+  try {
+    fn(box);
+  } finally {
+    restoreEnv(savedEnv);
+    rmSync(box.root, { recursive: true, force: true });
+  }
+}
+
+test("slugifyRecipeName normalizes and rejects empty", () => {
+  assert.equal(slugifyRecipeName("Weekly Changelog!"), "weekly-changelog");
+  assert.equal(slugifyRecipeName("  pr_reveal  "), "pr-reveal");
+  assert.throws(() => slugifyRecipeName("!!!"));
+});
+
+test("skeletonize keeps structure, resets status, blanks content", () => {
+  const skeleton = skeletonizeStoryboard(STORYBOARD);
+  // Structure kept.
+  assert.match(skeleton, /format: 1080x1080/);
+  assert.match(skeleton, /arc: Hook → Problem → Solution/);
+  assert.match(skeleton, /music: upbeat tech/);
+  assert.match(skeleton, /- duration: 3s/);
+  assert.match(skeleton, /- src: compositions\/frames\/01-hook\.html/);
+  assert.match(skeleton, /## Video direction/);
+  assert.match(skeleton, /hard cuts on the beat/);
+  // Statuses reset.
+  assert.equal((skeleton.match(/- status: outline/g) ?? []).length, 2);
+  assert.doesNotMatch(skeleton, /animated/);
+  // Content blanked.
+  assert.doesNotMatch(skeleton, /message:/);
+  assert.doesNotMatch(skeleton, /audience:/);
+  assert.doesNotMatch(skeleton, /mode:/);
+  assert.doesNotMatch(skeleton, /voiceover/);
+  assert.doesNotMatch(skeleton, /asset_candidates/);
+  assert.doesNotMatch(skeleton, /thesis/);
+  assert.doesNotMatch(skeleton, /Real dashboard/);
+  assert.match(skeleton, /<fill in: this video's content for the "Hook" beat/);
+  assert.match(skeleton, /<fill in: this video's content for the "Proof" beat/);
+});
+
+test("freeze writes the folder, manifest record, and user-tier copy", () => {
+  withSandbox(({ project, home }) => {
+    recordPreference({ projectDir: project, key: "destination", value: "x-feed" });
+    recordPreference({
+      projectDir: project,
+      key: "style_preset",
+      value: "pin-and-paper",
+      workflow: "product-launch-video",
+    });
+    const frozen = freezeRecipe({
+      projectDir: project,
+      name: "Weekly Launch",
+      workflow: "product-launch-video",
+      blocks: ["data-chart"],
+    });
+    assert.equal(frozen.slug, "weekly-launch");
+    assert.equal(frozen.version, 1);
+
+    const dir = join(project, ".media/recipes/weekly-launch");
+    const recipe = JSON.parse(readFileSync(join(dir, "recipe.json"), "utf8"));
+    assert.equal(recipe.workflow, "product-launch-video");
+    assert.equal(recipe.destination, "x-feed");
+    assert.equal(recipe.style_preset, "pin-and-paper");
+    assert.deepEqual(recipe.blocks, ["data-chart"]);
+    assert.ok(existsSync(join(dir, "frame.md")));
+    assert.match(readFileSync(join(dir, "storyboard-skeleton.md"), "utf8"), /- status: outline/);
+
+    const manifest = readFileSync(join(project, ".media/manifest.jsonl"), "utf8");
+    assert.match(manifest, /"type":"recipe"/);
+    assert.match(manifest, /"entity":"weekly-launch"/);
+
+    assert.ok(existsSync(join(home, ".media/recipes/weekly-launch/recipe.json")));
+  });
+});
+
+test("re-freezing bumps the version and archives the old folder", () => {
+  withSandbox(({ project }) => {
+    freezeRecipe({ projectDir: project, name: "promo", workflow: "product-launch-video" });
+    const again = freezeRecipe({
+      projectDir: project,
+      name: "promo",
+      workflow: "product-launch-video",
+    });
+    assert.equal(again.version, 2);
+    assert.ok(existsSync(join(project, ".media/recipes/promo@v1/recipe.json")));
+    const current = JSON.parse(
+      readFileSync(join(project, ".media/recipes/promo/recipe.json"), "utf8"),
+    );
+    assert.equal(current.version, 2);
+  });
+});
+
+test("list merges tiers (project wins), filters by workflow, skips archives", () => {
+  withSandbox(({ project, root }) => {
+    freezeRecipe({ projectDir: project, name: "promo", workflow: "product-launch-video" });
+    freezeRecipe({ projectDir: project, name: "promo", workflow: "product-launch-video" });
+    freezeRecipe({ projectDir: project, name: "explainer", workflow: "faceless-explainer" });
+
+    const fresh = join(root, "fresh-project");
+    mkdirSync(fresh, { recursive: true });
+    const all = listRecipes({ projectDir: fresh });
+    assert.deepEqual(all.map((r) => r.source).sort(), ["user", "user"]);
+    assert.equal(all.find((r) => r.name === "promo").version, 2);
+
+    const filtered = listRecipes({ projectDir: fresh, workflow: "faceless-explainer" });
+    assert.deepEqual(
+      filtered.map((r) => r.name),
+      ["explainer"],
+    );
+  });
+});
+
+test("use imports from the user tier into a fresh project and copies frame.md", () => {
+  withSandbox(({ project, root }) => {
+    freezeRecipe({ projectDir: project, name: "promo", workflow: "product-launch-video" });
+
+    const fresh = join(root, "fresh-project");
+    mkdirSync(fresh, { recursive: true });
+    const used = useRecipe({ projectDir: fresh, name: "Promo" });
+    assert.equal(used.recipe.name, "promo");
+    assert.equal(used.skeletonPath, ".media/recipes/promo/storyboard-skeleton.md");
+    assert.ok(existsSync(join(fresh, "frame.md")));
+    assert.ok(existsSync(join(fresh, ".media/recipes/promo/storyboard-skeleton.md")));
+    assert.match(
+      readFileSync(join(fresh, ".media/manifest.jsonl"), "utf8"),
+      /"imported_from":"user-tier"/,
+    );
+  });
+});
+
+test("use with an unknown name lists what exists", () => {
+  withSandbox(({ project }) => {
+    freezeRecipe({ projectDir: project, name: "promo", workflow: "product-launch-video" });
+    assert.throws(
+      () => useRecipe({ projectDir: project, name: "nope" }),
+      /no recipe named "nope" \(known: promo\)/,
+    );
+  });
+});
diff --git a/skills/media-use/scripts/prefs.mjs b/skills/media-use/scripts/prefs.mjs
new file mode 100644
index 0000000000..5f13583de8
--- /dev/null
+++ b/skills/media-use/scripts/prefs.mjs
@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * Remembered defaults CLI — the lightweight tier of HyperFrames user memory.
+ *
+ *   node prefs.mjs get --hyperframes . [--json]
+ *     Print the merged view (project `.media/preferences.json` over user
+ *     `~/.media/preferences.json`), each key with its source and the receipt
+ *     material (confirmed_in, updated_at).
+ *
+ *   node prefs.mjs record --hyperframes . --key destination --value x-feed [--workflow <w>]
+ *     Record one confirmed brief answer into the project tier; the same value
+ *     confirmed in two different projects promotes the key to the user tier.
+ *
+ * Consumption rules live in hyperframes-core/references/brief-contract.md § 2
+ * (Remembered defaults): a remembered value becomes the recommended option
+ * with a receipt — it never skips a question.
+ */
+import { parseArgs } from "node:util";
+import { mergedPreferences, recordPreference } from "./lib/prefs-store.mjs";
+
+const { values: args, positionals } = parseArgs({
+  options: {
+    hyperframes: { type: "string", default: "." },
+    key: { type: "string" },
+    value: { type: "string" },
+    workflow: { type: "string" },
+    json: { type: "boolean", default: false },
+  },
+  allowPositionals: true,
+});
+
+const verb = positionals[0];
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+if (verb === "get") {
+  const merged = mergedPreferences(args.hyperframes);
+  if (args.json) {
+    console.log(JSON.stringify(merged, null, 2));
+  } else if (Object.keys(merged).length === 0) {
+    console.log("no remembered preferences yet");
+  } else {
+    for (const [key, entry] of Object.entries(merged)) {
+      console.log(
+        `${key} = ${entry.value}  (${entry.source}; confirmed in ${entry.confirmed_in.join(", ")})`,
+      );
+    }
+  }
+} else if (verb === "record") {
+  if (!args.key || !args.value) fail("record needs --key and --value");
+  try {
+    const result = recordPreference({
+      projectDir: args.hyperframes,
+      key: args.key,
+      value: args.value,
+      workflow: args.workflow,
+    });
+    const promotion = result.promoted ? "; promoted to user tier" : "";
+    console.log(`recorded ${result.key} = ${result.value} (project${promotion})`);
+  } catch (err) {
+    fail(err instanceof Error ? err.message : String(err));
+  }
+} else {
+  fail(
+    "usage: prefs.mjs <get|record> --hyperframes . [--key <k> --value <v> --workflow <w>] [--json]",
+  );
+}
diff --git a/skills/media-use/scripts/recipe.mjs b/skills/media-use/scripts/recipe.mjs
new file mode 100644
index 0000000000..fb16722e91
--- /dev/null
+++ b/skills/media-use/scripts/recipe.mjs
@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * Recipes CLI — the heavyweight tier of HyperFrames user memory.
+ *
+ *   node recipe.mjs freeze --hyperframes . --name <n> --workflow <w> [--blocks a,b,c]
+ *     Freeze the current approved run as a named recipe: frame.md + the
+ *     storyboard skeleton (structure kept, content blanked) + the confirmed
+ *     brief values. Re-freezing the same name bumps the version and archives
+ *     the old folder as <name>@v<N>. Promotes to ~/.media/recipes/ immediately.
+ *
+ *   node recipe.mjs list --hyperframes . [--workflow <w>] [--json]
+ *     Two-tier merged listing (project wins), newest approval first.
+ *
+ *   node recipe.mjs use --hyperframes . --name <n> [--json]
+ *     Adopt a recipe: import it from the user tier if needed, copy its
+ *     frame.md over the project's, and print the brief values + skeleton path.
+ *
+ * When workflows offer/consume recipes is the review loop's and Step 0's
+ * business — see hyperframes-core/references/review-loop.md § 4 and each
+ * workflow's Step 0 recipe check.
+ */
+import { parseArgs } from "node:util";
+import { freezeRecipe, listRecipes, useRecipe } from "./lib/recipe-store.mjs";
+
+const { values: args, positionals } = parseArgs({
+  options: {
+    hyperframes: { type: "string", default: "." },
+    name: { type: "string" },
+    workflow: { type: "string" },
+    blocks: { type: "string" },
+    json: { type: "boolean", default: false },
+  },
+  allowPositionals: true,
+});
+
+const verb = positionals[0];
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+try {
+  if (verb === "freeze") {
+    if (!args.name) fail("freeze needs --name");
+    const frozen = freezeRecipe({
+      projectDir: args.hyperframes,
+      name: args.name,
+      workflow: args.workflow,
+      blocks: args.blocks
+        ? args.blocks
+            .split(",")
+            .map((b) => b.trim())
+            .filter(Boolean)
+        : undefined,
+    });
+    if (args.json) console.log(JSON.stringify({ ok: true, ...frozen }));
+    else console.log(`froze recipe ${frozen.slug} (v${frozen.version}) → ${frozen.dir}`);
+  } else if (verb === "list") {
+    const list = listRecipes({ projectDir: args.hyperframes, workflow: args.workflow });
+    if (args.json) console.log(JSON.stringify(list));
+    else if (list.length === 0) console.log("no recipes yet");
+    else {
+      for (const r of list) {
+        console.log(
+          `${r.name}  v${r.version}  ${r.workflow}  (${r.source}; approved ${String(r.approved_at ?? "?").slice(0, 10)})`,
+        );
+      }
+    }
+  } else if (verb === "use") {
+    if (!args.name) fail("use needs --name");
+    const used = useRecipe({ projectDir: args.hyperframes, name: args.name });
+    if (args.json) console.log(JSON.stringify({ ok: true, ...used }));
+    else {
+      console.log(
+        `using recipe ${used.recipe.name} (v${used.recipe.version}, ${used.recipe.workflow})`,
+      );
+      console.log(`  frame spec → ${used.frameSpecPath} (copied over)`);
+      console.log(`  storyboard skeleton → ${used.skeletonPath}`);
+      for (const key of ["destination", "aspect", "language", "voice", "style_preset"]) {
+        if (used.recipe[key]) console.log(`  ${key}: ${used.recipe[key]}`);
+      }
+    }
+  } else {
+    fail(
+      "usage: recipe.mjs <freeze|list|use> --hyperframes . [--name <n>] [--workflow <w>] [--blocks a,b] [--json]",
+    );
+  }
+} catch (err) {
+  fail(err instanceof Error ? err.message : String(err));
+}
diff --git a/skills/media-use/scripts/resolve.mjs b/skills/media-use/scripts/resolve.mjs
index 1de70e7bf9..334dafe682 100644
--- a/skills/media-use/scripts/resolve.mjs
+++ b/skills/media-use/scripts/resolve.mjs
@@ -169,6 +169,31 @@ if (args.from) {
   process.exit(0);
 }
 
+// Recipes: folder-based named bundles resolved by entity name — no providers,
+// no content hashing (an evolving versioned bundle, not an immutable file).
+// Delegates to lib/recipe-store.mjs the way grade/lut delegate to resolveColor;
+// freeze/list live in scripts/recipe.mjs.
+if (type === "recipe") {
+  const { useRecipe } = await import("./lib/recipe-store.mjs");
+  const name = (entity || intent || "").trim();
+  if (!name) exitError("--type recipe needs --entity <name> (or --intent <name>)", 2);
+  try {
+    const used = useRecipe({ projectDir, name });
+    if (args.json) {
+      console.log(JSON.stringify({ ok: true, ...used }));
+    } else {
+      console.log(
+        `resolved recipe ${used.recipe.name} (v${used.recipe.version}, ${used.recipe.workflow})`,
+      );
+      console.log(`  frame spec → ${used.frameSpecPath} (copied over)`);
+      console.log(`  storyboard skeleton → ${used.skeletonPath}`);
+    }
+    process.exit(0);
+  } catch (err) {
+    exitError(err.message, 1);
+  }
+}
+
 if (args.params !== undefined) {
   if (type !== "lut" && type !== "grade") {
     exitError(
diff --git a/skills/pr-to-video/SKILL.md b/skills/pr-to-video/SKILL.md
index 4d6063c05c..8143f047e3 100644
--- a/skills/pr-to-video/SKILL.md
+++ b/skills/pr-to-video/SKILL.md
@@ -25,7 +25,9 @@ Goal: Lock the PR reference and the core video brief, and create the HyperFrames
 
 Get the **PR reference** (a full URL, an `<owner>/<repo>#<N>` ref, or "this PR" in a checked-out repo), then confirm the brief in two rounds — through the question UI when the environment has one, conversationally otherwise. The intro text states **message** (the ONE thing the video must say about this change, in one sentence), **language**, and the style (always **claude**). Skip a question only when the user's request already answered it.
 
-**Round 1 — mode.** One question, asked first. Skip it when the request already carried a signal ("surprise me" / "just build it"):
+**Check for a recipe first.** Before any question, run `node ../media-use/scripts/recipe.mjs list --hyperframes . --workflow pr-to-video`. On a match (the user named one, said "like last time", or the list has one for this workflow), ask one question before the mode — one match: use recipe <name> (approved <date>)?; several: list them all and ask which one, or none. Adopting one answers the brief from the recipe — state those values as locked fields with "from recipe <name>" receipts, skip Step 2 (`recipe.mjs use` copies its frame.md in), and draft Step 3 from its storyboard skeleton. The mode question still follows, and the review gates still run — a recipe fills in answers, not approvals. Declined or no match: proceed to Round 1.
+
+**Round 1 — mode.** One question, asked first **and alone** — wait for the answer before any Round 2 question goes out; never bundle the brief questions into the same message. Skip it when the request already carried a signal ("surprise me" / "just build it"):
 
 - **Collaborative (recommended)** — confirm the key choices together before building.
 - **Autonomous** — every decision is made for the user, each stated with its reason; the only remaining question is preview-before-render.
@@ -39,7 +41,7 @@ Autonomous → ask nothing more. State the locked brief (all fields + receipts)
 - **Length — how long?** From the size table below; the tier is a ceiling, and a one-headline story recommends inside 30–90s ("+A/−D across F files" is the receipt).
 - **Destination — where will it play?** YouTube / embed → 16:9 (default for a code explainer) · X / LinkedIn / Instagram feed → 1:1 · Shorts / TikTok → 9:16.
 
-A "go" accepts all recommended defaults.
+Before asking, read the remembered defaults — brief contract § 2: a remembered value becomes the recommended option, its receipt naming the source project. A "go" accepts all recommended defaults.
 
 **Recommend the length from the PR's change size**, not a fixed guess. Before confirming the brief, peek at the PR once — a read-only call that also grounds the angle (Step 1 still does the full deterministic fetch):
 
@@ -64,7 +66,7 @@ Initialize only if `hyperframes.json` is missing. Name `<project>` from the PR i
 
 **Show sign-in status before the brief** — run `npx hyperframes auth status` and **relay its output verbatim (don't paraphrase or rewrite it).** It reports whether voice/BGM will use HeyGen or local engines and, when not signed in, how to sign in. **If not signed in, STOP and wait for the user to choose — sign in, or say "go"/"offline" to continue with local engines — before asking the brief or anything else.** Treat it as a real decision point, not a passing note; don't fold the choice into the brief question, and don't write keys into a per-repo `.env`. (In autonomous mode, note the status and continue offline.) See `../media-use` → Preflight for the canonical guidance.
 
-**Gate:** `hyperframes.json` exists; the PR ref is captured; angle, audience, length, destination → aspect, message, and language are locked; sign-in status was shown (signed in, or continuing offline).
+**Gate:** `hyperframes.json` exists; the PR ref is captured; angle, audience, length, destination → aspect, message, and language are locked; sign-in status was shown (signed in, or continuing offline); the confirmed answers were recorded as preferences (brief contract § 2).
 
 ---
 
@@ -121,7 +123,7 @@ Read `../hyperframes-creative/references/story-spine.md` (hook language, value-b
 
 Use `story-design.md` for the PR archetype (changelog / feature-reveal / fix-explainer / refactor-walkthrough), the PR-native frame types, hook, persuasion, beats, the per-frame word budget, and the credits close. The sequence comes from **narrative design, not the diff's file order** — explain the change, don't read the diff aloud. As a **soft guide**, consult the role→blueprint menu in `../hyperframes-animation/blueprints-index.md`: for each beat, write the voiceover in the shape its candidate blueprint implies and tag that candidate `blueprint:` id when one fits (story truth still decides which beats exist — never force a beat to fit a shape). Feature 2–4 real diff hunks (from `capture/diff.patch`), each a small legible snippet; name the `code-*` block each wants in the frame's `scene`. Frames carry no `asset_candidates` except the `credits` close (1–6 `assets/<login>.png` avatars). Use the exact required fields from the storyboard and script references.
 
-After drafting, present the plan as a proposal per story-spine § 3: open by echoing **"This video tells [audience] that [message]"**, then the frame table — one row per frame: frame · beat (type, duration) · on screen · why (its `narrativeRole`, traced to the message). In that same message ask the user (a) to approve or request changes, and (b) whether they want a live preview of the storyboard scaffold (`npx hyperframes preview`) — open it only on a yes. Iterate until approved; carry the preview choice to Step 6. This is a **checkpoint gate** (brief contract § 1): in autonomous mode, post the same summary as a heads-up and proceed — the preview question is asked once, at Step 6.
+After drafting, run the review loop's plan pass — `../hyperframes-core/references/review-loop.md` § 1: open the board (don't ask whether to), present the plan as a proposal, and ask the two questions — approve or change, and **sketches first** (recommended) or skip. Feedback loops through chat or the board's comments file until approved. This is a **checkpoint gate** (brief contract § 1): in autonomous mode there is no board and nothing to ask — post the same summary as a heads-up and proceed; sketches collapse into the build, and the one preview question comes at Step 6.
 
 **Gate:** `STORYBOARD.md` exists, every frame has the required narrative fields, `SCRIPT.md` exists when narration is needed, and the user approved the plan (autonomous: the summary was posted as a heads-up).
 
@@ -133,7 +135,7 @@ Goal: Generate narration, word timings, music, and audio metadata from the appro
 
 Start audio after Step 3 approval. Run it in the background, then continue to Step 4.
 
-**Choose the narration voice from the user's ask before invoking.** If the request named a voice, gender, or tone, pick a matching voice id and pass it with `--voice <id>`. The pipeline default is otherwise **Marcia (female)** on HeyGen / `am_michael` on Kokoro — so a request like "a male voice" is silently ignored unless you pass the flag. Voice ids are provider-specific; resolve against whichever provider Step 0's sign-in status selected: **HeyGen** (signed in) via `node ../media-use/audio/scripts/heygen-tts.mjs --list` (or `GET /v3/voices?engine=starfish`); **Kokoro** (offline) via the voice table in `../media-use/audio/references/tts.md` (prefixes `am_`/`bm_` male, `af_`/`bf_` female). Omit `--voice` only when the user expressed no preference.
+**Choose the narration voice from the user's ask before invoking.** If the request named a voice, gender, or tone, pick a matching voice id and pass it with `--voice <id>`. The pipeline default is otherwise **Marcia (female)** on HeyGen / `am_michael` on Kokoro — so a request like "a male voice" is silently ignored unless you pass the flag. Voice ids are provider-specific; resolve against whichever provider Step 0's sign-in status selected: **HeyGen** (signed in) via `node ../media-use/audio/scripts/heygen-tts.mjs --list` (or `GET /v3/voices?engine=starfish`); **Kokoro** (offline) via the voice table in `../media-use/audio/references/tts.md` (prefixes `am_`/`bm_` male, `af_`/`bf_` female). When the user expressed no preference, fall back to the remembered voice (brief contract § 2) before the pipeline default, and say which one you used; omit `--voice` only when neither names one. When the user explicitly picked a voice this run, record it (`prefs.mjs record --key voice`).
 
 `node <SKILL_DIR>/scripts/audio.mjs --script ./SCRIPT.md --storyboard ./STORYBOARD.md --hyperframes . --out ./audio_meta.json --voice <voice-id> &`
 
@@ -149,6 +151,8 @@ If there is no narration and no `SCRIPT.md`, skip voice generation. BGM may stil
 
 Goal: Add the visual direction, layout intent, and motion choices to each storyboard frame.
 
+**Sketch the board first (collaborative only).** The moment the plan is approved, run the sketch pass — `../hyperframes-core/references/review-loop.md` § 2 (don't wait on Step 3.1; sketches don't use timings): wireframe every frame yourself, mark each `built`, pause for the one layout question when the board is full, and revise only the sketches named until the board is confirmed. Stand-ins: for a **code beat**, a plain code panel with the filename and a few real diff lines as text — the `code-*` block wiring belongs to the workers. Only then write the visual design below onto the confirmed layouts. In autonomous mode, or when the user chose to skip sketches at Step 3, skip this pass — frames go straight from `outline` to `animated` at Step 5.
+
 Edit `STORYBOARD.md` in place. Do not create another storyboard. Use `frame.md` as source of truth for color, type, layout feel, and style.
 
 Read `references/visual-design.md`, `../hyperframes-animation/blueprints-index.md`, `references/motion-language.md`, `references/code-vocabulary.md`, and `../hyperframes-animation/rules-index.md`. Use `visual-design.md` for the method (the time-coded shot sequence, the inline Layout vocabulary, and the code-beat treatment), plus the required `## Video direction` block. Use `../hyperframes-animation/blueprints-index.md` to pick each frame's shot shape. Use `code-vocabulary.md` to pick the right `code-*` block per code beat (diff = `code-diff`, refactor = `code-morph`, new code = `code-typing`, …). Use `motion-language.md` (the motion vocabulary + the motion doctrine) and `../hyperframes-animation/rules-index.md` (valid rule names) for motion — do not invent motion or block/blueprint names.
@@ -157,7 +161,7 @@ For every frame, write a **time-coded shot sequence** into `STORYBOARD.md` per `
 
 Do not change story, script, `transition_in`, `asset_candidates`, or the PR source. Do not write HTML in this step. There is **no asset-staging step** — the only real assets are the credits avatars, already in `assets/`.
 
-**Gate:** every frame has a time-coded shot sequence whose reveals are paced to the voiceover (no front-loading); code frames name a `code-*` block as the `focal`; `## Video direction` exists.
+**Gate:** every frame has a time-coded shot sequence whose reveals are paced to the voiceover (no front-loading); code frames name a `code-*` block as the `focal`; `## Video direction` exists. Collaborative: the sketch board was confirmed.
 
 ---
 
@@ -177,7 +181,7 @@ Duration sync is mechanical: real voice duration wins; silent frames keep estima
 
 `for b in <each registry block named in the storyboard>; do npx hyperframes add "$b"; done`
 
-Before dispatch, read `sub-agents/frame-worker.md` and `../hyperframes-core/references/subagent-dispatch.md`. Dispatch one sub-agent per frame, in parallel if possible; otherwise run workers in waves. Each worker gets exactly one frame. Each worker's context must include `PROJECT_DIR`, `frame_id`, canvas size, caption status and keep-out band if captions are enabled, `RULES_DIR` (absolute path to this skill's `../hyperframes-animation/rules/`), and the absolute path to `references/code-vocabulary.md`. Each worker reads `frame.md`, its own `## Frame N` block from `STORYBOARD.md`, the local rule recipe (`../hyperframes-animation/rules/<id>.md`) for each cited motion, the frame's blueprint template (`../hyperframes-animation/blueprints/<id>.md`), and — for a code beat — `code-vocabulary.md` for the named block's inputs. Each worker writes only `compositions/frames/NN-*.html`; workers never edit `STORYBOARD.md`.
+Before dispatch, read `sub-agents/frame-worker.md` and `../hyperframes-core/references/subagent-dispatch.md`. Dispatch one sub-agent per frame, in parallel if possible; otherwise run workers in waves. Each worker gets exactly one frame. Each worker's context must include `PROJECT_DIR`, `frame_id`, whether the frame has a **confirmed sketch** on disk, canvas size, caption status and keep-out band if captions are enabled, `RULES_DIR` (absolute path to this skill's `../hyperframes-animation/rules/`), and the absolute path to `references/code-vocabulary.md`. Each worker reads `frame.md`, its own `## Frame N` block from `STORYBOARD.md`, the confirmed sketch when one exists (keep its layout — frame-worker § When a confirmed sketch exists), the local rule recipe (`../hyperframes-animation/rules/<id>.md`) for each cited motion, the frame's blueprint template (`../hyperframes-animation/blueprints/<id>.md`), and — for a code beat — `code-vocabulary.md` for the named block's inputs. Each worker writes only `compositions/frames/NN-*.html`; workers never edit `STORYBOARD.md`.
 
 **Full-bleed backgrounds ride on a `class="clip"` layer, never the `#root`.** A frame's ground (color field / gradient / grid) is its own full-duration background clip — a `background` set on the `#root` / `data-composition-id` element is clip-gated to the frame's window and is not a dependable ground, so dark content can land on the black host `body` and render invisible. The video's base ground is painted by the assembler from `frame.md`'s `canvas` color onto the index `#root`. (Full rule + self-check: `sub-agents/frame-worker.md`.)
 
@@ -191,7 +195,7 @@ After audio timings exist, build captions in the background and assemble the ind
 
 `captions.mjs` uses the project's `.hyperframes/caption-skin.html` (claude's, copied in Step 2), injecting brand tokens from `frame.md`; `captions: skipped (<reason>)` is valid. `assemble-index.mjs` stages the credits avatars from `assets/` as an idempotent backstop.
 
-**Gate:** every frame is marked `animated`, `index.html` exists, and captions are built or explicitly skipped.
+**Gate:** every frame is marked `animated` (collaborative: the sketch board was confirmed at Step 4), `index.html` exists, and captions are built or explicitly skipped.
 
 ---
 
@@ -219,7 +223,7 @@ If a command fails, surface stderr and stop — don't pile on recovery commands.
 
 **Known false-positive — do not chase it.** `inspect` may report a handful of `text_box_overflow` errors of ~1–4px on the **caption** highlight words (selector `#caption-word-*` / `.caption-line`). The caption pill uses a deliberately snug `line-height` (set once in `scripts/captions.mjs`) and has **no `overflow:hidden`**, so a heavy display glyph's ink spills a few px into the pill's own padding — nothing is actually clipped. Treat these as expected and proceed. Do **not** inflate the caption `line-height` (it balloons the pill, which is worse). Only act on a `text_box_overflow` when it names a **frame** element (`#el-NN-*`), not a caption word.
 
-After checks pass, pause for user review. The video is assembled, viewable, and editable in Studio. Manage preview only once across Step 3 and Step 6: open it if the user asked earlier, offer it if they declined earlier, do not ask again if they are already reviewing in Studio. In autonomous mode this is the one question the mode keeps: ask "preview first, or render?" — open the preview on yes, render on no — then deliver the MP4 with the contact sheet and the frame ids so revisions can target a single frame.
+After checks pass, pause for user review — the review loop's final look (`../hyperframes-core/references/review-loop.md` § 4): one question, on the Studio that has been open since Step 3 — render now, or what changes? (Autonomous: the one kept question, preview first or render.) Then deliver the MP4 with the contact sheet and the frame ids so revisions can target a single frame.
 
 Preview: `npx hyperframes preview`
 
diff --git a/skills/pr-to-video/sub-agents/frame-worker.md b/skills/pr-to-video/sub-agents/frame-worker.md
index ea674c8578..8de7d25fe5 100644
--- a/skills/pr-to-video/sub-agents/frame-worker.md
+++ b/skills/pr-to-video/sub-agents/frame-worker.md
@@ -26,6 +26,10 @@
 
 **OUTPUT** — `compositions/frames/<frame_id>.html`, one self-contained sub-composition. Writing it (past the self-check below) is your **terminal action** — you do not edit `STORYBOARD.md`, mint audio, assemble the index, run the CLI, or report back. The orchestrator picks up the file and marks the frame's `status`.
 
+## When a confirmed sketch exists
+
+In collaborative runs the orchestrator wireframes the board first, so your target file may already exist as the frame's **user-confirmed wireframe** — your dispatch says whether it does (a file found on a retry is your own prior output, not a sketch). Read it first and **keep its composition**: the placement, hierarchy, and copy were approved — don't move or drop them. Everything else is yours to finish: the full `frame.md` treatment (the sketch is deliberately unstyled), the `code-*` block where the sketch held plain code, the finished invented visuals where it used plain blocks, and the motion — map each Scene onto a timeline phase, reveal each piece on its `voiceover` cue with `fromTo` entrances, adding DOM only where a phase needs it. The frame's landed state must still read as the approved wireframe, fully dressed.
+
 ## Mostly invented — you build the visual (except code blocks + the credits avatars)
 
 A PR video is **mostly invented**: there are **no screenshots and no captured UI**. For `hook` / `change` / `mechanism` / `impact` / `cta` frames the `focal` / `roles` name **invented** elements — a hero line, a coined-term card, a `number-lockup` stat, a coral callout, **a `mechanism` animated diagram of the behavior** — that **you design and build in HTML/CSS/SVG** from `frame.md`. Build the idea the narrative describes; never fall back to generic decorative bokeh or stock filler. Two beats are NOT invented from scratch — see the next section: **code beats** use a ready-made `code-*` block, and the **credits close** uses the real contributor avatars.
diff --git a/skills/product-launch-video/SKILL.md b/skills/product-launch-video/SKILL.md
index e6956b7d91..47796cd2b4 100644
--- a/skills/product-launch-video/SKILL.md
+++ b/skills/product-launch-video/SKILL.md
@@ -33,7 +33,9 @@ Initialize only if `hyperframes.json` is missing. Name `<project>` from the bran
 
 **Confirm the brief** in two rounds — through the question UI when the environment has one, conversationally otherwise. The intro text states **message** (the ONE thing the promo must communicate, in one sentence) and **language**. Skip a question only when the user's request already answered it. (`VO_MODE` is asked in Step 1 only when a script was pasted.)
 
-**Round 1 — mode.** One question, asked first. Skip it when the request already carried a signal ("surprise me" / "just build it"):
+**Check for a recipe first.** Before any question, run `node ../media-use/scripts/recipe.mjs list --hyperframes . --workflow product-launch-video`. On a match (the user named one, said "like last time", or the list has one for this workflow), ask one question before the mode — one match: use recipe <name> (approved <date>)?; several: list them all and ask which one, or none. Adopting one answers the brief from the recipe — state those values as locked fields with "from recipe <name>" receipts, skip Step 2 (`recipe.mjs use` copies its frame.md in), and draft Step 3 from its storyboard skeleton. The mode question still follows, and the review gates still run — a recipe fills in answers, not approvals. Declined or no match: proceed to Round 1.
+
+**Round 1 — mode.** One question, asked first **and alone** — wait for the answer before any Round 2 question goes out; never bundle the brief questions into the same message. Skip it when the request already carried a signal ("surprise me" / "just build it"):
 
 - **Collaborative (recommended)** — confirm the key choices together before building.
 - **Autonomous** — every decision is made for the user, each stated with its reason; the only remaining question is preview-before-render.
@@ -46,9 +48,9 @@ Autonomous → ask nothing more. State the locked brief (all fields + receipts)
 - **Length — how long?** Recommend inside the 30–90s sweet spot, scaled to how much material the input gives you, with its basis.
 - **Destination — where will it play?** YouTube / embed → 16:9 · X / LinkedIn / Instagram feed → 1:1 · Shorts / TikTok → 9:16.
 
-A "go" accepts all recommended defaults.
+Before asking, read the remembered defaults — brief contract § 2: a remembered value becomes the recommended option, its receipt naming the source project. A "go" accepts all recommended defaults.
 
-**Gate:** `hyperframes.json` exists, and the brief fields (angle, length, destination → aspect, message, language) are locked; sign-in status was shown (signed in, or continuing offline).
+**Gate:** `hyperframes.json` exists, and the brief fields (angle, length, destination → aspect, message, language) are locked; sign-in status was shown (signed in, or continuing offline); the confirmed answers were recorded as preferences (brief contract § 2).
 
 ---
 
@@ -82,7 +84,7 @@ The script does the rest deterministically: copies the preset's `FRAME.md` → `
 
 `tokens.json` with no brand colors/fonts (e.g. no capture) → the script keeps the preset's own palette, a complete shippable design. If the brief names brand colors/fonts the capture missed, add them to `capture/extracted/tokens.json` before running (or use the user's `design.md` to populate it); only adjust `frame.md` by hand afterward if a mapping truly needs it.
 
-**Gate:** `build-frame.mjs` exited 0 — `frame.md` exists from a named preset, and (when the preset ships one) `.hyperframes/caption-skin.html` exists as the caption skin source.
+**Gate:** `build-frame.mjs` exited 0 — `frame.md` exists from a named preset, and (when the preset ships one) `.hyperframes/caption-skin.html` exists as the caption skin source; the chosen preset was recorded as a preference (`--key style_preset --workflow <this workflow>`, brief contract § 2).
 
 ---
 
@@ -94,7 +96,7 @@ Read `../hyperframes-creative/references/story-spine.md` (hook language, value-b
 
 Use `story-design.md` for story blueprint, hook, persuasion logic, beats, `VO_MODE`, and asset choices. As a **soft guide**, consult the role→blueprint menu in `../hyperframes-animation/blueprints-index.md`: for each beat, note a candidate blueprint id when one fits. Story truth still decides which beats exist — never force a beat to fit a blueprint, and never invent a beat just because a proven shape is available. Choose each visual frame's `asset_candidates` from `capture/extracted/asset-descriptions.md` (the canonical inventory) — don't browse raw `capture/assets/`. Do not ask the user to pick assets unless that inventory is missing or unusable. Use the exact required fields from the storyboard and script references.
 
-After drafting, present the plan as a proposal per story-spine § 3: open by echoing **"This video tells [audience] that [message]"**, then the frame table — one row per frame: frame · beat (type, duration) · on screen · why (its `narrativeRole`, traced to the message). In that same message ask the user two things: (a) to approve or request changes, and (b) whether they want a live preview of the storyboard scaffold (npx hyperframes preview) — open it only on a yes. Iterate until approved, and carry the preview choice to Step 6. This is a **checkpoint gate** (brief contract § 1): in autonomous mode, post the same summary as a heads-up and proceed — the preview question is asked once, at Step 6.
+After drafting, run the review loop's plan pass — `../hyperframes-core/references/review-loop.md` § 1: open the board (don't ask whether to), present the plan as a proposal, and ask the two questions — approve or change, and **sketches first** (recommended) or skip. Feedback loops through chat or the board's comments file until approved. This is a **checkpoint gate** (brief contract § 1): in autonomous mode there is no board and nothing to ask — post the same summary as a heads-up and proceed; sketches collapse into the build, and the one preview question comes at Step 6.
 
 **Gate:** `STORYBOARD.md` exists, every visual frame has `asset_candidates`, `SCRIPT.md` exists when narration is needed, and the user approved the frame-by-frame plan (autonomous: the summary was posted as a heads-up).
 
@@ -106,7 +108,7 @@ Goal: Generate narration, word timings, music, and audio metadata from the appro
 
 Start audio after Step 3 approval. Run it in the background, then continue to Step 4.
 
-**Choose the narration voice from the user's ask before invoking.** If the request named a voice, gender, or tone, pick a matching voice id and pass it with `--voice <id>`. The pipeline default is otherwise **Marcia (female)** on HeyGen / `am_michael` on Kokoro — so a request like "a male voice" is silently ignored unless you pass the flag. Voice ids are provider-specific; resolve against whichever provider Step 0's sign-in status selected: **HeyGen** (signed in) via `node ../media-use/audio/scripts/heygen-tts.mjs --list` (or `GET /v3/voices?engine=starfish`); **Kokoro** (offline) via the voice table in `../media-use/audio/references/tts.md` (prefixes `am_`/`bm_` male, `af_`/`bf_` female). Omit `--voice` only when the user expressed no preference.
+**Choose the narration voice from the user's ask before invoking.** If the request named a voice, gender, or tone, pick a matching voice id and pass it with `--voice <id>`. The pipeline default is otherwise **Marcia (female)** on HeyGen / `am_michael` on Kokoro — so a request like "a male voice" is silently ignored unless you pass the flag. Voice ids are provider-specific; resolve against whichever provider Step 0's sign-in status selected: **HeyGen** (signed in) via `node ../media-use/audio/scripts/heygen-tts.mjs --list` (or `GET /v3/voices?engine=starfish`); **Kokoro** (offline) via the voice table in `../media-use/audio/references/tts.md` (prefixes `am_`/`bm_` male, `af_`/`bf_` female). When the user expressed no preference, fall back to the remembered voice (brief contract § 2) before the pipeline default, and say which one you used; omit `--voice` only when neither names one. When the user explicitly picked a voice this run, record it (`prefs.mjs record --key voice`).
 
 `node <SKILL_DIR>/scripts/audio.mjs --script ./SCRIPT.md --storyboard ./STORYBOARD.md --hyperframes . --out ./audio_meta.json --voice <voice-id> &`
 
@@ -122,6 +124,8 @@ If there is no narration and no `SCRIPT.md`, skip voice generation. BGM may stil
 
 Goal: Add the visual direction, layout intent, and motion choices to each storyboard frame.
 
+**Sketch the board first (collaborative only).** The moment the plan is approved, run the sketch pass — `../hyperframes-core/references/review-loop.md` § 2 (don't wait on Step 3.1; sketches don't use timings): wireframe every frame yourself, mark each `built`, pause for the one layout question when the board is full, and revise only the sketches named until the board is confirmed. Stand-ins: plain labeled blocks for the captured assets — the real files arrive with Step 5's workers. Only then write the visual design below onto the confirmed layouts. In autonomous mode, or when the user chose to skip sketches at Step 3, skip this pass — frames go straight from `outline` to `animated` at Step 5.
+
 Edit `STORYBOARD.md` in place. Do not create another storyboard. Use `frame.md` as source of truth for color, type, layout feel, and style.
 
 Read `references/visual-design.md`, `../hyperframes-animation/blueprints-index.md`, `references/motion-language.md`, and `../hyperframes-animation/rules-index.md`. Use `visual-design.md` for the method (the time-coded shot sequence, the inline Layout vocabulary, and the required `## Video direction` block). Use `../hyperframes-animation/blueprints-index.md` to pick each frame's shot shape. Use `motion-language.md` (the motion vocabulary + the motion doctrine) and `../hyperframes-animation/rules-index.md` (valid rule names) for motion — do not invent motion names.
@@ -134,7 +138,7 @@ Stage named assets after visual design is locked:
 
 `node <SKILL_DIR>/scripts/stage-assets.mjs --storyboard ./STORYBOARD.md --hyperframes .`
 
-**Gate:** every visual frame has a time-coded shot sequence whose reveals are paced to the voiceover (no front-loading); `## Video direction` exists; `assets/` contains the named assets.
+**Gate:** every visual frame has a time-coded shot sequence whose reveals are paced to the voiceover (no front-loading); `## Video direction` exists; `assets/` contains the named assets. Collaborative: the sketch board was confirmed.
 
 ---
 
@@ -152,7 +156,7 @@ Duration sync is mechanical: real voice duration wins; silent frames keep estima
 
 Before dispatch, read `sub-agents/frame-worker.md` and `../hyperframes-core/references/subagent-dispatch.md`. Dispatch one sub-agent per frame, in parallel if possible; otherwise run workers in waves. Each worker gets exactly one frame.
 
-Each worker context must include `PROJECT_DIR`, `frame_id`, canvas size, caption status and keep-out band if captions are enabled, and `RULES_DIR` as the absolute path to this skill's `../hyperframes-animation/rules/`. Each worker reads `frame.md`, its own `## Frame N` block from `STORYBOARD.md`, the local rule recipe (`../hyperframes-animation/rules/<id>.md`) for each cited motion, and the frame's blueprint template (`../hyperframes-animation/blueprints/<id>.md`). Each worker writes only `compositions/frames/NN-*.html`. Workers must never edit `STORYBOARD.md`.
+Each worker context must include `PROJECT_DIR`, `frame_id`, whether the frame has a **confirmed sketch** on disk, canvas size, caption status and keep-out band if captions are enabled, and `RULES_DIR` as the absolute path to this skill's `../hyperframes-animation/rules/`. Each worker reads `frame.md`, its own `## Frame N` block from `STORYBOARD.md`, the confirmed sketch when one exists (keep its layout — frame-worker § When a confirmed sketch exists), the local rule recipe (`../hyperframes-animation/rules/<id>.md`) for each cited motion, and the frame's blueprint template (`../hyperframes-animation/blueprints/<id>.md`). Each worker writes only `compositions/frames/NN-*.html`. Workers must never edit `STORYBOARD.md`.
 
 **Full-bleed backgrounds ride on a `class="clip"` layer, never the `#root`.** A frame's ground (color field / gradient / grid) is its own full-duration background clip — a `background` set on the `#root` / `data-composition-id` element is clip-gated to the frame's window and is not a dependable ground, so dark content can land on the black host `body` and render invisible. The video's base ground is painted by the assembler from `frame.md`'s `canvas` color onto the index `#root`. (Full rule + self-check: `sub-agents/frame-worker.md`.)
 
@@ -166,7 +170,7 @@ After audio timings exist, build captions in the background and assemble the ind
 
 `captions.mjs` uses the project's `.hyperframes/caption-skin.html` (copied in Step 2) as the caption look, injecting brand tokens from `frame.md`; with no skin present it renders the built-in default pill. `captions: skipped (<reason>)` is valid. Continue without captions when explicitly skipped.
 
-**Gate:** every frame is marked `animated`, `index.html` exists, and captions are built or explicitly skipped.
+**Gate:** every frame is marked `animated` (collaborative: the sketch board was confirmed at Step 4), `index.html` exists, and captions are built or explicitly skipped.
 
 ---
 
@@ -192,7 +196,7 @@ Inject transitions, run checks, pause for review, then render.
 
 If a command fails, surface stderr and stop — don't pile on recovery commands. Fix it yourself: the cheapest safe edit to `compositions/frames/NN-*.html`, then rerun the failed check.
 
-After checks pass, pause for user review. The video is assembled, viewable, and editable in Studio. Manage preview only once across Step 3 and Step 6: open it if the user asked earlier, offer it if they declined earlier, and do not ask again if they are already reviewing in Studio. In autonomous mode this is the one question the mode keeps: ask "preview first, or render?" — open the preview on yes, render on no — then deliver the MP4 with the contact sheet and the frame ids so revisions can target a single frame.
+After checks pass, pause for user review — the review loop's final look (`../hyperframes-core/references/review-loop.md` § 4): one question, on the Studio that has been open since Step 3 — render now, or what changes? (Autonomous: the one kept question, preview first or render.) Then deliver the MP4 with the contact sheet and the frame ids so revisions can target a single frame.
 
 Preview: `npx hyperframes preview`
 
diff --git a/skills/product-launch-video/sub-agents/frame-worker.md b/skills/product-launch-video/sub-agents/frame-worker.md
index 6dad8fb66d..6321358e53 100644
--- a/skills/product-launch-video/sub-agents/frame-worker.md
+++ b/skills/product-launch-video/sub-agents/frame-worker.md
@@ -25,6 +25,10 @@
 
 **OUTPUT** — `compositions/frames/<frame_id>.html`, one self-contained sub-composition. Writing it (past the self-check below) is your **terminal action** — you do not edit `STORYBOARD.md`, mint audio, assemble the index, run the CLI, or report back. The orchestrator picks up the file and marks the frame's `status`.
 
+## When a confirmed sketch exists
+
+In collaborative runs the orchestrator wireframes the board first, so your target file may already exist as the frame's **user-confirmed wireframe** — your dispatch says whether it does (a file found on a retry is your own prior output, not a sketch). Read it first and **keep its composition**: the placement, hierarchy, and copy were approved — don't move or drop them. Everything else is yours to finish: the full `frame.md` treatment (the sketch is deliberately unstyled), the real assets where the sketch used stand-in blocks, and the motion — map each Scene onto a timeline phase, reveal each piece on its `voiceover` cue with `fromTo` entrances, adding DOM only where a phase needs it. The frame's landed state must still read as the approved wireframe, fully dressed.
+
 ## You do NOT decide
 
 These belong to other steps — touching them collides with a sibling or breaks an upstream contract: