goosetools-worker 0.1.2 → 0.2.2

package/worker/index.js

@@ -4,19 +4,26 @@
 // HTTPS with its worker token.
 
 import { execFile } from "node:child_process";
-import { mkdirSync, readdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { runAgent } from "./agent-cli.js";
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
 import { join, dirname, resolve, extname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import yaml from "js-yaml";
 import { upload } from "@vercel/blob/client";
+import { skillSection } from "./skill.js";
+import { extFromUrl } from "./style.js";
+import { FONT_SPECS, sanitizeFonts } from "../src/fonts.js";
+import { assertFfmpeg, isVideoPath, posterFrame } from "../src/video.js";
 
 const execFileAsync = promisify(execFile);
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
-// ── Config: flags > env > worker/.env ───────────────────────────────────────
-function loadDotEnv() {
-  const p = join(ROOT, "worker", ".env");
+// ── Config: flags > env > worker/.env > ~/.goosetools/env ───────────────────
+// The last one is written by `goosetools-worker install` (the background
+// service) so the daemon needs no flags at all.
+function parseEnvFile(p) {
   if (!existsSync(p)) return {};
   return Object.fromEntries(
     readFileSync(p, "utf8")
@@ -25,7 +32,10 @@ function loadDotEnv() {
       .map((l) => [l.slice(0, l.indexOf("=")).trim(), l.slice(l.indexOf("=") + 1).trim()]),
   );
 }
-const dotenv = loadDotEnv();
+const dotenv = {
+  ...parseEnvFile(join(homedir(), ".goosetools", "env")),
+  ...parseEnvFile(join(ROOT, "worker", ".env")),
+};
 function flag(name) {
   const i = process.argv.indexOf(name);
   return i !== -1 ? process.argv[i + 1] : undefined;
@@ -33,7 +43,15 @@ function flag(name) {
 const BASE_URL = (flag("--url") ?? process.env.GOOSETOOLS_URL ?? dotenv.GOOSETOOLS_URL ?? "https://goosetools.com").replace(/\/$/, "");
 const TOKEN = flag("--token") ?? process.env.WORKER_TOKEN ?? dotenv.WORKER_TOKEN;
 const VOICE_DIR = process.env.VOICE_DIR ?? dotenv.VOICE_DIR; // optional
-const POLL_MS = 30_000;
+// Fast for a stretch after the last job (someone is actively working), 60s
+// once things go quiet — a flat 30s poll across four workers kept the prod
+// database awake 24/7 and burned its whole compute quota.
+const POLL_FAST_MS = 5_000;
+const POLL_IDLE_MS = 60_000;
+const STAY_FAST_MS = 2 * 60 * 1000;
+let lastJobAt = 0;
+const pollDelay = () =>
+  Date.now() - lastJobAt < STAY_FAST_MS ? POLL_FAST_MS : POLL_IDLE_MS;
 
 if (!TOKEN) {
   console.error("Missing worker token. Run with --token gt_... (get one at " + BASE_URL + "/dashboard/carousel)");
@@ -59,6 +77,85 @@ async function api(path, body) {
   return res.json();
 }
 
+// ── Per-user brand ───────────────────────────────────────────────────────────
+// The server sends the user's saved brand with each job; merge it over the
+// repo brand.yml (so unset keys keep working) and drop it in the carousel dir
+// where render.js prefers it.
+// `apply` carries the per-carousel "use my brand font / color" checkboxes.
+// They ride along in brand.yml because render.js reads that file to decide
+// whether the brand or the style wins each key. Style jobs pass nothing and
+// get the historical behavior (style wins).
+export function writeBrandFile(dir, jobBrand, apply) {
+  const rootBrand = yaml.load(readFileSync(join(ROOT, "brand.yml"), "utf8"));
+  const merged = {
+    ...rootBrand,
+    ...(jobBrand ?? {}),
+    colors: { ...rootBrand.colors, ...(jobBrand?.colors ?? {}) },
+    fonts: { ...rootBrand.fonts, ...(jobBrand?.fonts ?? {}) },
+    style: { ...rootBrand.style, ...(jobBrand?.style ?? {}) },
+    ...(apply
+      ? { applyBrandFonts: apply.fonts === true, applyBrandColors: apply.colors === true }
+      : {}),
+  };
+  writeFileSync(join(dir, "brand.yml"), yaml.dump(merged));
+  return merged;
+}
+
+// ── Style reference images ───────────────────────────────────────────────────
+// A generated style keeps its reference images in styles/<slug>/refs/ with a
+// manifest of the source URLs. The server sends the style's current refUrls
+// with each carousel job; if the local cache is missing or stale (refs were
+// added/removed/reordered on the web) we re-download. Built-in and hand-made
+// styles send no refUrls and skip all ref-guided behavior.
+const MAX_PROMPT_REFS = 6;
+
+async function ensureStyleRefs(styleSlug, styleRefUrls) {
+  const urls = (styleRefUrls ?? []).slice(0, 20);
+  if (urls.length === 0) return [];
+  const refsDir = join(ROOT, "styles", styleSlug, "refs");
+  const manifestPath = join(refsDir, "manifest.json");
+
+  const cachedPaths = () => {
+    const files = readdirSync(refsDir)
+      .filter((f) => /^ref-\d+\./.test(f))
+      .sort();
+    return files.map((f) => join(refsDir, f));
+  };
+
+  try {
+    const cached = JSON.parse(readFileSync(manifestPath, "utf8"))?.urls ?? [];
+    if (cached.length === urls.length && cached.every((u, i) => u === urls[i])) {
+      const paths = cachedPaths();
+      if (paths.length === urls.length) return paths.slice(0, MAX_PROMPT_REFS);
+    }
+  } catch {
+    // no/unreadable manifest → fall through to download
+  }
+
+  try {
+    rmSync(refsDir, { recursive: true, force: true });
+    mkdirSync(refsDir, { recursive: true });
+    const paths = [];
+    for (const [i, url] of urls.entries()) {
+      const res = await fetch(url);
+      if (!res.ok) throw new Error(`download failed (${res.status}): ${url}`);
+      const p = join(
+        refsDir,
+        `ref-${String(i + 1).padStart(2, "0")}${extFromUrl(url, res.headers.get("content-type"))}`,
+      );
+      writeFileSync(p, Buffer.from(await res.arrayBuffer()));
+      paths.push(p);
+    }
+    writeFileSync(manifestPath, JSON.stringify({ urls }, null, 2));
+    console.log(`  refreshed ${paths.length} style ref(s) for ${styleSlug}`);
+    return paths.slice(0, MAX_PROMPT_REFS);
+  } catch (e) {
+    // Refs are guidance, not a hard dependency — never fail the job over them.
+    console.error(`  style refs unavailable (${e.message}) — proceeding without refs`);
+    return [];
+  }
+}
+
 // ── Drafting via local Claude Code ──────────────────────────────────────────
 function readIfExists(p) {
   return existsSync(p) ? readFileSync(p, "utf8") : "";
@@ -82,12 +179,73 @@ function voiceContext() {
   return `\n## Voice rules (follow strictly — later files win on conflict)\n\n${parts.join("\n\n---\n\n")}\n`;
 }
 
-function draftingPrompt(job, templates, photoFiles) {
+// A video's poster frame sits next to the clip under the same stem — the
+// render engine derives the identical path, so whatever Claude studies here is
+// exactly the still the slide gets built on.
+function posterName(videoFile) {
+  return videoFile.replace(/\.[^.]+$/, "") + ".poster.jpg";
+}
+
+function photosContext(photoFiles, photosDir, hasVideos) {
+  if (photoFiles.length === 0) {
+    return hasVideos
+      ? `- No photos were attached — only the video(s) below. Every "photo" template slide you use must carry a video:.`
+      : `- No photos were attached — do not use the "photo" template.`;
+  }
+  return `- The user attached ${photoFiles.length} photo(s). FIRST, read each photo file to SEE what it shows:
+${photoFiles.map((f) => `  ${join(photosDir, f)}`).join("\n")}
+- Then place them deliberately with the "photo" template (photo: photos/<filename>): match each photo to the slide whose message it illustrates — a close-up photo belongs on the slide calling out that detail, a wide shot on a setup/mood slide.
+- If the user's request says to show or highlight something specific, the slides about it MUST use the photo that actually shows that thing. Never leave requested photos unused.
+- Photos get cropped to the slide shape from the CENTER at natural scale by default. Two per-slide controls, chosen from what you SAW in each photo:
+  - focus: the CENTER of the subject, as "X% Y%" coordinates on the original photo from the top-left — e.g. a monitor whose middle sits low-center-right is roughly focus: "65% 70%". (Keywords like top/bottom/left/right also work for gentle nudges without zoom.)
+  - zoom: how tight to go. 1 = whole photo (default). With zoom > 1 the renderer cuts a window out of the photo CENTERED on the focus point — the subject lands dead center of the slide. Use zoom: 1.6-2.5 when the subject is SMALL in the frame and the slide is ABOUT that subject — a feature close-up should fill the slide with the feature, not the whole room. Always pair zoom with precise "X% Y%" focus coordinates aimed at the subject's center.`;
+}
+
+// Videos ride the same "photo" template as stills — the clip simply plays
+// where the photo would sit. Claude can't watch an MP4, so it judges each clip
+// (and its focus/zoom) from the poster frame the worker pulled out of it.
+function videosContext(videoFiles, videosDir) {
+  if (videoFiles.length === 0) return "";
+  return `- The user attached ${videoFiles.length} video(s). A video slide MOVES: the clip plays full-bleed behind the slide's text, exactly where a photo would sit.
+- To use one, put \`video: videos/<filename>\` on a "photo" template slide — in place of \`photo:\`, never alongside it.
+- You cannot watch a video, but one frame was pulled out of each. READ these to SEE what each clip shows:
+${videoFiles.map((f) => `  ${join(videosDir, posterName(f))}   (a frame from videos/${f})`).join("\n")}
+- Spend the motion where it earns its place: give a video the slide whose message its movement actually sells (a process, a reveal, a thing in use), not a slide that a still would have carried just as well.
+- focus and zoom work exactly as they do for photos, judged from the poster frame above — the clip is cropped to the slide the same way.
+- Never leave an attached video unused.`;
+}
+
+const PALETTE_KEYS = [
+  "primary", "primaryLight", "primaryDark", "accent", "dark",
+  "lightBg", "lightBorder", "text", "textOnLight",
+];
+
+// The ref-guidance block shared by drafting and revision prompts. Empty when
+// the style has no reference images (built-in styles) — the prompts then read
+// exactly as they did before refs existed.
+function refsContext(refPaths) {
+  if (!refPaths || refPaths.length === 0) return "";
+  return `
+## Reference slides for this style — THE SOURCE OF TRUTH for look and format
+Read each of these images FIRST, before drafting anything (they are in order; the first is the style's pinned cover reference):
+${refPaths.map((p) => `- ${p}`).join("\n")}
+
+${skillSection("analyze")}
+
+${skillSection("map")}
+
+Two extra controls available because references exist:
+- Per-slide \`variant: flip\` mirrors a template's movable overlay (swatch stack, badge, caption block) to the opposite side of the slide.
+- A top-level \`colors:\` mapping recolors the whole deck — use it ONLY when the user's photos share a coherent palette worth building the deck from. Keys limited to: ${PALETTE_KEYS.join(", ")}. Values must be #hex sampled from the user's photos. Omit \`colors:\` entirely to keep the reference palette.
+`;
+}
+
+function draftingPrompt(job, templates, media, refPaths) {
   const exemplar = readFileSync(join(ROOT, "carousels", "demo", "slides.yml"), "utf8");
   return `You are drafting the slide copy for an Instagram carousel. Return ONLY a YAML document (no markdown fences, no commentary) in exactly this format:
 
 ${exemplar}
-
+${refsContext(refPaths)}
 ## Rules
 - Exactly ${job.slideCount} slides total.
 - Allowed "template" values (this style only): ${templates.join(", ")}.
@@ -95,7 +253,9 @@ ${exemplar}
 - Text markup: *word* renders in the accent color, _word_ renders italic. No other markup. No emoji. No em dashes. No ellipsis characters.
 - Keep each slide's text short — it is display type, max ~12 words per slide, use line breaks (YAML |- blocks).
 - Resource-style slides (template "resource") need: name, url (a real site — only include real, well-known URLs you are certain exist), and a short text description.
-${photoFiles.length > 0 ? `- The user attached photos, available as: ${photoFiles.join(", ")}. Use the "photo" template with photo: photos/<filename> for slides that should feature them.` : `- No photos were attached — do not use the "photo" template.`}
+- If a template is built for color swatches (e.g. "palette"), give those slides swatches: ["#hex", "#hex", ...] (3-6 real, deliberate colors) plus a short text label. Pick colors that genuinely work together — they are the content.
+${photosContext(media.photoFiles, media.photosDir, media.videoFiles.length > 0)}
+${videosContext(media.videoFiles, media.videosDir)}
 - Never invent statistics, follower counts, or claims. Plain honest copy.
 ${voiceContext()}
 ## The carousel to draft
@@ -104,19 +264,158 @@ ${job.prompt ?? "(no prompt — build the carousel around the attached photos)"}
 `;
 }
 
-async function draftSlides(job, styleDir, photoFiles) {
+// The deck as the user counts it: "# slide N" markers before each slide so
+// notes like "slide 3" and the YAML agree on numbering (slide 1 = cover).
+function numberedDeck(previousYml) {
+  try {
+    const spec = yaml.load(previousYml);
+    if (!Array.isArray(spec?.slides) || spec.slides.length === 0) return previousYml;
+    const total = spec.slides.length;
+    const role = (i) => (i === 0 ? "cover" : i === total - 1 ? "closer/CTA" : "middle");
+    const head = { ...spec };
+    delete head.slides;
+    const headYml = Object.keys(head).length > 0 ? yaml.dump(head, { lineWidth: 100 }) : "";
+    const body = spec.slides
+      .map(
+        (s, i) =>
+          `  # ── slide ${i + 1} of ${total} (${role(i)}) ──\n` +
+          yaml.dump([s], { lineWidth: 100 }).replace(/^(?=.)/gm, "  "),
+      )
+      .join("");
+    return `${headYml}slides:\n${body}`;
+  } catch {
+    return previousYml; // unparseable? show it as-is rather than fail the job
+  }
+}
+
+// Revision jobs get a fundamentally different prompt: the task is EDITING an
+// existing YAML, not drafting a new one. Untouched slides must survive
+// byte-for-byte — that's what makes per-slide notes trustworthy.
+function revisionPrompt(job, templates, media, refPaths, brand) {
+  return `You are revising an existing Instagram carousel. Below is the CURRENT
+slide deck (YAML, with "# slide N" markers showing how the user counts slides —
+slide 1 is the cover) and the user's notes. Apply the notes faithfully.
+
+## The current deck
+
+${numberedDeck(job.previousSlidesYml)}
+
+## The user's notes
+
+${job.feedback ? `"${job.feedback}"` : `(No written notes — the only request is to work the newly added photos and videos below into the deck.)`}
+${refsContext(refPaths)}
+## Attached photos and videos
+${photosContext(media.photoFiles, media.photosDir, media.videoFiles.length > 0)}
+${videosContext(media.videoFiles, media.videosDir)}
+${
+  job.newPhotoFiles?.length || job.newVideoFiles?.length
+    ? `
+## Media added WITH this revision
+These file(s) were uploaded alongside the notes — they did not exist when the
+current deck was drafted, so the deck cannot be using them yet:
+${job.newPhotoFiles.map((f) => `  photos/${f}`).join("\n")}
+${job.newVideoFiles.map((f) => `  videos/${f}   (read ${posterName(f)} in that folder to see it)`).join("\n")}
+Read each one to SEE it, then place it where the notes say. If a note names a
+new file but no slide, put it on the slide whose message it clearly
+illustrates (switching that slide to the "photo" template if needed) — never
+leave newly added media unused.
+`
+    : ""
+}
+
+## How to read the notes
+- Notes may point at a slide by number ("slide 3" = the "# slide 3" marker above) or by quoting text that appears on it — resolve either against the deck above.
+- Notes may be PER-SLIDE (surgical: change only what that note describes, on that slide) or GLOBAL ("punchier throughout", "less salesy", "use my brand font"). A global note applies to EVERY slide it concerns — applying it to only one or two slides is a failure, not caution.
+
+## Global look controls
+Use these ONLY when a note asks for a deck-wide look change (they live at the top level of the YAML, next to "style:"):
+- \`fonts:\` mapping — keys: heading, body, mono (plus headingWeight, a number). Allowed families: ${[...Object.keys(FONT_SPECS), ...(brand?.customFonts ?? []).map((f) => f.family)].join(", ")}. The user's saved brand fonts are heading "${brand?.fonts?.heading ?? ""}", body "${brand?.fonts?.body ?? ""}", mono "${brand?.fonts?.mono ?? ""}" — a note like "use my brand font" means setting exactly those. A note like "use the original font" / "the style's font" means REMOVING any top-level fonts: mapping so the style's own typography returns.
+- \`colors:\` mapping — keys limited to: ${PALETTE_KEYS.join(", ")}, values #hex.
+Fonts and colors exist ONLY at the top level — never answer a look note by rewriting slide text or switching templates.
+
+## Hard rules
+- Output ONLY the full revised YAML document (no fences, no commentary, and WITHOUT the "# slide N" markers), same format as the current deck.
+- A slide that no per-slide note mentions and no global note affects — or that the notes call good ("perfect", "great", "ok", "keep", a checkmark) — MUST be copied into your output COMPLETELY UNCHANGED: identical template, identical text, character for character.
+- Where a note asks for a change, make that change everywhere the note applies — and change nothing else.
+- If a note says a slide's content type is wrong (e.g. "no resource here, just advice"), switch that slide's template (allowed: ${templates.join(", ")}) and rewrite that slide only.
+- Keep the slide count at ${job.slideCount} unless a note explicitly says to add or remove a slide.
+- Same text markup rules as always: *word* = accent/headline voice, _word_ = italic. No emoji, no em dashes.
+${voiceContext()}`;
+}
+
+// Post-revision check: did the revised deck actually honor the notes? Same
+// philosophy as the rendered-slide self-check — inspect your own output
+// against the ground truth (there: reference images, here: the user's notes).
+// Returns [] when everything applied; misses feed one corrective retry.
+async function verifyNotesApplied(job, revisedYml) {
+  const prompt = `A user asked for revisions to an Instagram carousel. Compare the decks and judge whether every request in the notes was honored.
+
+## Original deck
+${numberedDeck(job.previousSlidesYml)}
+
+## The user's notes
+"${job.feedback}"
+
+## Revised deck
+${revisedYml}
+
+Check each distinct request in the notes (notes reference slides by number — see the markers — or by quoting their text; global notes like "punchier throughout" or "use my brand font" must be applied everywhere they concern, font/color notes via the top-level fonts:/colors: keys). Also flag slides that changed although no note asked for it.
+
+Output ONLY YAML, no commentary. If every request was honored and nothing changed unasked:
+applied: true
+Otherwise:
+missed:
+  - "<the request, and what the revised deck failed to do>"`;
+  const { text: stdout } = await runAgent({
+    agent: job.agentCli,
+    prompt,
+    mode: "text",
+    timeoutMs: 5 * 60 * 1000,
+  });
+  const verdict = yaml.load(stdout.replace(/^```(?:yaml)?\n?/m, "").replace(/\n?```\s*$/m, "").trim());
+  return Array.isArray(verdict?.missed) ? verdict.missed.map(String) : [];
+}
+
+const HEX_RE = /^#[0-9a-fA-F]{3,8}$/;
+
+// Per-carousel color overrides may only touch known palette keys with real
+// hex values — anything else is silently dropped rather than failing the job.
+function sanitizeColors(colors) {
+  if (!colors || typeof colors !== "object" || Array.isArray(colors)) return null;
+  const out = {};
+  for (const [k, v] of Object.entries(colors)) {
+    if (PALETTE_KEYS.includes(k) && HEX_RE.test(String(v))) out[k] = String(v);
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+
+async function draftSlides(job, styleDir, media, refPaths, brand) {
   const templates = readdirSync(join(styleDir, "templates"))
     .filter((f) => f.endsWith(".html"))
     .map((f) => f.replace(/\.html$/, ""));
 
-  const prompt = draftingPrompt(job, templates, photoFiles);
+  // A revision can carry a note, newly added photos, or both.
+  const isRevision = Boolean(
+    job.previousSlidesYml && (job.feedback || (job.newPhotoUrls ?? []).length),
+  );
+  const basePrompt = isRevision
+    ? revisionPrompt(job, templates, media, refPaths, brand)
+    : draftingPrompt(job, templates, media, refPaths);
 
+  // Misses from the notes-applied check feed the retry, so attempt 2 knows
+  // exactly what attempt 1 got wrong instead of rolling the dice again.
+  let missNote = "";
   for (let attempt = 1; attempt <= 2; attempt++) {
-    const { stdout } = await execFileAsync(
-      "claude",
-      ["-p", prompt, "--output-format", "text"],
-      { maxBuffer: 10 * 1024 * 1024, timeout: 10 * 60 * 1000 },
-    );
+    // mode "read" lets the agent actually look at the attached photos
+    // (--allowedTools Read on Claude, a read-only sandbox rooted at ROOT on
+    // Codex — job dirs live under ROOT, so relative and absolute paths work).
+    const { text: stdout } = await runAgent({
+      agent: job.agentCli,
+      prompt: basePrompt + missNote,
+      mode: "read",
+      cwd: ROOT,
+      timeoutMs: 10 * 60 * 1000,
+    });
     const raw = stdout.replace(/^```(?:yaml)?\n?/m, "").replace(/\n?```\s*$/m, "").trim();
     try {
       const spec = yaml.load(raw);
@@ -124,11 +423,49 @@ async function draftSlides(job, styleDir, photoFiles) {
       if (!Array.isArray(slides) || slides.length === 0) throw new Error("no slides array");
       for (const slide of slides) {
         if (!templates.includes(slide.template)) throw new Error(`unknown template ${slide.template}`);
-        if (slide.photo && !photoFiles.includes(slide.photo.replace(/^photos\//, ""))) {
+        if (slide.photo && !media.photoFiles.includes(slide.photo.replace(/^photos\//, ""))) {
           throw new Error(`unknown photo ${slide.photo}`);
         }
+        if (slide.video && !media.videoFiles.includes(slide.video.replace(/^videos\//, ""))) {
+          throw new Error(`unknown video ${slide.video}`);
+        }
+        // A slide has one background. Asked for both, the moving one wins —
+        // that's the one the user went out of their way to attach.
+        if (slide.video && slide.photo) delete slide.photo;
+        if (slide.variant !== undefined && slide.variant !== "flip") delete slide.variant;
       }
-      return { spec: { style: job.styleSlug, slides }, raw };
+      const colors = sanitizeColors(spec.colors);
+      // Uploaded families count too — see sanitizeFonts.
+      const fonts = sanitizeFonts(
+        spec.fonts,
+        (brand?.customFonts ?? []).map((f) => f.family),
+      );
+      const result = {
+        spec: {
+          style: job.styleSlug,
+          ...(colors ? { colors } : {}),
+          ...(fonts ? { fonts } : {}),
+          slides,
+        },
+        raw,
+      };
+      // Revisions get one more gate: were the notes actually applied? A miss
+      // on attempt 1 retries with the misses named; on attempt 2 we keep the
+      // deck anyway — like refs, this check guides, it never fails the job.
+      // (Photos-only revisions have no notes to verify against.)
+      if (isRevision && job.feedback && attempt === 1) {
+        try {
+          const missed = await verifyNotesApplied(job, yaml.dump(result.spec, { lineWidth: 100 }));
+          if (missed.length > 0) {
+            console.log(`  notes check: ${missed.length} request(s) not applied — retrying`);
+            missNote = `\n\n## Your previous attempt failed review\nIt missed these requests — apply them this time (everything else above still holds):\n${missed.map((m) => `- ${m}`).join("\n")}\n\nYour previous attempt, for reference:\n\n${raw}\n`;
+            continue;
+          }
+        } catch (e) {
+          console.error(`  notes check skipped (${e.message})`);
+        }
+      }
+      return result;
     } catch (e) {
       console.error(`Draft attempt ${attempt} invalid: ${e.message}`);
       if (attempt === 2) throw new Error(`Drafting failed: ${e.message}`);
@@ -145,21 +482,77 @@ async function runJob(job) {
 
   const dir = join(ROOT, "carousels", `web-${job.id.slice(0, 8)}`);
   mkdirSync(join(dir, "photos"), { recursive: true });
+  mkdirSync(join(dir, "videos"), { recursive: true });
+  // Older servers don't send these — default to applying the brand, matching
+  // the checkboxes' default on the web.
+  const brand = writeBrandFile(dir, job.brand, {
+    fonts: job.applyBrandFonts !== false,
+    colors: job.applyBrandColors !== false,
+  });
 
-  // Download attached photos.
+  // Download attached media. Photos and videos arrive in one list (the server
+  // has always called it photoUrls); the file extension decides which is
+  // which, and each lands in its own folder. On revisions the server also
+  // names which URLs arrived with the feedback note — those get called out in
+  // the prompt.
   const photoFiles = [];
+  const videoFiles = [];
+  const newUrls = new Set(job.newPhotoUrls ?? []);
+  job.newPhotoFiles = [];
+  job.newVideoFiles = [];
   for (const url of job.photoUrls ?? []) {
     const res = await fetch(url);
-    if (!res.ok) throw new Error(`Photo download failed: ${url}`);
+    if (!res.ok) throw new Error(`Media download failed: ${url}`);
     const name = decodeURIComponent(new URL(url).pathname.split("/").pop() ?? "photo.jpg");
     const safe = name.replace(/[^\w.-]/g, "_");
-    writeFileSync(join(dir, "photos", safe), Buffer.from(await res.arrayBuffer()));
-    photoFiles.push(safe);
+    const video = isVideoPath(safe);
+    writeFileSync(join(dir, video ? "videos" : "photos", safe), Buffer.from(await res.arrayBuffer()));
+    (video ? videoFiles : photoFiles).push(safe);
+    if (newUrls.has(url)) (video ? job.newVideoFiles : job.newPhotoFiles).push(safe);
+  }
+
+  // Bake EXIF rotation into the pixels — otherwise Claude reads sideways
+  // iPhone photos and its focus coordinates land in the wrong place.
+  if (photoFiles.length > 0) {
+    await execFileAsync(
+      "node",
+      [join(ROOT, "src", "normalize-photos.js"), join(dir, "photos")],
+      { maxBuffer: 10 * 1024 * 1024, timeout: 5 * 60 * 1000 },
+    );
   }
 
+  // Pull a still out of each clip so the drafting pass can SEE it — Claude
+  // reads images, not MP4s.
+  //
+  // This is also the gate: if the user attached a clip and this computer can't
+  // do video, fail NOW — before drafting spends Claude tokens on a deck we
+  // can't deliver. Falling back to stills would hand back a carousel that
+  // looks finished and quietly isn't the one they asked for.
+  if (videoFiles.length > 0) {
+    await assertFfmpeg();
+    for (const f of videoFiles) {
+      try {
+        await posterFrame(join(dir, "videos", f), join(dir, "videos", posterName(f)));
+      } catch (e) {
+        throw new Error(`Couldn't read the video "${f}" — is it a valid MP4, MOV or WebM? (${e.message})`);
+      }
+    }
+  }
+
+  const media = {
+    photoFiles,
+    photosDir: join(dir, "photos"),
+    videoFiles,
+    videosDir: join(dir, "videos"),
+  };
+
+  // Reference images for generated styles — drafting and the self-check
+  // study these alongside the user's photos.
+  const refPaths = await ensureStyleRefs(job.styleSlug, job.styleRefUrls);
+
   // Draft (Claude writes YAML to stdout only; we validate + write files).
-  const { spec } = await draftSlides(job, styleDir, photoFiles);
-  const slidesYml = yaml.dump(spec, { lineWidth: 100 });
+  const { spec } = await draftSlides(job, styleDir, media, refPaths, brand);
+  let slidesYml = yaml.dump(spec, { lineWidth: 100 });
   writeFileSync(join(dir, "slides.yml"), slidesYml);
 
   // Render.
@@ -170,22 +563,131 @@ async function runJob(job) {
     { maxBuffer: 10 * 1024 * 1024, timeout: 15 * 60 * 1000 },
   );
 
+  // Self-check: LOOK at the rendered slides and fix what's off. For photo
+  // slides that's framing (focus/zoom are estimates until you see the
+  // output); when the style has reference images it's also a per-slide
+  // comparison against them — role to role, cover vs cover, closer vs
+  // closer — with overlay flips and swatch corrections as fixes.
+  // Video slides render a poster-frame still alongside their MP4, framed by
+  // the same focus/zoom — so the framing check works on them unchanged.
+  const photoSlideIdx = spec.slides
+    .map((s, i) => (s.photo || s.video ? i : -1))
+    .filter((i) => i !== -1);
+  if (photoSlideIdx.length > 0 || refPaths.length > 0) {
+    try {
+      const total = spec.slides.length;
+      const roleOf = (i) => (i === 0 ? "cover" : i === total - 1 ? "closer/CTA" : "middle");
+      const checkIdx = refPaths.length > 0 ? spec.slides.map((_, i) => i) : photoSlideIdx;
+      const slideDesc = (i) => {
+        const s = spec.slides[i];
+        const bits = [`template ${s.template}`];
+        if (s.photo) bits.push(`photo ${s.photo}, focus ${s.focus ?? "center"}, zoom ${s.zoom ?? 1}`);
+        if (s.video) bits.push(`video ${s.video} (this PNG is a frame of it), focus ${s.focus ?? "center"}, zoom ${s.zoom ?? 1}`);
+        if (s.variant) bits.push(`variant ${s.variant}`);
+        if (Array.isArray(s.swatches)) bits.push(`swatches [${s.swatches.join(", ")}]`);
+        return `- slide ${i + 1} of ${total} (${roleOf(i)}): ${join(outDir, `slide-${String(i + 1).padStart(2, "0")}.png`)} — ${bits.join("; ")}`;
+      };
+      const checkPrompt = `You built an Instagram carousel; now inspect your own output.
+
+The user's request: "${job.prompt ?? ""}"${job.feedback ? `\nThe user's revision notes: "${job.feedback}"` : ""}
+
+Read these RENDERED slides (what followers will actually see), with their current values:
+${checkIdx.map(slideDesc).join("\n")}
+${refPaths.length > 0 ? `
+Then read the style's REFERENCE images — the originals this carousel must look like it belongs with (in order; the first is the cover reference):
+${refPaths.map((p) => `- ${p}`).join("\n")}
+
+${skillSection("compare")}
+` : ""}${photoFiles.length > 0 || videoFiles.length > 0 ? `
+The ORIGINAL frames the photo/video slides were cropped from:
+${photoFiles.map((f) => `- ${join(dir, "photos", f)}`).join("\n")}
+${videoFiles.map((f) => `- ${join(dir, "videos", posterName(f))} (from videos/${f})`).join("\n")}
+
+For each photo or video slide ask: is the subject the user cares about actually prominent and well-framed in THIS crop — or did the crop land on the wrong thing (background, another object)? Remember focus is "X% Y%" coordinates ON THE ORIGINAL photo, and with zoom the crop is a window CENTERED on that point — so focus must be the subject's center.
+` : ""}
+Output ONLY YAML, no commentary. If every slide passes:
+ok: true
+Otherwise list corrections — only slides needing change, only keys you are changing:
+fixes:
+  - slide: 4
+    focus: "78% 62%"
+    zoom: 2.0
+    variant: flip          # mirror the overlay side ("" to un-flip)
+    swatches: ["#a1b2c3"]  # only for slides that already have swatches
+Do not rewrite any slide's text and do not switch templates.`;
+      const { text: stdout } = await runAgent({
+        agent: job.agentCli,
+        prompt: checkPrompt,
+        mode: "read",
+        cwd: ROOT,
+        timeoutMs: 10 * 60 * 1000,
+      });
+      const verdict = yaml.load(stdout.replace(/^```(?:yaml)?\n?/m, "").replace(/\n?```\s*$/m, "").trim());
+      if (verdict?.fixes?.length) {
+        for (const fix of verdict.fixes) {
+          const i = Number(fix.slide) - 1;
+          const s = spec.slides[i];
+          if (!s) continue;
+          if (s.photo || s.video) {
+            if (fix.focus) s.focus = String(fix.focus);
+            if (fix.zoom) s.zoom = Number(fix.zoom);
+          }
+          if (fix.variant === "flip") s.variant = "flip";
+          else if (fix.variant === "") delete s.variant;
+          if (Array.isArray(fix.swatches) && Array.isArray(s.swatches)) {
+            const clean = fix.swatches.map(String).filter((c) => HEX_RE.test(c));
+            if (clean.length >= 1 && clean.length <= 10) s.swatches = clean;
+          }
+        }
+        slidesYml = yaml.dump(spec, { lineWidth: 100 });
+        writeFileSync(join(dir, "slides.yml"), slidesYml);
+        console.log(`  self-check: reframing ${verdict.fixes.length} slide(s), re-rendering`);
+        await execFileAsync(
+          "node",
+          [join(ROOT, "src", "render.js"), dir, "--aspect", job.aspect, "--out", outDir],
+          { maxBuffer: 10 * 1024 * 1024, timeout: 15 * 60 * 1000 },
+        );
+      } else {
+        console.log("  self-check: framing OK");
+      }
+    } catch (e) {
+      console.error(`  self-check skipped: ${e.message}`);
+    }
+  }
+
   // Upload results (client-upload tokens are minted by the server per file,
   // scoped to this job; the PNG bytes go straight to Blob storage).
-  const pngs = readdirSync(outDir).filter((f) => f.endsWith(".png")).sort();
+  // One result per slide, in deck order: the MP4 where a video slide
+  // composited, the PNG otherwise. A video slide leaves both on disk — the PNG
+  // is its fallback and what the framing check read — so the MP4 wins the slot.
+  const bySlide = new Map();
+  for (const f of readdirSync(outDir).filter((f) => /^slide-\d+\.(png|mp4)$/.test(f)).sort()) {
+    const stem = f.slice(0, f.lastIndexOf("."));
+    if (f.endsWith(".mp4") || !bySlide.has(stem)) bySlide.set(stem, f);
+  }
   const resultUrls = [];
-  for (const png of pngs) {
-    const blob = await upload(`carousel/results/${job.id}/${png}`, readFileSync(join(outDir, png)), {
+  for (const stem of [...bySlide.keys()].sort()) {
+    const file = bySlide.get(stem);
+    const isVideo = file.endsWith(".mp4");
+    const blob = await upload(`carousel/results/${job.id}/${file}`, readFileSync(join(outDir, file)), {
       access: "public",
       handleUploadUrl: `${BASE_URL}/api/carousel/upload`,
       clientPayload: JSON.stringify({ workerToken: TOKEN }),
-      contentType: "image/png",
+      contentType: isVideo ? "video/mp4" : "image/png",
+      // Clips are far bigger than slide PNGs; chunked upload survives them.
+      ...(isVideo ? { multipart: true } : {}),
     });
     resultUrls.push(blob.url);
   }
 
   await api("complete", { jobId: job.id, ok: true, slidesYml, resultUrls });
   console.log(`✓ job ${job.id}: ${resultUrls.length} slides uploaded`);
+
+  // The slides are safely in Blob storage now, so the local scratch dir (photos
+  // + rendered PNGs, tens of MB per job) has done its job. Without this it
+  // accumulates forever under carousels/. Only reached on success — a failed
+  // job keeps its dir for debugging (the main loop's catch handles those).
+  rmSync(dir, { recursive: true, force: true });
 }
 
 // ── Main loop ────────────────────────────────────────────────────────────────
@@ -200,8 +702,18 @@ while (true) {
       firstPoll = false;
     }
     if (job) {
+      lastJobAt = Date.now();
       try {
-        await runJob(job);
+        if (job.kind === "style") {
+          const { runStyleJob } = await import("./style.js");
+          await runStyleJob(job, { api, execFileAsync, ROOT, TOKEN, BASE_URL, writeBrandFile });
+        } else if (job.kind === "carousel" || !job.kind) {
+          await runJob(job);
+        } else {
+          throw new Error(
+            "This computer's worker is outdated for this job — update with: npx --yes goosetools-worker@latest install",
+          );
+        }
       } catch (e) {
         console.error(`✗ job ${job.id}: ${e.message}`);
         await api("complete", { jobId: job.id, ok: false, error: e.message }).catch(() => {});
@@ -211,5 +723,5 @@ while (true) {
   } catch (e) {
     console.error(`Poll failed (will retry): ${e.message}`);
   }
-  await new Promise((r) => setTimeout(r, POLL_MS));
+  await new Promise((r) => setTimeout(r, pollDelay()));
 }