@koda-sl/baker-cli 0.394.0-dev.d28cef496 → 0.396.0-dev.88120240

package/README.md

@@ -3830,7 +3830,7 @@ Starting a batch returns 202 + a `generationId`; the CLI polls until the takes s
 ```bash
 baker studio generate "a friendly golden retriever in a bright modern living room" --aspect-ratio 16:9
 baker studio generate "hero shot of a matte black water bottle on wet marble, studio light" \
-  --model google/gemini-3-pro-image-preview --image-size 2K --aspect-ratio 4:5 --count 3
+  --model google/gemini-3-pro-image --image-size 2K --aspect-ratio 4:5 --count 3
 baker studio generate "home office hero, warm minimalist, natural light, 35mm photo" \
   --reference "https://i.pinimg.com/…/pin1.jpg,./src/brand/logos/product.png,j57abc123def456ghi789"
 baker studio generate "founder-style selfie, kitchen background" --skill ugc-selfie-hook
@@ -3838,13 +3838,13 @@ baker studio generate "flat geometric mascot, brand palette" \
   --model recraft/recraft-v4.1-pro-vector --rgb-colors "[[10,10,10],[255,80,0]]" --bg-rgb "[255,255,255]"
 ```
 
-**Models** (`--model`, default `google/gemini-3.1-flash-image-preview`):
+**Models** (`--model`, default `google/gemini-3.1-flash-image`):
 
 | Model | Best for | Aspect ratios | Sizes |
 |---|---|---|---|
-| `google/gemini-3.1-flash-image-preview` **(default)** | Fast iteration, reference editing, extreme aspect ratios (Nano Banana flash) | standard **+** `1:4` `4:1` `1:8` `8:1` | `0.5K`–`4K` |
+| `google/gemini-3.1-flash-image` **(default)** | Fast iteration, reference editing, extreme aspect ratios (Nano Banana flash) | standard **+** `1:4` `4:1` `1:8` `8:1` | `0.5K`–`4K` |
 | `google/gemini-3.1-flash-lite-image` | Cheapest tier (Nano Banana 2 Lite) — half the flash price per output token. High-volume variants and any 1K-sufficient frame, portrait ad formats included | standard **+** `1:4` `4:1` `1:8` `8:1` | `1K` **only** |
-| `google/gemini-3-pro-image-preview` | Highest fidelity (Nano Banana Pro) — strong prompt adherence and reference grounding | standard set | `1K` `2K` `4K` |
+| `google/gemini-3-pro-image` | Highest fidelity (Nano Banana Pro) — strong prompt adherence and reference grounding | standard set | `1K` `2K` `4K` |
 | `openai/gpt-image-2` | Photoreal + cleanest in-image text — ad/landing reproduction | standard set **minus** `4:5` `5:4` | *(none — derived from the ratio)* |
 | `openai/gpt-5.4-image-2` | **Legacy** — accepted so canvases authored before the gpt-image-2 switch still re-run. Don't pick it for new work. | standard set | `1K` `2K` `4K` (ignored upstream) |
 | `recraft/recraft-v4.1-pro-vector` | Vector/flat/SVG-style with palette control. Writes **SVG**, so its output cannot be fed back as a reference | `1:1` `4:3` `3:4` `16:9` `9:16` **only** | *(none — refuses `image_size`)* |
@@ -3853,7 +3853,7 @@ Standard aspect ratios: `1:1` `2:3` `3:2` `3:4` `4:3` `4:5` `5:4` `9:16` `16:9`
 
 `openai/gpt-image-2` accepts neither `image_size` nor the `4:5` / `5:4` portrait ratios — OpenAI picks the pixel dimensions from the ratio. To ship a 4:5 Meta feed ad from it, render the hero at `3:4` and adapt with `image_aspect_adapt`; the scaffolders do this for you.
 
-`google/gemini-3.1-flash-lite-image` renders at `1K` and nothing else — `2K` / `4K` is a provider 400 (`resolution: not supported. Accepted: 1K`), not a soft clamp. It costs half of `google/gemini-3.1-flash-image-preview` per output image token ($0.00003 vs $0.00006), so it is the cheap-iteration tier for images. Keep hero stills and reference sheets that need `2K`+ on the flash or pro tier.
+`google/gemini-3.1-flash-lite-image` renders at `1K` and nothing else — `2K` / `4K` is a provider 400 (`resolution: not supported. Accepted: 1K`), not a soft clamp. It costs half of `google/gemini-3.1-flash-image` per output image token ($0.00003 vs $0.00006), so it is the cheap-iteration tier for images. Keep hero stills and reference sheets that need `2K`+ on the flash or pro tier.
 
 `recraft/recraft-v4.1-pro-vector` is the narrowest of the roster in three ways, all read off its live endpoint schema: it renders **five** ratios (no `4:5` / `5:4` / `2:3` / `3:2` / `21:9`, so a portrait ad shape snaps to `3:4`), it has **no `image_size`** — the provider accepts one and ignores it, which is why it is refused here — and it takes **exactly one** reference image against 14-16 elsewhere. Its output is an SVG, and the image models read only JPG, PNG and WebP, so a Recraft take cannot be used as a reference for the next render.
 
@@ -3863,7 +3863,7 @@ A knob the chosen model does not advertise is **refused, not silently dropped**
 
 | Flag | Description |
 |---|---|
-| `--model` | Model id (default `google/gemini-3.1-flash-image-preview`) |
+| `--model` | Model id (default `google/gemini-3.1-flash-image`) |
 | `--aspect-ratio` | Output aspect ratio (default `1:1`) |
 | `--count` | Takes to render, 1–8 (default 1) |
 | `--reference` | Comma-separated visual references, in order: **library image ids**, **local file paths**, and/or **image URLs**. Paths and URLs are added to the media library first and passed as ids — the studio takes library ids only, so the client can see what grounded the render and the reference stays reusable. The biggest quality lever there is. |
@@ -3971,7 +3971,7 @@ Compact output per take is `{ slot, status, imageId | videoId, url, inLibrary, e
 | `lifestyle-scene` | `openai/gpt-image-2` | `4:5` | 3 | **yes** |
 | `cinematic-still` | `google/gemini-3-pro-image-preview` | `16:9` | 3 | no |
 | `brand-icon` | `recraft/recraft-v4.1-pro-vector` | `1:1` | 4 | no |
-| `background-plate` | `google/gemini-3.1-flash-image-preview` | `4:5` | 3 | no |
+| `background-plate` | `google/gemini-3.1-flash-image` | `4:5` | 3 | no |
 
 A skill fills only what you did **not** pin — `--model`, `--aspect-ratio` and `--count` always win. Which means a skill can change the model, and the model decides what the rest of the flags may be: `--skill brand-icon` lands on Recraft, so it takes one reference image rather than fourteen, refuses `--image-size`, and writes SVG that cannot be fed back in as a reference. The CLI resolves the skill's model before checking the reference count, so an over-long `--reference` list is refused before anything is uploaded.
 
@@ -4163,7 +4163,7 @@ A re-run with no changes hits the cache for every node — total runtime drops t
       "type": "text_generate",
       "inputs": { "topic": "$ref:topic.text" },
       "params": {
-        "model": "google/gemini-3.1-flash-image-preview",
+        "model": "google/gemini-3.1-flash-image",
         "prompt": "Write a 6-word tagline for {{topic}}."
       }
     }
@@ -4345,7 +4345,7 @@ Example pipeline:
 { "id": "font", "type": "ingest", "params": { "source": "url", "url": "https://cdn.example.com/brand.woff2", "expect": "font" } }
 { "id": "specimen", "type": "font_specimen", "inputs": { "font": "$ref:font.asset" }, "params": {} }
 { "id": "gen", "type": "image_generate", "inputs": { "reference": "$ref:specimen.image" },
-  "params": { "model": "google/gemini-3.1-flash-image-preview", "prompt": "Launch poster headlined 'SALE ENDS FRIDAY' using the exact typeface from the reference image" } }
+  "params": { "model": "google/gemini-3.1-flash-image", "prompt": "Launch poster headlined 'SALE ENDS FRIDAY' using the exact typeface from the reference image" } }
 ```
 
 ---
@@ -4484,13 +4484,13 @@ No `image_size`: OpenAI derives the pixel dimensions from the ratio, so a size i
 
 Kept only so canvases authored before the gpt-image-2 switch still validate and re-run unchanged — `baker canvas rerun` replays a recorded canvas verbatim. It keeps the full standard ratio set (including `4:5` / `5:4`) and still accepts `image_size`, which the provider ignores. Prefer `openai/gpt-image-2` for anything new.
 
-###### Model: `google/gemini-3.1-flash-image-preview`
+###### Model: `google/gemini-3.1-flash-image` (legacy id `google/gemini-3.1-flash-image-preview` still accepted)
 
 Gemini flash image model — the default. Fast iteration, reference editing, extreme aspect ratios, and the `0.5K` size for cheap previews.
 
 | Name | Type | Required | Notes |
 |---|---|---|---|
-| `model` | literal | yes | `"google/gemini-3.1-flash-image-preview"` |
+| `model` | literal | yes | `"google/gemini-3.1-flash-image"` |
 | `prompt` | string | yes | non-empty |
 | `aspect_ratio` | enum | no | EXTREME AR |
 | `image_size` | enum | no | `0.5K \| 1K \| 2K \| 4K` |
@@ -4506,20 +4506,20 @@ Gemini flash image model — the default. Fast iteration, reference editing, ext
 | `aspect_ratio` | enum | no | EXTREME AR — keeps `4:5` / `5:4`, so Meta/Instagram portrait formats come straight out of it |
 | `image_size` | enum | no | `1K` only — `2K` / `4K` is a hard provider 400 (`resolution: not supported. Accepted: 1K`), so `validate` rejects it before the call costs anything |
 
-Reach for it for high-volume variants and any frame `1K` covers. Send hero stills and the `image_reference_sheet` subject sheet — anything that needs `2K`+ — to `google/gemini-3.1-flash-image-preview` or `google/gemini-3-pro-image-preview`. Registered for `image_generate` only; `image_reference_sheet` and `image_aspect_adapt` do not accept it.
+Reach for it for high-volume variants and any frame `1K` covers. Send hero stills and the `image_reference_sheet` subject sheet — anything that needs `2K`+ — to `google/gemini-3.1-flash-image` or `google/gemini-3-pro-image`. Registered for `image_generate` only; `image_reference_sheet` and `image_aspect_adapt` do not accept it.
 
 ```json
 { "id": "variant_a", "type": "image_generate",
   "params": { "model": "google/gemini-3.1-flash-lite-image", "prompt": "Portrait feed ad for a citrus energy drink …", "aspect_ratio": "4:5", "image_size": "1K" } }
 ```
 
-###### Model: `google/gemini-3-pro-image-preview`
+###### Model: `google/gemini-3-pro-image` (legacy id `google/gemini-3-pro-image-preview` still accepted)
 
 "Nano Banana Pro" — heavier, higher-quality Gemini.
 
 | Name | Type | Required | Notes |
 |---|---|---|---|
-| `model` | literal | yes | `"google/gemini-3-pro-image-preview"` |
+| `model` | literal | yes | `"google/gemini-3-pro-image"` |
 | `prompt` | string | yes | non-empty |
 | `aspect_ratio` | enum | no | STD AR |
 | `image_size` | enum | no | `1K \| 2K \| 4K` |
@@ -4563,7 +4563,7 @@ The sheet prompt is baked into the backend — there is no `prompt` param. `subj
 
 | Name | Type | Required | Notes |
 |---|---|---|---|
-| `model` | enum | yes | one of `google/gemini-3-pro-image-preview`, `google/gemini-3.1-flash-image-preview` |
+| `model` | enum | yes | one of `google/gemini-3-pro-image`, `google/gemini-3.1-flash-image` (their `-preview` ids still accepted) |
 | `subject_description` | string | yes | exact subject wording — reuse verbatim downstream |
 | `subject_type` | enum | yes | `character \| person \| product` — picks the template + default views |
 | `views` | string[] | no | 2–6 view labels; defaults per `subject_type` (below) |
@@ -4590,7 +4590,7 @@ Default views per `subject_type`:
 
 Guidance:
 - 3–4 full-body views at `16:9` is the sweet spot for characters; more views shrink each figure and lose face detail.
-- Use `google/gemini-3.1-flash-image-preview` while iterating; switch to `google/gemini-3-pro-image-preview` at `2K`+ for final 6-view sheets.
+- Use `google/gemini-3.1-flash-image` while iterating; switch to `google/gemini-3-pro-image` at `2K`+ for final 6-view sheets.
 - Feed the whole sheet downstream as one `reference` input — don't crop individual views.
 
 **Example** — two photos of a sneaker → product sheet → consistent hero shot:
@@ -4603,14 +4603,14 @@ Guidance:
     { "id": "b", "type": "ingest", "params": { "source": "url", "url": "https://example.com/sneaker-side.jpg", "expect": "image" } },
     { "id": "sheet", "type": "image_reference_sheet",
       "inputs": { "references": ["$ref:a.asset", "$ref:b.asset"] },
-      "params": { "model": "google/gemini-3-pro-image-preview",
+      "params": { "model": "google/gemini-3-pro-image",
                   "subject_description": "navy leather low-top sneaker with white sole and gold logo",
                   "subject_type": "product",
                   "style": "matte black studio background, soft even key light",
                   "aspect_ratio": "16:9", "image_size": "2K" } },
     { "id": "hero", "type": "image_generate",
       "inputs": { "reference": "$ref:sheet.sheet" },
-      "params": { "model": "google/gemini-3-pro-image-preview",
+      "params": { "model": "google/gemini-3-pro-image",
                   "prompt": "The navy leather low-top sneaker with white sole and gold logo from the reference sheet, hero shot on a rain-soaked neon street at night" } }
   ],
   "output": { "node": "hero", "output": "images" }
@@ -4635,7 +4635,7 @@ The adaptation prompt is baked into the backend and is direction-aware (a wider
 
 | Name | Type | Required | Notes |
 |---|---|---|---|
-| `model` | enum | yes | one of `google/gemini-3-pro-image-preview`, `google/gemini-3.1-flash-image-preview` |
+| `model` | enum | yes | one of `google/gemini-3-pro-image`, `google/gemini-3.1-flash-image` (their `-preview` ids still accepted) |
 | `formats` | enum[] | one of `formats`/`platform` | 1–6 unique target ratios from `1:1 \| 2:3 \| 3:2 \| 3:4 \| 4:3 \| 4:5 \| 5:4 \| 9:16 \| 16:9 \| 21:9` — output order follows this list |
 | `platform` | enum | one of `formats`/`platform` | a placement preset that expands to that platform's canonical on-grid set: `meta_feed` (4:5), `meta_feed_stories` (4:5, 9:16), `meta_all` (4:5, 9:16, 1:1), `linkedin` (1:1), `google_demandgen` (1:1, 4:5, 16:9), `tiktok` (9:16), `youtube` (16:9). Mutually exclusive with `formats`. Off-grid platform targets (e.g. Google 1.91:1) are not rendered here — crop them from the nearest rendered ratio with `baker images crop`. |
 | `guidance` | string | no | hints appended to the baked prompt, e.g. `"keep the CTA button fully visible"` |
@@ -4652,7 +4652,7 @@ The adaptation prompt is baked into the backend and is direction-aware (a wider
 Guidance:
 - Reach for `platform` when you want a placement's whole set without naming ratios (e.g. `"platform": "meta_feed_stories"`); use `formats` when you need an exact, custom ratio list. Set one, never both.
 - List the source's own ratio in `formats` too when you want the full set in one output — it passes through for free.
-- Use `google/gemini-3.1-flash-image-preview` while iterating; switch to `google/gemini-3-pro-image-preview` for final-quality adaptation.
+- Use `google/gemini-3.1-flash-image` while iterating; switch to `google/gemini-3-pro-image` for final-quality adaptation.
 - Indexes are positional: `$ref:adapt.images#1` is always the second entry of `formats`.
 
 **Example** — one 9:16 story creative fanned out to feed and landscape:
@@ -4662,12 +4662,12 @@ Guidance:
   "schema": "baker-canvas/1",
   "nodes": [
     { "id": "hero", "type": "image_generate",
-      "params": { "model": "google/gemini-3-pro-image-preview",
+      "params": { "model": "google/gemini-3-pro-image",
                   "prompt": "Story-format ad for a citrus energy drink: can centered, bold OFFER text top, logo bottom",
                   "aspect_ratio": "9:16", "image_size": "2K" } },
     { "id": "adapt", "type": "image_aspect_adapt",
       "inputs": { "source": "$ref:hero.images#0" },
-      "params": { "model": "google/gemini-3-pro-image-preview",
+      "params": { "model": "google/gemini-3-pro-image",
                   "formats": ["9:16", "1:1", "16:9"],
                   "guidance": "keep the offer text and logo fully visible" } }
   ],
@@ -4802,9 +4802,9 @@ Fail-fast: an invalid model selection (wrong count, duplicate or out-of-range pi
 {
   "schema": "baker-canvas/1",
   "nodes": [
-    { "id": "a", "type": "image_generate", "params": { "model": "google/gemini-3.1-flash-image-preview", "prompt": "hero shot of a ceramic mug, warm morning light" } },
-    { "id": "b", "type": "image_generate", "params": { "model": "google/gemini-3.1-flash-image-preview", "prompt": "hero shot of a ceramic mug, studio softbox" } },
-    { "id": "c", "type": "image_generate", "params": { "model": "google/gemini-3.1-flash-image-preview", "prompt": "hero shot of a ceramic mug, dramatic side light" } },
+    { "id": "a", "type": "image_generate", "params": { "model": "google/gemini-3.1-flash-image", "prompt": "hero shot of a ceramic mug, warm morning light" } },
+    { "id": "b", "type": "image_generate", "params": { "model": "google/gemini-3.1-flash-image", "prompt": "hero shot of a ceramic mug, studio softbox" } },
+    { "id": "c", "type": "image_generate", "params": { "model": "google/gemini-3.1-flash-image", "prompt": "hero shot of a ceramic mug, dramatic side light" } },
     { "id": "best", "type": "image_select",
       "inputs": { "images": ["$ref:a.images#0", "$ref:b.images#0", "$ref:c.images#0"] },
       "params": { "model": "~google/gemini-pro-latest", "prompt": "most premium-feeling lighting, no harsh shadows" } }
@@ -5621,13 +5621,15 @@ Turn a source/inspiration image into a **runnable, self-validated static-ad canv
 2. **element selection** (`~google/gemini-flash-latest`) — picks the **main, identity-critical** elements (the brand logo, a showcased product, a trust badge) **plus any foreground/hero person or animal** — the emotional focal point — even a generic one, because a free-generated face/muzzle reads as AI and grows artifacts; the emotional hero always gets a real-reference slot. When the advertiser's logo appears in **more than one lockup** (a square/icon **mark** and a horizontal **wordmark**), each is emitted as its **own** element (e.g. `LOGO_MARK`, `LOGO_WORDMARK`) so you drop the right file in each slot instead of stretching one logo to cover both. The describe pass also records the ad's **typography** under a `fonts` block (each typeface's classification, a best-guess family, and its weight/case) so you know exactly what to drop at the brand-font slot. Background extras are dropped. Each element is stamped back onto its blueprint entry as a `reference_image` label so the JSON self-documents which slot grounds which subject.
 3. **global layout** (`~google/gemini-flash-latest`) — produces a structured `layout` block in `prompt.json`: the column/row grid, each region's `x_pct`/`y_pct` bounds, panel splits, background/shape, and every text block's relative size/weight/case/alignment. This is what gives the generator a precise composition to rebuild.
 
-It then scaffolds a canvas that ingests `prompt.json`, wires **one `[TODO]` ingest slot per detected element** (plus an optional brand-font → type-specimen) into `image_generate`, and wires the original image in for composition only — left out of the render when it shows a person, because the generator copies that face whatever the prompt says (the blueprint's layout carries the composition instead). Each **animal hero** is additionally fused into a generated **multi-view reference sheet** (`image_reference_sheet`, a turnaround built from the one dropped photo) that the render grounds on instead of the lone flat snapshot — the same identity lock the video scaffold uses, so the muzzle stays consistent and artifact-free from a single reference. Pass `--skip-actor-sheets` to ground straight on the dropped photo. A **person hero** is cast from a company Avatar with `--avatar <handle>`: the slot ingests its identity sheet and `prompt.json` describes that person in the Avatar's own words. The render keeps the face it is given, so it is never a found photo of a real person. The canvas is validated before it's written. stdout returns `{ ok, canvas_path, prompt_path, models, aspect_ratio, placements, output_formats, layout_regions, stats, checklist }` — the **checklist** lists every real asset to drop in (and which heroes get a sheet).
+It then scaffolds a canvas that renders the ad in two layers. The image model (`openai/gpt-image-2.5-sunburst`, quality `xhigh`) paints **three candidate plates** (the picture with no text and no logo, keeping calm the areas the copy will occupy), an `image_select` judge scores them on a fixed rubric (mechanism kept, space for the offer, brand, artifacts, Stories safe zones, text) and picks one, and every delivered format is drawn by an HTML composition (`layout-4x5/`, `layout-9x16/`, one per format, snapshotted by `hyperframe_snapshot`): the copy from `prompt.json` in the brand's heading and body fonts from `src/brand/fonts/` (via `src/brand/tokens.json` when present), the call to action as a button in the brand CTA colour, and the real logo file from `src/brand/logos/`. The plates read `prompt.plate.json` (the scene, the reserved areas and the visual mechanisms; no copy, no brand names) and the compositions read `prompt.compose.json`; both are re-derived from `prompt.json` by `validate` and `run`, so a copy edit re-draws the formats from the cached plates without paying for a picture again. A format within 10% of the plate's shape is a free crop; a farther one extends the chosen plate once on the same model. With no font file in `src/brand/fonts/` (or `--skip-font`) the copy is baked into the plates instead, and every other shape is re-framed by `image_aspect_adapt` on `google/gemini-3-pro-image`, never cropped. Detected elements get **one `[TODO]` ingest slot** each (the logo slot is pre-filled with the brand logo and feeds the composition, never the picture model), and the original image is wired in for composition only — left out of the render when it shows a person, because the generator copies that face whatever the prompt says (the blueprint's layout carries the composition instead). Each **animal hero** is additionally fused into a generated **multi-view reference sheet** (`image_reference_sheet`, a turnaround built from the one dropped photo) that the render grounds on instead of the lone flat snapshot — the same identity lock the video scaffold uses, so the muzzle stays consistent and artifact-free from a single reference. Pass `--skip-actor-sheets` to ground straight on the dropped photo. A **person hero** is cast from a company Avatar with `--avatar <handle>`: the slot ingests its identity sheet and `prompt.json` describes that person in the Avatar's own words. The render keeps the face it is given, so it is never a found photo of a real person. The canvas is validated before it's written. stdout returns `{ ok, canvas_path, prompt_path, models, aspect_ratio, placements, output_formats, layout_regions, stats, checklist }` — the **checklist** lists every real asset to drop in (and which heroes get a sheet).
 
-**Automatic placement fan-out.** By default the canvas doesn't stop at one ratio: the hero renders once at the platform's primary ratio, then an `image_aspect_adapt` node recomposes it into that platform's full placement set, and the canvas `output` points at the adapted images. The placement set is derived from `--platform` (`meta` → 4:5 + 9:16, `google` → 1:1 + 4:5 + 16:9, `linkedin` → 1:1, `tiktok` → 9:16, `youtube` → 16:9); override it with `--placements <preset>` or disable it with `--placements none` for a single base ad. The hero ratio passes through the adapt node **free**; each other ratio is a billed recomposition — and because adaptation re-generates, every ratio should be eyeballed for text and brand-color fidelity before publish (`ad-formats.md` in the scaffold skill covers this).
+**Placement formats.** The canvas delivers the platform's full placement set, each format at its exact size, collected under `final` with the format as its label. The set is derived from `--platform` (`meta` → 4:5 + 9:16, `google` → 1:1 + 4:5 + 16:9, `linkedin` → 1:1, `tiktok` → 9:16, `youtube` → 16:9); override it with `--placements <preset>` or `--placements none` for a single format. The report's `aspect_ratio` is the ratio the plates really render at (the model's nearest to the lead format), and `format_plan` says how each format is made.
+
+**After a run** the CLI reads the finished ad back: every delivered image's pixel shape against its format, and one vision pass that reads each word against the copy and checks the logo, clipping, legibility and artifacts. stdout carries `verdict` (`ready` | `ready_with_notes` | `needs_fixes` | `not_reviewed`) and `judge` (the per-plate scores); the findings are stored on the run as its `review`. `needs_fixes` means the ad is not done even though every node completed.
 
 The checklist `note` reminds you to fill **logo** slots from the company's committed brand logo in `src/brand/logos/` (per `BRAND.md`) — **not** from `baker images logo <domain>`, whose Brandfetch CDN often serves an outdated mark (a common cause of an old logo shipping on a live ad).
 
-The generation prompt is **model-aware and typography-hardened** (a static ad is the only path that bakes text *into* the image — video frames are clean plates). It resolves the image model's profile, so for **gpt-image** the exclusions (no invented badges/watermark) are hoisted to the very *end* of the prompt where the model reads them as pure exclusions rather than composition, and it quotes every blueprint string with an instruction to render each **once, verbatim**, lock brand names letter-by-letter, and keep type crisp and legible — the fix for the #1 static-ad defect (garbled/duplicated/dropped copy). Run `baker canvas critique` on the scaffolded canvas for an advisory read on text-legibility risk, identity grounding, and brand-type fidelity before you spend.
+The plate prompt is **model-aware**: for **gpt-image** the exclusions (no invented badges/watermark) are hoisted to the very *end* of the prompt where the model reads them as pure exclusions rather than composition. In the baked-copy fallback it quotes every line of `prompt.json`'s copy (never the logo's text) with an instruction to render each **once, verbatim**; that block is re-read from `prompt.json` on every `validate` and `run`, which also upgrades canvases scaffolded before this change. Run `baker canvas critique` on the scaffolded canvas for an advisory read before you spend.
 
 ```bash
 baker canvas scaffold-static-ad ./reference-ad.png --context "competitor ad for <brand>, <category>, <market>"
@@ -5645,11 +5647,12 @@ baker canvas run ./static-ad.canvas.json
 | `--describe-model <id>` | registry default (`~google/gemini-pro-latest`) | Override the `image_describe` model. |
 | `--select-model <id>` | registry default (`~google/gemini-flash-latest`) | Override the element-selection `text_generate` model. |
 | `--layout-model <id>` | registry default (`~google/gemini-flash-latest`) | Override the global-layout `text_generate` model. |
-| `--gen-model <id>` | registry default (`openai/gpt-image-2`) | Override the `image_generate` model. |
+| `--gen-model <id>` | `openai/gpt-image-2.5-sunburst` | Override the plate model. |
+| `--takes <n>` | `3` | Plates rendered and judged (1-3); `1` skips the judge. |
 | `--platform <channel>` | `meta` | `_definition.md` channel **and** the default placement set the hero fans out to (`meta`\|`google`\|`linkedin`\|`tiktok`\|`youtube`\|`x`\|`other`; `x`/`other` fan out to nothing). |
 | `--placements <preset\|none>` | derived from `--platform` | Override the fan-out set: `meta_feed`\|`meta_feed_stories`\|`meta_all`\|`linkedin`\|`google_demandgen`\|`tiktok`\|`youtube`, or `none` for a single base ad. |
-| `--aspect <ratio>` | inferred from the image, else `9:16` | Force the hero's aspect ratio (clamped into the placement set so it stays a free pass-through). |
-| `--skip-font` | off | Skip the brand-font → type-specimen slot. |
+| `--aspect <ratio>` | inferred from the image, else `9:16` | Force the lead format (it leads the placement set when the set has it). |
+| `--skip-font` | off | Bake the copy into the plates even though a brand font exists. |
 | `--skip-actor-sheets` | off | Ground each animal hero on its lone dropped photo instead of a generated multi-view reference sheet. |
 | `--avatar <handles>` | — | Cast company avatars as the image's people, comma-separated in the order they were detected (`marta` or `marta,joan`). Each person slot grounds on that avatar's identity sheet and takes its subject description. Checked before any billed pass; an unknown, not-ready or sheetless avatar fails with code `avatar`. A handle with no person to play is reported in `hints` as `NOT CAST`. |
 
@@ -6165,6 +6168,67 @@ baker creatives publish ./canvas/<run_id>/<final>.png --title "Spring Offer 4x5"
 
 Without `--slug` the command behaves as before (one creative record per published image). With `--slug` it upserts the repo-convention row — the same one the dashboard's Creatives tab and the `src/creatives/{slug}/` folder describe — so publish, repo sync, and run history all land on a single record regardless of order.
 
+### `baker creatives performance`
+
+How each published creative is doing in the live Meta ads that show it. A creative is linked to an ad when a chat's publish uploads its image to Meta and creates an ad with it (or swaps an existing ad onto it); the results are read live from Meta.
+
+```bash
+baker creatives performance                      # every creative in an ad, last 30 days
+baker creatives performance --slug spring-offer  # one creative
+baker creatives performance --days 14 --full     # + ids, last-7-day figures, one row per ad
+```
+
+| Flag | Effect |
+|---|---|
+| `--slug <slug>` | Only this creative. |
+| `--days <n>` | Window ending today, 1-90 (default 30). |
+| `--full` | Adds creative and image ids, result type, days live, last-7-day CTR and cost per result, and one row per ad. |
+
+Each creative reports `spend`, `impressions`, `ctr` (percent), `cpc`, `results`, `costPerResult`, `frequency`, a `fatigue` verdict (`fresh`, `fading`, `fatigued`, `dead`, `too_early`, `no_delivery`) with its reason, and `definition`: the angle, hook, persona, awareness, hypothesis and reference fields read from the local `src/creatives/<slug>/_definition.md`. `hints` name worn-out creatives, the angle with the lowest cost per result, and unreadable ad accounts.
+
+### `baker creatives feedback [--slug <slug>] [--full]`
+
+What reviewers said about creative versions in Baker (Approve, or Not this one with reasons and a note; choosing a version to keep counts as an approval). Compact by default: approved and rejected counts, the top rejection reasons, what approved versions share (format, platform, option) and the 8 latest verdicts, plus `hints[]` saying what to do differently. `--slug` narrows to one creative; `--full` returns every verdict (up to 200) with whole notes.
+
+```bash
+baker creatives feedback
+baker creatives feedback --slug spring-offer --full
+```
+
+Each entry carries its `source`: `review` (the buttons in Baker), `selection` (choosing or saving the version) or `chat` (what the person wrote in a chat, recorded with `feedback record`).
+
+### `baker creatives feedback record`
+
+Record what the person said about one version in a chat: an approval, or a rejection with reasons and their own words. It is stored like the Approve / Not this one buttons, as the verdict of the person who wrote the chat's latest message (`recordedFor: "sender"`), or of the chat itself when nobody has written in it (`"chat"`). One verdict per person per version or option: a later one replaces theirs. Must run from a chat.
+
+```bash
+baker creatives feedback record --slug spring-offer --run r_01K… --verdict rejected \
+  --reasons text_mistakes,weak_hook --note "the price is 49 not 59"
+baker creatives feedback record --slug spring-offer --run r_01K… --option 2 --verdict approved
+```
+
+| Flag | Effect |
+|---|---|
+| `--slug <slug>` | Required. The creative (`src/creatives/<slug>/`). |
+| `--run <r_…>` | Required. The version. |
+| `--verdict approved\|rejected` | Required. |
+| `--option <o>` | One option of a version that made several: its label, its number (`2`) or its slot. |
+| `--reasons <a,b>` | Comma-separated: `text_mistakes`, `logo_or_brand_wrong`, `weak_hook`, `wrong_message`, `looks_fake`, `not_our_style`, `other`. A rejection needs reasons or a note. |
+| `--note <text>` | The person's own words (stored up to 1000 characters). |
+
+After a rejection, `hints[]` restates what to change, starting from that version.
+
+### `baker creatives select`
+
+Choose the version of a creative to keep, or only some of its options, the way choosing it in Baker does: the creative shows that version as the chosen one, and the choice records the chat sender's approval (`source: "selection"`). Naming options replaces the earlier pick. It does not add the image to the library; that is `baker creatives publish`, which, given `--run-id`, also counts as choosing that version.
+
+```bash
+baker creatives select --slug spring-offer --run r_01K…
+baker creatives select --slug spring-offer --run r_01K… --options "beach,2"
+```
+
+Prints `{ ok, data: { creative, runId, kept?, options, approvalRecorded }, hints }`, where `options` lists every option the version offers.
+
 ## Landing Quality (`baker landing`)
 
 Two tools that bracket a landing build: **`inspiration`** before you design (what does good look like here?) and **`critique`** after you build (did this settle into generic defaults?).

package/canvas/static-ad-composition/index.html

@@ -0,0 +1,197 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=__WIDTH__, height=__HEIGHT__" />
+    <script src="./gsap.min.js"></script>
+    <style>
+      /* The brand's own faces, staged beside this file by the render. One range per face,
+         so a single-weight file is used as it is instead of being faked bolder. */
+      @font-face { font-family: 'AdHeadline'; src: url('./headline.font'); font-weight: 100 900; font-display: block; }
+      @font-face { font-family: 'AdBody'; src: url('./body.font'); font-weight: 100 900; font-display: block; }
+      * { margin: 0; padding: 0; box-sizing: border-box; }
+      html, body { width: __WIDTH__px; height: __HEIGHT__px; overflow: hidden; background: #000; }
+      #root { position: absolute; inset: 0; overflow: hidden; }
+      .plate { position: absolute; inset: 0; width: 100%; height: 100%; object-fit: cover; object-position: 50% 50%; }
+      .scrim { position: absolute; left: 0; right: 0; pointer-events: none; display: none; }
+      .band { position: absolute; display: flex; flex-direction: column; gap: 0; }
+      .block { font-family: 'AdBody', 'Helvetica Neue', Arial, sans-serif; overflow-wrap: break-word; text-wrap: pretty; }
+      .block.headline, .block.subheadline, .block.cta { font-family: 'AdHeadline', 'AdBody', 'Helvetica Neue', Arial, sans-serif; }
+      .block.headline { text-wrap: balance; letter-spacing: -0.01em; }
+      .cta-pill { display: inline-block; border-radius: 999px; font-weight: 700; line-height: 1.1; }
+      .logo { display: block; width: auto; object-fit: contain; }
+    </style>
+  </head>
+  <body>
+    <div id="root" data-composition-id="main" data-start="0" data-duration="1" data-width="__WIDTH__" data-height="__HEIGHT__">
+      <img class="plate" id="plate" src="./plate.png" alt="" />
+      <div class="scrim" id="scrim-top"></div>
+      <div class="scrim" id="scrim-bottom"></div>
+      <div class="band" id="band-top" data-role="copy-top"></div>
+      <div class="band" id="band-middle" data-role="copy-middle"></div>
+      <div class="band" id="band-bottom" data-role="copy-bottom"></div>
+    </div>
+
+    <script>
+      (function () {
+        var AD = {{ad}};
+        var FRAME = {{frame}};
+        var W = __WIDTH__;
+        var H = __HEIGHT__;
+        var root = document.getElementById("root");
+        var safe = FRAME.safe || { top: 0.05, bottom: 0.05, left: 0.06, right: 0.06 };
+        var box = { x: safe.left * W, y: safe.top * H, w: W * (1 - safe.left - safe.right), h: H * (1 - safe.top - safe.bottom) };
+        // One unit per percent of the shorter side, so type reads the same size on every format.
+        var U = Math.min(W, H) / 100;
+
+        var SIZE = { x_large: 8.6, large: 6.6, medium: 4.4, small: 3.0 };
+        var WEIGHT = { bold: 800, semibold: 600, regular: 400 };
+        var CASE = { upper: "uppercase", title: "capitalize", sentence: "none" };
+        var MAX_SHARE = { top: 0.44, middle: 0.3, bottom: 0.36 };
+
+        function luma(hex) {
+          var m = /^#?([0-9a-f]{6})$/i.exec(hex || "");
+          if (!m) return null;
+          var v = parseInt(m[1], 16);
+          return 0.2126 * ((v >> 16) & 255) + 0.7152 * ((v >> 8) & 255) + 0.0722 * (v & 255);
+        }
+
+        var bands = { top: [], middle: [], bottom: [] };
+        var drawCopy = FRAME.draw_copy !== false;
+        (drawCopy ? AD.copy || [] : []).forEach(function (b) {
+          (bands[b.band] || bands.top).push(b);
+        });
+
+        function bandEl(name) {
+          return document.getElementById("band-" + name);
+        }
+
+        function place(name) {
+          var el = bandEl(name);
+          el.style.left = box.x + "px";
+          el.style.width = box.w + "px";
+          el.style.gap = 1.6 * U + "px";
+          if (name === "top") el.style.top = box.y + "px";
+          if (name === "bottom") el.style.bottom = H - (box.y + box.h) + "px";
+          if (name === "middle") {
+            el.style.top = box.y + box.h / 2 + "px";
+            el.style.transform = "translateY(-50%)";
+          }
+        }
+
+        function alignSelf(align) {
+          return align === "left" ? "flex-start" : align === "right" ? "flex-end" : "center";
+        }
+
+        function addLogo(name, align) {
+          var img = document.createElement("img");
+          img.className = "logo";
+          img.src = "./logo.png";
+          img.alt = "";
+          img.style.height = 5.4 * U + "px";
+          img.style.maxWidth = box.w * 0.42 + "px";
+          img.style.alignSelf = alignSelf(align);
+          img.onerror = function () {
+            img.remove();
+          };
+          var el = bandEl(name);
+          if (name === "bottom") el.appendChild(img);
+          else el.insertBefore(img, el.firstChild);
+        }
+
+        function addBlock(name, b) {
+          var el = document.createElement("div");
+          el.className = "block " + b.role;
+          el.dataset.size = String(SIZE[b.size] || SIZE.medium);
+          var size = b.role === "fine_print" ? 2.4 : b.role === "cta" ? 4.2 : SIZE[b.size] || SIZE.medium;
+          el.dataset.base = String(size);
+          el.style.fontSize = size * U + "px";
+          el.style.fontWeight = String(b.role === "cta" ? 700 : WEIGHT[b.weight] || 400);
+          el.style.lineHeight = b.role === "headline" ? "1.04" : "1.22";
+          el.style.textTransform = CASE[b.case] || "none";
+          el.style.textAlign = b.align || "center";
+          el.style.alignSelf = alignSelf(b.align);
+          if (b.role === "cta") {
+            var pill = document.createElement("span");
+            pill.className = "cta-pill";
+            pill.textContent = b.text;
+            pill.style.background = AD.cta.background;
+            pill.style.color = AD.cta.color;
+            pill.style.padding = "0.55em 1.4em";
+            el.appendChild(pill);
+          } else {
+            el.textContent = b.text;
+            var ink = b.color || "#ffffff";
+            el.style.color = ink;
+            var dark = (luma(ink) || 255) < 110;
+            el.style.textShadow = dark ? "0 1px 10px rgba(255,255,255,0.35)" : "0 2px 14px rgba(0,0,0,0.45)";
+            el.dataset.dark = dark ? "1" : "0";
+          }
+          bandEl(name).appendChild(el);
+        }
+
+        ["top", "middle", "bottom"].forEach(function (name) {
+          place(name);
+          bands[name].forEach(function (b) {
+            addBlock(name, b);
+          });
+        });
+        if (AD.logo) addLogo(AD.logo.band, AD.logo.align);
+
+        // Shrink a band's type until it fits its share of the safe area and no line runs
+        // past the edge. The copy is whatever prompt.json says today, so its length is
+        // not known when the layout is written.
+        function fit(name) {
+          var el = bandEl(name);
+          var max = box.h * MAX_SHARE[name];
+          var scale = 1;
+          for (var i = 0; i < 40; i++) {
+            var tooTall = el.scrollHeight > max;
+            var tooWide = Array.prototype.some.call(el.children, function (c) {
+              return c.scrollWidth > box.w + 1;
+            });
+            if (!tooTall && !tooWide) break;
+            scale *= 0.94;
+            Array.prototype.forEach.call(el.querySelectorAll(".block"), function (c) {
+              c.style.fontSize = Number(c.dataset.base) * U * scale + "px";
+            });
+          }
+        }
+
+        // A soft scrim behind a band of light type (or a light one behind dark type), so the
+        // copy reads on any plate without boxing it in.
+        function scrim(name) {
+          if (name === "middle" || bands[name].length === 0) return;
+          var el = bandEl(name);
+          var s = document.getElementById("scrim-" + name);
+          var firstText = el.querySelector(".block:not(.cta)");
+          var dark = firstText && firstText.dataset.dark === "1";
+          var tint = dark ? "255,255,255" : "0,0,0";
+          var rect = el.getBoundingClientRect();
+          var reach = name === "top" ? rect.bottom + 6 * U : H - rect.top + 6 * U;
+          s.style.display = "block";
+          s.style.height = Math.min(H * 0.6, reach) + "px";
+          if (name === "top") {
+            s.style.top = "0";
+            s.style.background = "linear-gradient(to bottom, rgba(" + tint + ",0.42), rgba(" + tint + ",0))";
+          } else {
+            s.style.bottom = "0";
+            s.style.background = "linear-gradient(to top, rgba(" + tint + ",0.42), rgba(" + tint + ",0))";
+          }
+        }
+
+        var tl = gsap.timeline({ paused: true });
+        tl.to({}, { duration: 1 });
+        window.__timelines = window.__timelines || {};
+        window.__timelines.main = tl;
+
+        var ready = document.fonts && document.fonts.ready ? document.fonts.ready : Promise.resolve();
+        ready.then(function () {
+          ["top", "middle", "bottom"].forEach(fit);
+          ["top", "bottom"].forEach(scrim);
+          root.setAttribute("data-ready", "1");
+        });
+      })();
+    </script>
+  </body>
+</html>

package/canvas/static-ad-composition/meta.json

@@ -0,0 +1,53 @@
+{
+  "id": "static-ad",
+  "title": "Static ad: a rendered plate with the copy, the call to action and the logo drawn on top",
+  "description": "Written by `baker canvas scaffold-static-ad`, one copy per delivered format. The plate is the image model's clean picture; the copy, the CTA and the logo are drawn here from prompt.compose.json (derived from prompt.json) in the brand's own fonts and logo file. Width and height are this format's delivered size.",
+  "width": 1080,
+  "height": 1350,
+  "fps": 1,
+  "default_duration": 1,
+  "inputs": {
+    "plate": {
+      "kind": "image",
+      "required": true,
+      "staged_as": "plate.png",
+      "description": "The picture, with no text and no logo."
+    },
+    "logo": {
+      "kind": "image",
+      "required": false,
+      "staged_as": "logo.png",
+      "description": "The brand's logo file."
+    },
+    "font_headline": {
+      "kind": "font",
+      "required": false,
+      "staged_as": "headline.font",
+      "description": "The brand's headline face."
+    },
+    "font_body": {
+      "kind": "font",
+      "required": false,
+      "staged_as": "body.font",
+      "description": "The brand's body face."
+    },
+    "compose": {
+      "kind": "json",
+      "required": true,
+      "staged_as": "compose.json",
+      "description": "prompt.compose.json, also passed inline as the `ad` param."
+    }
+  },
+  "params": {
+    "ad": {
+      "kind": "json",
+      "required": true,
+      "description": "The copy blocks, logo placement and CTA colours (prompt.compose.json)."
+    },
+    "frame": {
+      "kind": "json",
+      "required": true,
+      "description": "This format's safe area and whether the copy is drawn here."
+    }
+  }
+}

package/dist/{chunk-AOVFDDVW.js → chunk-7OVZ6SOA.js}

@@ -958,7 +958,8 @@ function compactWinningAd(record) {
     summary: String(dna.creative_concept ?? ""),
     advertiser_id: String(record.advertiser_id ?? ""),
     ad_id: String(record.ad_id ?? ""),
-    media_url: String(record.media_url ?? "")
+    media_url: String(record.media_url ?? ""),
+    ...record.source === "followed" || record.source === "library" ? { source: record.source } : {}
   };
 }
 function fullWinningAd(record) {
@@ -1299,4 +1300,4 @@ export {
   captureVimeoCookie,
   childEnvWith
 };
-//# sourceMappingURL=chunk-AOVFDDVW.js.map
+//# sourceMappingURL=chunk-7OVZ6SOA.js.map