@koda-sl/baker-cli 0.478.0 → 0.480.0

package/README.md

@@ -1992,15 +1992,24 @@ Ads start from what customers said. Three commands carry the process; the agent
 ```bash
 baker creatives brief [--adset <id>] [--account-id act_<id>] [--no-research]   # one read: viewer, account bottleneck, what works, taste, customer quotes, ideas on file
 baker creatives ideas [--full]                                 # check and rank src/creatives/_ideas/*.md; build_next
-baker creatives make <idea> [--slug <s>] [--adset <id>] [--reference <adId> [--platform meta|linkedin|tiktok|google]] [--spec <beats.json>] [--from-idea] [--series <lead>]
+baker creatives make <idea> [--platforms <p,…>] [--formats <r,…>] [--slug <s>] [--adset <id>] [--reference <adId> [--reference-platform meta|linkedin|tiktok|google]] [--avatar <handle>] [--spec <beats.json>] [--from-idea] [--series <lead>]
 baker creatives translate --slug <ad> --to es-MX,es-CO,pt-BR [--copy-file <json>] [--note "<brief>"] [--again]   # the same ad in other languages, one design
 baker creatives learn [--days <n>] [--dry-run]                 # what each idea's ads did, written back onto the idea
+baker creatives rules list [--kind static|video] [--product <slug>] [--all]   # the company's standing rules for every ad
+baker creatives rules add --candidate <rc-…> | --text "<rule>" --strength never|must|prefer --applies <what> …   # a rule the person agreed to
+baker creatives rules retire <id> [--by <id>|BRAND.md]
+baker creatives check [--slug <s>]                             # which ads already made break a rule now in force
 ```
 
+- **Creative rules.** Every step of an ad reads one company (`engine/creative-context`): its reading of COMPANY.md (cached per edit), its BRAND.md (name, fonts, colours, voice, imagery, logo usage) and the rules that hold for the ad: BRAND.md's own (read by `google/gemini-3.5-flash`, cached per BRAND.md edit) and the ones a person taught, one file each in `src/content/creative-rules/`. Rules are read when a call runs, never copied into an ad's files; the compiled prompts carry them in a `<company_rules>` block the source fingerprint leaves out, so a rule edit re-renders on the next run and marks nothing stale. A never or a must is held before anything renders on the ad's words (`rule_broken`: whole phrases, accents, case and spacing folded, in the rule's language) and on its cast (`cast_not_decided` for an Avatar made for a role under a rule that only real people appear), and after on the finished ad: the rules a person taught are checked on a static's sizes and a video's frames by a vision model (each blocking break given a second look), and a video's voice, sound and subtitle rules by the watch pass. BRAND.md's rules are told to every render and its banned words are checked, but they never block a finished ad by eye. An ad departs from a rule only through `waive` in its prompt.json, which the source fingerprint covers; a rule three ads waive is flagged to retire. `feedback record` drafts the rules a rejection's words state for every ad (`ruleCandidates`, only where the words say it holds beyond this ad) and names reasons repeated across ads; `rules add` saves one only once the person agreed, after checking it duplicates and contradicts none of theirs, catches the version it came from and blocks none they approved. Each run record names the rules it was made against (`rules: { digest, ids }`). A correction (`--fix`, the spec repair) also reads the creative's case file: every rejection on it, in the person's words.
+- **An edit keeps the idea.** A creative's idea (its message, who it is for and its market, its reference, what is taken from it and must be kept, what stops the scroll and the proof with what of ours carries each, why it won and what survives of it, the language its viewer reads; on a video its accent, voices, chosen voices, how it is voiced and who appears) is read off `_definition.md`, `prompt.json`, `scenes/*.json` and the canvas, never stored twice. `feedback --slug` and a rejection's `feedback record` return it as `data.anchor` (compact; `--full` adds why it wins, the voices and the changes), restated as the first hint. `canvas run` and `validate` hold it to the version the person saw when the chat turn started (`BAKER_TURN_ID`; outside a chat, the last render here, else the version the run history shows) and refuse a change no new line under `## Changes` in `_definition.md` records with a reason after the dash, the front matter agreeing (`idea_changed`). Words the decision model reads, surely, as another language than the viewer's are refused (`copy_language`), a reading that is not sure warns. A run says `[scope]` before an edit that makes new pictures for more than words or colours, and `[voice]` for a talking take whose rendered voice is kept and is made again. An automatic repair never changes `viewer`.
+
 - `brief` returns a verdict, not raw numbers: `account.bottleneck` is `hook`, `after_click`, `none` or `too_little_data`. A part that cannot be read says `unavailable`; the market searches (the followed brands, and the library for what COMPANY.md's first line says the company sells, in a few words) run at once and get 12 seconds, so a slow ad library leaves them out rather than holding the brief. With few customer quotes on file it runs `research customers` itself alongside the reads (about 30 s) and returns what it wrote; `--no-research` skips that. With no ideas on file, its hint lists the values `awareness`, `angle` and `format` take. `market` says what competitors' ads already say (the followed brands, else the library), how sophisticated the market is, and which awareness stages nobody speaks to.
 - `ideas` is local and nearly free: two readings of the words go to the decision model (a fraction of a cent, billed with the workspace's next run, answers kept in `canvas/.cache/`). An insight filed as `observed` reads as `interpreted` when its source cannot be opened or its quote is a statistic about people rather than someone's words ("39% de los propietarios…"), and a new idea is warned when its message says what a failed idea said, however reworded or translated. Without an answer, an insight keeps its status and only the same words count as the same message. An idea's `evidence` resolves to `src/content/insights/` entries, or it is an `explore` bet. Numbers must be in the Knowledge or our own customers' quotes (a Reddit, forum or web quote never sources a claim), no two ideas may share an angle and format, and a review or testimonial format needs a quote from our own customer.
 - `learn` pools each built idea's creatives, judges them against the rest of the account's cost per result and writes `status` (`winner`, `failed`, `inconclusive`, `testing`) and a frozen `result` onto the idea. `ideas` then warns when a new idea repeats a failed one.
-- `make` builds one idea, on a proven winning ad whenever one fits. A static searches the idea's container on the idea's message for our viewer, then for the container's strongest winners from any category (no query, by winner score), pools the candidates (each ad once, the better search first), checks up to six with `winning-ads fit`, three at a time (the next only once one does not fit), and keeps the best-ranked one that fits as soon as it and every better one have answered. The fit says what made that ad a winner, so what the creative carries of it (`reference.carry`: `whole_ad`, `layout`, `hook` or `angle`); make seeds it into `prompt.json` as `concept`, the canvas keeps the ad as its `original` node, and the renders see it for its structure only at `whole_ad` or `layout`. The first hint names the ad and what it carries (for a `--reference` chosen by hand, only the ad: nothing checked what made it win); if the concept could not be written into `prompt.json`, a hint says so and how to write it from the fit already made. For a new creative it starts scaffolding the best-ranked one while the fits are asked (kept when it fits, stopped and removed whole when another or none is kept). Finding, checking and describing a reference gets 150 seconds; past that the build is stopped and the static starts from the idea (`REFERENCE_SLOW`). A creative whose ad is already written is never built over (`ALREADY_MADE`): edit its `prompt.json`, or pass `--slug` for another ad of the same idea. A video idea takes its beats spec. Either way it records the idea on `_definition.md`, sets `prompt.json`'s `message` and syncs the definition. Drafted copy lines claiming a figure the company never wrote come back first in `hints`. Only when no proven ad fits (or with `--from-idea`) does a static start from the idea itself, and the first hint says why (none in the container, what the ones checked won on that the company lacks, the time ran out, or the proven ad it picked could not be read; a `--reference` chosen by hand that cannot be read fails instead): `prompt.json` holds the message and placeholders, and `canvas run` refuses to render until the scene and copy are written.
+- `make` builds one idea, on a proven winning ad whenever one fits. A static first reads a reference brief: one small model (`google/gemini-3.5-flash-lite`, about a second, cached per company notes and idea under `canvas/.cache/reference-brief/`) reads COMPANY.md and the idea and says what this ad sells, its industry and its people in the plain English the library files ads under, the market it runs in, who buys (consumer, small business, enterprise), whether the brand jokes (these and its own brand names from the company's reading, read once per COMPANY.md), what its rules forbid (its never-rules), and up to four wider searches, closest first (an adjacent product the same buyer weighs, the same buyer buying something else, the same kind of decision: for a padel-court builder, tennis courts, sports club owners, turnkey business investment). Without an answer it falls back to COMPANY.md's first line, its market line (English, Spanish, French, German or Italian) and the persona. It then searches for ads of what this ad sells, in its market and then anywhere, first in the idea's container for our viewer and then in any static container; then ads made for the same people whatever they sell; then the wider searches; then ads of the broader industry; then the idea's message; then the container's strongest winners from any category (no query, by winner score), in the market and then anywhere (a search that fails is asked once more; when every search for this ad's topic fails, the library's browse of any category's winners is never built on: the static starts from the idea, `REFERENCE_SEARCH_UNAVAILABLE`, and make can be run again later). It pools the candidates (one ad per brand, the better search first, ads whose run barely proves them after the proven ones, the company's own ads left out), reads up to 24 of them against the ad being made with the decision model (made for our kind of buyer? would our viewer see themselves in it? could our brand run something like it?) and checks the best six in that order, checks up to six with `winning-ads fit`, three at a time, each judged for the ad being made (the idea's persona from the Knowledge, its message, awareness, angle and the customers' words it cites; a reference the fit says our viewer would scroll past does not fit, nor one whose scroll-stopper or proof cannot be ours, and a fit made for one idea is never reused for another) (the next only once one does not fit; the first hint names each passed over and why), and, when more than one fits, looks at all of them side by side for the viewer (`~google/gemini-pro-latest`, one call) and keeps the one it prefers, saying why (`reference.chosen_because`, also in the first hint and the thinking's first read). The same look says, as a media buyer would, which element our ad takes from which of them (the hook, the visual, who appears, the proof, the layout, the call to action) and what it must not copy (a fake news page, dated urgency, another brand's marks); every picture is saved under `canvas/references/` and the thinking lays them out as a question to settle; measured on 14 production companies, judged blind by another model, the reference kept went from 5.0 to 6.9 out of 10. The fit says what made that ad a winner, so what the creative carries of it (`reference.carry`: `whole_ad`, `layout`, `hook` or `angle`); make seeds it into `prompt.json` as `concept`, the canvas keeps the ad as its `original` node, and the renders see it for its structure only at `whole_ad` or `layout`. The first hint names the ad and what it carries. A `--reference` chosen by hand skips the search but is checked like one make found (the same fit, for the ad being made; free when made before), so its thinking names what stops the scroll and the proof and asks what of ours carries each, and the first hint calls it the one chosen; only when no check can be made is it built on unchecked, the hint naming only the ad; if the concept could not be written into `prompt.json`, a hint says so and how to write it from the fit already made. For a new creative it starts scaffolding the best-ranked one while the fits are asked (kept when it fits, stopped and removed whole when another or none is kept). Finding, checking and describing a reference gets 150 seconds; past that the build is stopped and the static starts from the idea (`REFERENCE_SLOW`). A creative whose ad is already written is never built over (`ALREADY_MADE`): edit its `prompt.json`, or pass `--slug` for another ad of the same idea. A video idea takes its beats spec. Either way it records the idea on `_definition.md`, saves a proven ad's picture under `canvas/references/`, writes a `## Thinking` outline into its body (open `[TODO: …]` questions, the first sending the agent to that picture, seeded with the fit's read: what the reference is and why it won, or why the bet should work; whether it fits the viewer; our hook; the angle and the call to action; who appears and what we show, listing what the company has: its ready Avatars (real people and ones made for a role), up to three customers' own words for this message from the testimonials, how to make the founder's Avatar, where to get product pictures, and its logos, and closing with three decision lines, `- Cast:`, `- Product shown:`, `- Logo:`; what survives, one decision line per element the proven ad won on, what stops the scroll and the proof first (`- Stops the scroll: <element> — keep`, `— replace with <what of ours does the same job>` or `— impossible: "<rule>"`, the check's first read in each question); the plan, which settles the format when the proven ad's container differs from the idea's), sets `prompt.json`'s `message` and `viewer.who` (the idea's persona, title and segment, never a placeholder: the image prompt, the casting check and the viewer check read it) and syncs the definition. `canvas run` and `canvas validate` refuse to render while a thinking question is open (`definition_not_thought`), so the definition is thought before the ad is written; a creative made before the outline existed is never asked. They also refuse a cast that is not ours (`cast_not_decided`): the cast must be an Avatar (`@handle`), a real customer, real footage or nobody, the product a library picture, a capture, a Hyperframe, footage or none, the logo a brand file or none; and on a static, an Avatar cast must be one `prompt.json` grounds a person on. `--avatar <handle>` (`@eduard` or `eduard,lucia`) casts the ad's people as those Avatars: run again with it once the thinking decides, before `prompt.json` is written; it rebuilds the canvas and keeps the thinking. A static started from the idea has no people to find, so each Avatar is a person of its own, grounded on its sheet (`PERSON_n` in `prompt.json` `references`); a quote signed by that Avatar's person names that reference instead of casting them twice. Drafted copy lines claiming a figure the company never wrote come back first in `hints`. Only when no proven ad fits (or with `--from-idea`) does a static start from the idea itself, and the first hint says why (none in the container, what the ones checked won on that the company lacks, the time ran out, or the proven ad it picked could not be read; a `--reference` chosen by hand that cannot be read fails instead): `prompt.json` holds the message and placeholders, and `canvas run` refuses to render until the scene and copy are written.
+- **The logo on a static.** A standard ad shows the brand's logo whatever the reference showed (only a native disguise follows the reference, its logo small as the sender). With no logo file in `src/brand/logos/`, `scaffold-static-ad` (and so `make`) looks for the company's own: Brandfetch's when it confirms the brand, else the logo in its website's header (an image or inline SVG from its own domain only), saved as `logo-light`/`logo-dark` and registered in `tokens.json`; with none found a hint says where to add it on the Brand page, and the cast's `- Logo: none` is accepted only then, for a native ad, or when its reason quotes a company rule on the logo. `static_logo` places the file where it reads (each pixel against the ground under it, at least 90%), never on words, a button or a face; with no such spot it sets it on a small plate in a brand colour, and a size with no room is blocked (`--regenerate format_<size>`, keeping the corner clear). An ad with `logo: false` tells the words render to draw no logo or wordmark.
+- **Where an ad runs decides its sizes.** `make --platforms`, the creative's `_definition.md` (whose recorded `formats` a rebuild keeps), an idea's `platforms` (main first), the one platform the idea's words name, or a Meta `--adset` say where it runs; with none, `make` and `canvas scaffold-static-ad` refuse before anything is searched or billed (`platform_required`, its fix naming the connected ad accounts), never defaulting to Meta. The sizes follow the placement catalog (`@baker/canvas-contract` `deliveryPlan`): Meta 4:5 + 9:16, LinkedIn 1:1, TikTok 9:16, Pinterest 2:3, Google 1:1, YouTube and X 1.91:1, the first platform's size designed first; `--formats` delivers exactly the sizes asked (a size the platform never shows is refused, one it needs left out is a warning naming the placements that show a cropped picture), and a placement id names one placement alone (`meta_stories`). The definition records `platforms`, `platform` and `formats`; editing them re-plans the canvas on the next `canvas validate` or `canvas run` (`[sizes]`), before anything bills, keeping the three options when only a size is added. `make --platform` is retired (it named the reference's library: `--reference-platform`); `scaffold-static-ad --platform`, `--placements` and `--aspect` are mapped onto `--platforms` with a hint, and `--placements none` is refused.
 - `make --series <lead>` makes a static idea as another ad of a series: several messages in one style. Nothing is searched or rendered; the ad's `_definition.md` names its lead (`series: <lead>`), its `prompt.json` starts as the lead's ready version with the idea's message, and only its `copy` is written. Its canvas is written from the lead's on every run: the lead's finished picture with this ad's words, every other size the lead's own size with the same words. `baker canvas run --series <lead>` renders every ad of the series at once, one reviewed and corrected run each, skipping an ad already ready from the lead's current version.
 - `translate --slug <ad> --to <langs>` makes the ad in other languages as ads of the series it leads: one creative per language or country variant, `<ad>-<lang>` (the BCP-47 tag in lowercase: `-es-mx`), whose `_definition.md` says `series: <ad>` and `language: <lang>` (canonical case, `es-MX`, as the spec's market and the dashboard store it; tags are compared without case) and whose `prompt.json` is the ad's as last drawn with its words translated. Every language is translated in one text call (transcreated, each regional tag in that country's own variety and form of address, `es-MX` and `es-CO` two ads, each line keeping its role and about its length, brand names, prices and numbers kept, a customer's quote and the name on it never translated, and the ad's `message` translated with the lines; the spend is billed with the workspace's next run), or read from `--copy-file`: `{"<lang>": ["line 1", …]}` is every line with no model call, `{"<lang>": {"headline": "…", "3": "…"}}` only the lines given (by role or number), the model writing the rest. `--note` is the agent's brief for the translator (tone, form of address, terms to keep). Each made language lists the lines it `kept` as a customer said them, and the answer warns when the ad's `prompt.json` changed after its last render, since translations are made from the version rendered. The ad may itself be an ad of a series (an angle ad), so angles × languages stay one design. A language already made is left as it is, so adding one later re-renders nothing; `--again` translates it again. Then `baker canvas run --series <ad>` renders them; a new version of the ad reaches every language on the next `--series` run.
 
@@ -2568,6 +2577,7 @@ Each external source is its own subcommand. Pick the verb that matches the sourc
 | `baker images pinterest <q>` | Pinterest reference imagery via ScrapeCreators (photo-real mood boards) | off |
 | `baker images logo <domain>` | Brand logo via Brandfetch CDN | **on** (top 1) |
 | `baker images icon <name>` | Iconify (200+ icon sets, no API key) | off (CDN URL is stable) |
+| `baker images meme <reaction>` | The real, well-known meme template for a reaction (Imgflip; blank picture and caption boxes, best first). Use it when the brand's voice fits a meme | off (`--auto-ingest N` keeps the top N) |
 | `baker images gif <q>` | Reaction GIFs / memes via Giphy (paid-social creative) | off |
 | `baker images sticker <q>` | Transparent stickers via Giphy (overlay-friendly for ad creative) | off |
 | `baker images extract <url>` | Pull every image off a URL via Firecrawl | off |
@@ -2610,7 +2620,7 @@ baker images screenshot https://competitor.com/pricing --context "Competitor pri
 
 **Migrating from Magnific:** `baker images stock` used to run on Magnific, Freepik's developer API. That provider is gone and the command now searches Pexels and Pixabay together. Consequences: it is free (no `image-magnific-search` credit line any more); `--type` survives as `photo|illustration|vector` (PSDs and mockups are the one thing genuinely lost); `--license`, `--ai`, `--people` and `--order` now fail with a fix naming the replacement rather than being silently dropped; and `--orientation` loses `panoramic` while `--size` and `--locale` are new. Library rows already ingested from Magnific keep `source: "magnific"`, stay searchable, and remain a valid `--source` filter; nothing writes that value any more.
 
-**Migrating from Tenor:** the old `baker images meme` command and Tenor provider have been removed. Use `baker images gif` (Giphy) instead. Existing library rows ingested via Tenor remain stored with `source: "tenor"` but are no longer returned by `baker images find` and `--source tenor` is no longer a valid filter on `library`. Re-ingest via `baker images gif --auto-ingest N` if you need fresh equivalents.
+**Migrating from Tenor:** the old Tenor provider has been removed. Use `baker images gif` (Giphy) instead (`baker images meme` is now a different command: the real meme templates from Imgflip). Existing library rows ingested via Tenor remain stored with `source: "tenor"` but are no longer returned by `baker images find` and `--source tenor` is no longer a valid filter on `library`. Re-ingest via `baker images gif --auto-ingest N` if you need fresh equivalents.
 
 ### `baker images library <query>`
 
@@ -3655,17 +3665,22 @@ the brands it won and lost inside. A common pattern is not a winning one: `count
 ### `baker winning-ads fit <adId>`
 
 Before building on a reference: why the ad wins, read against **this** company. One billed vision call, cached per ad
-under `canvas/.cache/fit/<platform>-<adId>.json` (asking again is free).
+under `canvas/.cache/fit/<platform>-<adId>.json` (asking again is free), asked at temperature 0 so the same ad, idea and
+rules read the same in every workspace. A person of the reference (a celebrity, an actor, the advertiser's own people) is never kept. A meme's job goes
+to a real meme our buyer persona relates to (`baker images meme`), not necessarily the reference's own.
 
 ```bash
 baker winning-ads fit a_12345 --platform meta
 ```
 
 Returns `why_it_wins` in five layers (`disguise`, `voice`, `trigger`, `attention`, `logic`), the `load_bearing`
-elements that carry them (each with what it `needs`, whether the company has it: `have` | `adapt` | `missing`, and
-`ours`, what replaces it), a `verdict`: `use`, `adapt` or `reject`, and what made the ad a winner, so what an ad built
+elements that carry them, always what stops the scroll (`job: stop`) and the proof that makes it believed (`job:
+proof`) as they show in the picture (each with what it `needs`, whether the company has it: `have` | `adapt` |
+`missing`, what our ad does with it, `decision`: `keep` | `replace` | `impossible`, `ours`, what of ours does its job,
+and `rule`, the company rule that forbids it, quoted), a `verdict`: `use`, `adapt` or `reject` (a stop or proof that is
+`impossible` for us is a `reject`, whatever the model said; a cached fit that names neither is asked again), and what made the ad a winner, so what an ad built
 on it carries (`carry`: `whole_ad`, `layout`, `hook` or `angle`, with `carry_why`; renders see the reference's picture
-only at `whole_ad` or `layout`). The company's Knowledge, reviews and market, and the library's evidence that the ad won
+only at `whole_ad` or `layout`). The company's Knowledge, reviews, market and Avatars, and the library's evidence that the ad won
 (its winner category, angle, hook and composition), ground the answer. `baker canvas scaffold-static-ad --source-ad-id <adId> --source-platform <platform>` reads the cached
 answer, writes it into `prompt.json` as `concept`, and refuses a `reject` with `concept_does_not_fit` before anything is
 billed; the hint names the platform the fit was asked on, so a TikTok or LinkedIn reference is read from its own library.
@@ -4897,6 +4912,18 @@ Local; no credits (one box-reader call per variant, about $0.005, which rides on
 
 Local; no credits (one box-reader call, about $0.005, which rides on the run record's review spend). Brings a finished 9:16's words and logo inside the band Reels or Stories leave clear without rendering again: reads where every line and the logo sit and, when any reaches past the band, shrinks the whole picture a little (to 85% at most) and shifts it, carrying its edge into the uncovered margin, only when that edge is plain ground; where the review blocks a line under Reels' or TikTok's buttons down the right (an ad set that runs there and not in Stories), the fit clears them too (a busy edge would read as a blurred duplicate, so the picture is passed on as rendered). The image model cannot move an element by a few points on request, so this replaces re-rendering for small misses. **Inputs:** `image`. **Params:** `format`, `placements` (the ad set's, as the sizes were planned). **Outputs:** `image` (same pixel size), `fit` (`{ scale, x, y }`, or null when passed on unchanged), `reason` (`not_read`, `inside_band`, `too_far` when clearing the band needs more than the 85% shrink, or `busy_edge` when the edge it would carry is not plain ground) and `usage`. Scaffolded by `scaffold-static-ad` after every 9:16 Reels or Stories covers (`safe_<size>`, tagged `static_safe_fit`). It never sets the picture over a blurred or mirrored copy of itself: a layout `too_far` or `busy_edge` is passed on as it is, the run review names what Reels or Stories covers, and `baker canvas run` lays that size out again by itself.
 
+##### `static_logo`
+
+Local; no credits (two box-reader calls, the words and the people and products, about $0.01, which ride on the run record's review spend). Places the brand's logo file on one delivered size pixel for pixel, never drawn by a model, and only where a designer sets a logo: a top corner or the top centre just inside the safe area (on a 9:16, just below the band Stories and Reels cover), a bottom corner at the safe area's foot (off Reels' buttons on the lower right), or beside the button on its row at the margin when the button sits at the foot; never the middle of an edge or a spot inside the picture. The size's brief reserves its slot by the same function (`chooseLogoSpot`; a `static_format`'s `logo_slot`, chosen on the cut before any word is set, off every person, face and product, on plain ground) and the composite keeps that slot while it is still clean. Otherwise it takes the first such place whose whole box (the logo, its clear space, a plate when it needs one) is off every words box, keeps its clear space off every person, face and product, and has no straight edge through it (a card's border, a window's frame, a phone's bezel): on plain ground where the logo reads at a quarter of the frame wide (held between 5% and 9% of the width tall), then a fifth, then a sixth; else the first clean place on a small plate in a brand colour. With no clean place at all it stamps nothing and flags the size (`no_room`): the review sends the node that set the size's words (`format_<size>`, or the render that laid it out again) back with the corner kept clear; a re-laid-out ad's lead size, which is the chosen picture itself, is asked for as a `--fix` of that picture with the corner plain. Of the logo's files (`inputs.logos`: the brand's file and the same artwork in its other colours, `logo-light.svg` beside `logo-dark.svg`) it places the first, in that order, that reads on the ground measured under it (contrast 3:1), else the one that stands out most; a file inked in the text colour (`currentColor`) is drawn in each of `inks` (the brand's accent, its ink, white; projected from prompt.json) and the first that reads is placed (`facts.ink`). An SVG is drawn at the slot's size and every file cut to its artwork. The variant checks (`static_prefilter` `checks.logo_slot`) set aside a re-laid-out variant that puts a line in the master's slot, and no variant is ranked for a logo it was told not to draw. Then it checks the size: the logo and the headline (`params.copy`) each wholly inside the frame and the safe area, and no line of the copy under the logo. **Inputs:** `image`, `logos`, `slot` (optional). **Params:** `format`, `placements`, `position` (`top_left`, `top_right`, `bottom_left`, `bottom_right`, `top_centre`, `bottom_centre`; a bottom centre is tried as the bottom corners), `aspect` (the logo's shape the slot was planned with), `copy`, `inks`, `plates`. **Outputs:** `image`, `facts` (`box`, `slot`, `variant`, `ink`, `ground`, `contrast`, `headline`, `read`, and `problems`, each blocking in the run review) and `usage`. Scaffolded by `scaffold-static-ad` as the last step of every size when the brand has a logo file (`logo_<size>`, tagged `logo_composite`).
+
+##### `static_format`
+
+Local; one image call at the words model's price, reported by the backend (nothing is recorded when the call is replayed), plus a box-reader call (and a subject-reader call when no `subjects` are wired) riding on the run record's review spend. Delivers one size of a static ad from its picture (a plate with no designed words): cuts the size at one scale around the people and products (a face, an animal or a product is never cut, a person only at the bottom), has the image model set the ad's designed words, logo and button on that cut (shown at a ratio the model renders, a 3:4 holding a 4:5), lines its render up with the cut and keeps only what changed at the words (a scrim or card over the picture as a tone on its own pixels, a face never redrawn, text that is part of the scene never taken, and with the copy to go by, any line the copy does not name, such as a phone's status-bar time, is the scene's), then moves each block of words that reaches past the band the size's placements leave clear, or sits on a face of the picture, on its own (shifted first, shrunk to 80% at most, never more than 12% of the height; a change the model made that a tone does not explain, such as a person drawn again, is put back to the picture). Everything outside the words is the picture's own pixels, checked on every run. The paid call is a step of its own: changing only the band, the placements or the node's version replays it free; `--regenerate format_<size>` pays for it again. **Inputs:** `plate`, `subjects` (the plate's subject boxes), `logo`, `type`, `style`, `refs`, `previous` (the last words render, for an edit). **Params:** `format`, `lead`, `placements`, `words` (`model`, `quality`, `prompt`, `edit.instruction`), `copy` (the designed lines), `in_scene` (lines that are part of the picture), `core` (where to centre the cut when no subject was read), `band_min_scale`, `check_formats` (the other sizes cut from the same picture: when one would cut a face or the product, no words are paid for and the size reports `subject_cut`), `logo_slot` (`aspect`, `position`: the brand's logo file is placed on the size afterwards, so the words draw no logo and keep its slot empty, chosen on the cut by the function its `static_logo` places it with: a designer's place inside the size's safe area, off every person, face and product, on plain ground and through no straight edge; the words are told to start below a top slot or end above a bottom one, and words set there are set again, never moved out of it). **Outputs:** `image` (the size at its delivered pixels), `cut`, `words_raw`, `words_alpha`, `logo_slot` (the slot kept empty, in the size's pixels, for its `static_logo`), `facts` (crop, upscale, each block's move, how far the render sat from the cut once lined up, `reason`: `band_too_far`, `words_over_face`, `subject_covered` (the words hide most of a product or animal, named in `covered`), `subject_cut`, `words_misaligned` or `not_read`, the share the model changed that was put back, and each step's credits; carried on the run record) and `usage`.
+
+##### `static_plate`
+
+Local; one image call at the painter's price when anything is missing, reported by the backend, plus a subject-reader call (and, for `from_ad`, a box-reader call) riding on the run record's review spend. Makes a static ad's picture from a picture that exists, kept pixel for pixel, the image model painting only what is missing: `widen` extends the chosen picture sideways to a wide shape (16:9, 21:9), keeping the full-width band its subjects need, so the wide sizes show the tall ones' own people and products; `from_ad` paints an approved ad's words, logo and button out and extends its frame to the plate's shape. A picture a plain cut already gives is cut, nothing painted or billed. **Inputs:** `image`, `subjects`. **Params:** `mode`, `aspect_ratio`, `paint` (`model`, `quality`, `prompt` added after the painting instruction), `copy` and `in_scene` (`from_ad`). After painting, the plate is read twice for subjects standing where only painting was: a person, face or animal, or a product repeating one the kept part shows, is `reason: subject_added` (named in `added`), and every size cut from the plate is blocked by the run's review. **Outputs:** `image` (the plate), `shown`, `painted`, `subjects` (on the plate), `facts` (what was kept and where, the share painted, the boxes cleared, `reason`, `added`) and `usage`.
+
 ##### `font_specimen`
 
 Render specimen text in a given font file to a **PNG** — black `#000` text on a white `#fff` background — via headless Chromium at 2× device-scale. Produces a **typeface reference image**: wire `image` into `image_generate`'s `reference` input so the model replicates the font when generating images that contain text.
@@ -6097,7 +6124,7 @@ when the viewer can only guess what is offered, is sure of something else, or, f
 cart, a trial, a donation, a registration); who it is for is reported but never fails an ad alone. The viewer is the `viewer` recorded in
 `_definition.md`, else the one its `targetAdSet` reaches (as `baker ads meta adsets --audience` reads it), else
 the persona and `awareness` from the Knowledge, else a cold stranger. Not understood → exit 2 with
-`viewer_check_failed` and a `fix` that starts with the one rewrite answering a missed offer (`Do this: make the biggest words say "<message>"`) and names what the viewer missed. After two failures of one ad in a chat turn the check no longer holds it back: the command answers `ok: true` with `understood: false` and what was missed, and `baker canvas run` renders it, printing the miss. The casting check is asked alongside the viewer. Answers are cached per copy, scene and viewer.
+`viewer_check_failed` and a `fix` that starts with the one rewrite answering a missed offer (`Do this: make the biggest words say "<message>"`) and names what the viewer missed. After two failures of one ad in a chat turn the check no longer holds it back: the command answers `ok: true` with `understood: false` and what was missed, and `baker canvas run` renders it, printing the miss. The casting check is asked alongside the viewer; it judges who each person is against the company's rules, never how the ad shows them (a rule like "people only as small round photos" is the finished ad's review). Answers are cached per copy, scene and viewer.
 Before either, a static ad whose scene quotes words, or names a price or a share, that the copy (or `scene_text`) does not hold is refused (`scene_words_not_in_copy`): the picture would print them and a correction round would erase them. An unreadable `prompt.json` names each wrong field in a line and shows that field's shape. `baker canvas run` makes the same check on a static ad before it spends (skipped for `--fix`, an autofix round, `--use-variant`, a re-layout and resumed runs, never for an edit of the words;
 `--skip-viewer-check` renders without it; a model outage lets the render through with a warning). `--full` adds
 the viewer's whole answer and how the viewer was chosen.
@@ -6144,9 +6171,9 @@ A completed render the review calls ready (`verdict` `ready` or `ready_with_note
 
 **Resuming an interrupted run.** A long `baker canvas run` (multi-clip video) that is killed mid-render — session end, sandbox pause — leaves a marker under the outputs dir. The next `baker canvas run` of the same canvas automatically **resumes** that run: it reuses the run id so still-running billed jobs re-attach instead of being abandoned and re-billed, and completed nodes come from the cache. A live render keeps its marker's heartbeat fresh, so a second `run` of the same canvas is refused while it is alive (checked with `kill(pid, 0)` plus the heartbeat, on Linux and macOS alike). Resume also works from a **different workspace or a fresh sandbox**: when no local marker survives, the run history is consulted for a resumable run of the same source (canvas, `prompt.json`, scenes, compositions and formats), and it is adopted when the backend says it may be: interrupted, stopped at a checkpoint, or a `running` row whose keepalive is older than the backend's staleness threshold. Ctrl-C / SIGTERM aborts gracefully — no new nodes dispatch, a resumable snapshot is flushed, and the marker survives. A clean completion (or a handled failure) clears the marker, so a normal re-run starts a fresh generation. Force a new run with `--fresh`, or pin a specific run with `--run-id <id>` (also the escape hatch to adopt a run that is reported as concurrently live). Independent same-layer nodes (e.g. video clips) fan out in parallel up to `--parallel`/`--concurrency` (default 8; env `BAKER_CANVAS_CONCURRENCY`).
 
-**Static ads: the run corrects a blocking defect itself.** When the review of a static ad finds a blocking defect, `baker canvas run` makes up to 3 more renders (`AUTO_FIX_ROUNDS` in `static-autofix.ts`) before it reports, correcting each defect at the layer that causes it: words or a logo where an interface covers them (Reels, Stories) or the frame cuts them are **placed and extended** (`withExtendedSizes`): a `static_place` node reads where everything sits and shrinks the ad (to 60% at most) into the size's safe area, and a `static_extend_merge` node has the ad's own model paint the margins that leaves and keeps its painting as one picture across the whole frame, laying the ad's own pixels back only over the words, logo and buttons the placing read (padded and feathered, so no edge of the shrunk ad shows; the whole ad is laid back, as before, when nothing was read or the painting moved the words), so the model is never asked to move anything (a size already inside its area is passed on with nothing painted or billed, and one whose words sit too far out for a shrink to clear, or that the placing found inside its area while the review still blocks it, is laid out again instead, never placed the same way twice; a button is placed by its shape, its words grown by 0.7 of their height on every side, as the review judges it); a defect the spec asked for (a second subject, stars with no named source, a concept that does not read) and any defect of a native screen corrects the spec first (`static-spec-repair.ts`: a model rewrites `prompt.json` for those findings alone, every line of the copy kept word for word), then draws the ad again from it (a native screen redraws free); a picture wrong as a whole or in three places or more is made again from its brief, told what the last one got wrong, but only in a round with another after it unless the brief caused the defect; anything else on the picture is a `--fix` of the chosen picture for its own findings (`correctionOf`: the words to erase, the line to re-letter or add), naming what the last edit was already asked for, while each re-laid size the review flagged follows as an edit of its own last layout (`withSizesFollowingFix`), keeping what an earlier round fixed in it, and a size it found nothing blocking on is delivered as it was (`keep`, nothing in it made again or placed); anything else on a re-laid size alone edits just that size from its own last layout (`withRelayEdit`); sizes that do not show the same ad (`SIZES:`) are always the re-laid ones' fault, since every size follows the chosen picture, so they are laid out again to show exactly what it shows, never the picture edited to match them. A size a round did not touch (its file the same byte for byte) keeps the round before's verdict (`carryUnchanged`) and is not read again: the review reads only the sizes the round changed. Each correction is told what earlier rounds fixed so it keeps it right (`keptRules`), and starts from the best attempt so far: one that came out with more blocking defects than an earlier attempt is set aside and the earlier one corrected instead (`correctFrom`). Each round is one render (a fix, or one request per re-laid size) and prints `[autofix] round N of 3: …` on stdout; the final JSON's hints start with "Corrected automatically before this result, …" and its review is of the corrected version. Blocking findings left after the rounds keep the hints below. A round that would only repeat the correction that just left its defect in place (a chosen option, `--use-variant`, is only ever corrected) is not run: that version is reported as it is. `--no-autofix` reports after the first render.
+**Static ads: the run corrects a blocking defect itself.** When the review of a static ad finds a blocking defect, `baker canvas run` makes up to 3 more renders (`AUTO_FIX_ROUNDS` in `static-autofix.ts`) before it reports, correcting each defect at the layer that causes it: words or a logo where an interface covers them (Reels, Stories) or the frame cuts them are **placed and extended** (`withExtendedSizes`): a `static_place` node reads where everything sits and shrinks the ad (to 60% at most) into the size's safe area, and a `static_extend_merge` node has the ad's own model paint the margins that leaves and keeps its painting as one picture across the whole frame, laying the ad's own pixels back only over the words, logo and buttons the placing read (padded and feathered, so no edge of the shrunk ad shows; the whole ad is laid back, as before, when nothing was read or the painting moved the words), so the model is never asked to move anything (a size already inside its area is passed on with nothing painted or billed, and one whose words sit too far out for a shrink to clear, or that the placing found inside its area while the review still blocks it, is laid out again instead, never placed the same way twice; a button is placed by its shape, its words grown by 0.7 of their height on every side, as the review judges it); on a size cut from one picture, a halo, a seam, a box or patch behind the words or a smear beside the button that its words left has that size's words set again from scratch on the same picture (`--regenerate format_<size>`), never new pictures, even when the review types it as a defect of the picture; a defect the spec asked for (a second subject, stars with no named source, a concept that does not read) and any defect of a native screen corrects the spec first (`static-spec-repair.ts`: a model rewrites `prompt.json` for those findings alone, every line of the copy kept word for word), then draws the ad again from it (a native screen redraws free); a size that lost what stopped the scroll or the proof of its proven ad has the spec repaired toward that ad, told what of ours `concept.load_bearing` declares carries each (a repair may ground the Avatar the concept declares in an ad that cast nobody, never another person, and never takes that Avatar away), and when no repair is written the corrections stop (`[autofix] stopped`) with the hint to restore it as the plan decided or build the idea on another proven ad, the version never shown as done; a picture wrong as a whole or in three places or more is made again from its brief, told what the last one got wrong, but only in a round with another after it unless the brief caused the defect; anything else on the picture is a `--fix` of the chosen picture for its own findings (`correctionOf`: the words to erase, the line to re-letter or add), naming what the last edit was already asked for, while each re-laid size the review flagged follows as an edit of its own last layout (`withSizesFollowingFix`), keeping what an earlier round fixed in it, and a size it found nothing blocking on is delivered as it was (`keep`, nothing in it made again or placed); anything else on a re-laid size alone edits just that size from its own last layout (`withRelayEdit`); sizes that do not show the same ad (`SIZES:`) are always the re-laid ones' fault, since every size follows the chosen picture, so they are laid out again to show exactly what it shows, never the picture edited to match them. A size a round did not touch (its file the same byte for byte) keeps the round before's verdict (`carryUnchanged`) and is not read again: the review reads only the sizes the round changed. Each correction is told what earlier rounds fixed so it keeps it right (`keptRules`), and starts from the best attempt so far: one that came out with more blocking defects than an earlier attempt is set aside and the earlier one corrected instead (`correctFrom`). Each round is one render (a fix, or one request per re-laid size) and prints `[autofix] round N of 3: …` on stdout; the final JSON's hints start with "Corrected automatically before this result, …" and its review is of the corrected version. Blocking findings left after the rounds keep the hints below. A round that would only repeat the correction that just left its defect in place (a chosen option, `--use-variant`, is only ever corrected) is not run: that version is reported as it is. `--no-autofix` reports after the first render.
 
-**Static ads: correct a version, or use another of its variants.** Correct a finished version with `--fix "<what to change>"`: one render takes that version (the last one, or `--from <run_id>`) as its first reference and changes only what you said, keeping the picture, the layout and every other word, and every size is made again from the corrected picture. **A correction grows on top of the version it starts from**: the run executes that version's own graph (its variants, the prefilter and pick, every earlier correction) with each of those steps pinned to the outputs that version recorded (free, never re-rendered, whatever `prompt.json` says now), then appends `edit_1` (the picture as its first reference, framed for the master as a variant is) and makes the sizes from it; a second correction appends `edit_2` on `edit_1`. `--use-variant` wires the chosen variant from the version's own `gen` as a `chosen` step, and a `--regenerate adapt_<size>` keeps the version's picture the same way. So the run record, and the dashboard's workflow of each version, show the whole history: options, pick, edits, sizes. The canvas file is never rewritten. Every static run keeps the graph it executed in the asset store (`graphUrl` on its run record, up to 4 MB), so a version rendered in another workspace ("Edit creative …" from a new chat, `--from <run_id>`) grows the same way, its steps pinned to the outputs its run record holds; only a run recorded before graphs were kept is corrected from its picture by URL. **A `prompt.json` changed only in its words, their positions or its colours** since the version shown is made the same way, as an edit of that version (`[edit]` in the output, the instruction read off the change); three new options are asked for only with `--regenerate static_variants`. A `--fix` whose defect is still blocking afterwards is recorded, and asking for it again with the same words exits 2 with `no_progress`. When every blocking finding is on re-laid-out sizes, the first hint says to lay out those sizes again (`--regenerate adapt_<size>`) before any `--fix`. Every static run's hints say what it cost in credits and what for. There is no render limit per creative. Use another variant with `--use-variant <sha256>` (`--from <run_id>`, default the last render): when the person asks in the chat for another of a version's variants over the judge's pick, every size is made again from that picture, and the only requests re-lay it out for each other size; `--regenerate adapt_9x16` lays out one size again from the same chosen picture when only that size came out wrong (after a `--fix` or `--use-variant`, from that corrected or chosen picture, so the size never brings back the uncorrected one; `--from <run_id>` names another version).
+**Static ads: correct a version, or use another of its variants.** Correct a finished version with `--fix "<what to change>"`: one render takes that version (the last one, or `--from <run_id>`) as its first reference and changes only what you said, keeping the picture, the layout and every other word, and every size is made again from the corrected picture. **A correction grows on top of the version it starts from**: the run executes that version's own graph (its variants, the prefilter and pick, every earlier correction) with each of those steps pinned to the outputs that version recorded (free, never re-rendered, whatever `prompt.json` says now), then appends `edit_1` (the picture as its first reference, framed for the master as a variant is) and makes the sizes from it; a second correction appends `edit_2` on `edit_1`. `--use-variant` wires the chosen variant from the version's own `gen` as a `chosen` step, and a `--regenerate format_<size>` (or `adapt_<size>`) keeps the version's picture the same way. So the run record, and the dashboard's workflow of each version, show the whole history: options, pick, edits, sizes. The canvas file is never rewritten. Every static run keeps the graph it executed in the asset store (`graphUrl` on its run record, up to 4 MB), so a version rendered in another workspace ("Edit creative …" from a new chat, `--from <run_id>`) grows the same way, its steps pinned to the outputs its run record holds; only a run recorded before graphs were kept is corrected from its picture by URL. **A `prompt.json` changed only in its words, their positions or its colours** since the version shown is made the same way, as an edit of that version (`[edit]` in the output, the instruction read off the change); three new options are asked for only with `--regenerate static_variants`. A `--fix` whose defect is still blocking afterwards is recorded, and asking for it again with the same words exits 2 with `no_progress`. When every blocking finding is on some sizes, the first hint says to make those sizes again (`--regenerate format_<size>` on one picture, `adapt_<size>` when laid out again) before any `--fix`. Every static run's hints say what it cost in credits and what for. There is no render limit per creative. Use another variant with `--use-variant <sha256>` (`--from <run_id>`, default the last render): when the person asks in the chat for another of a version's variants over the judge's pick, every size is made again from that picture, and the only requests re-lay it out for each other size; `--regenerate format_9x16` (`adapt_9x16` when laid out again for each size) makes one size again from the same chosen picture when only that size came out wrong (after a `--fix` or `--use-variant`, from that corrected or chosen picture, so the size never brings back the uncorrected one; `--from <run_id>` names another version).
 
 #### `baker canvas scaffold-video <video> [flags]`
 
@@ -6259,14 +6286,15 @@ Turn a source/inspiration image into a **runnable, self-validated static-ad canv
 
 **A library ad is read once for every company.** With `--source-ad-id` and the library's own picture (no `<image>`, `--context`, `--describe-model` or `--select-model`), both passes below come from `POST /api/ad-library/reference-read`: the backend reads the ad from Ad DNA's picture, grounded in its full DNA, and keeps the read for every company. The first build on an ad pays for it (~40 s); every later one, in any company, gets it at once and free. When the shared read cannot be had, the passes run here as before.
 
-1. **`image_describe`** (`~google/gemini-flash-latest`) — reverse-engineers the image (layout by what fills each region, copy verbatim, typefaces, capture in words, the `mechanism` and the `audience` it is built for) and writes it next to the canvas as **`prompt.json`**, an **ad spec** (`"schema": "baker-static-ad/3"`; `/2` still reads) you rewrite into the ad you want: `viewer` (who sees it and what they already know), `message` (the one thing it tells them, never printed), `copy` (each line with `lettering`: `in_scene`, written on something in the picture (`on`, `look`), or `designed`, set in the brand's face), `scene` (`description`, `look`: photo | designed | illustration, `capture` in words, `mood`, `layout`), `brand`, `colors` (each tied to an object, from the brand palette), `references` (one picture each, labelled by role: `PERSON_1`, `ANIMAL_1`, `PRODUCT_1`, `BADGE_1`, `PROP_1`), `logo` (and `logo_position`), `third_party_brands` (other brands the offer is about, a car brand on a car loan: `name`, `what`, and `logo` naming the `BADGE_n` reference of its logo; their logos may appear), an optional `direction`, the `mechanism` to rebuild for our brand, and in `/3`: `viewer.market` (`country`, `language`, `currency`), `brand_presence` (`standard` | `native`: a native disguise carries the logo as its sender and no big button), `recognition` (the kind of product a stranger must take it for at a glance, never the format), `native` (the ad is a screen people know, drawn exactly from HTML at every size by the free `static_native` node instead of painted: `x_post` (a post or a thread, with `reply_to`), `whatsapp`, `imessage`, `trustpilot`, `google_reviews`, `notes`, `slack`; on a 9:16 the app is drawn full screen as a phone shows it: status bar and app header pinned at the top, the reply bar and tab bar (or a keyboard under a chat or note) pinned at the bottom, the posts or messages as large as the clear band holds, and the frame's headline, caption and logo a card in the brand's colours under the app's header; a wall of reviews (`trustpilot`, `google_reviews`) takes up to 16 real reviews, the first two (`FEATURED_REVIEWS`) the ad's copy set whole in the safe area and the rest filling the whole frame behind them as large, sharp cards, turned and cut by its edges, because a wall wins on how many there are; a review longer than 160 characters is shown cut at a word with "…", and that cut text is the copy the review reads back; a chat (`whatsapp`, `imessage`) on a 9:16 never shrinks below about 62% of the phone scale: its earliest messages scroll up under the header, as the app does, the node's optional `scrolled` output lists the copy lines scrolled off that size, and the run review expects those lines nowhere on it; a logo file whose drawing runs off its own edge is set aside for a whole one, and a square mark where a wordmark goes is drawn larger; the run review never flags the app's own interface words (status bar, keyboard) as under Reels; those words ("Today", "Verified", "Post your reply") are printed in the viewer's language: Spanish, Portuguese and English as checked against the apps, any other written once by a text model and cached per language (`scripts/interface-words-evals`), English when it cannot; the image model renders only the screen's `photos`, each a plain phone photo of ordinary people of the market; adding the block switches an existing ad on its next run, `--fix` does not apply, an invented brand handle or a rating the Knowledge does not hold (either decimal mark) is refused as `native_screen_invalid`, and a photo of ours goes in as its `image`: a native photo takes no `avatar`, since nothing would cast it), a role on each third-party brand (`partner` | `proof` | `category_signal`), a reference's `image` (wired as a picture of ours) and a person's `avatar` (the company avatar cast), and `concept` (`why_it_wins` in five layers, `load_bearing` elements with `have`/`adapt`/`missing` and `ours`, `verdict` `use`|`adapt`|`reject`, `transfer_note`; seeded from `baker winning-ads fit`). Every render keeps the load-bearing elements; `validate`/`run` refuse a `reject` or a `missing` element with nothing named (`concept_does_not_fit`) and a rating, or a promised price, share, multiple or time, the Knowledge does not hold with that unit, or a superlative it does not make (`proof_without_source`), in any language or several in one ad: a text model reads each claim of the copy and of the Knowledge as a kind, a number and a unit (cached by text, billed with the next run), code compares them exactly, and the decision model (Jev) judges a superlative; with no model, every number the copy writes in digits must be in the Knowledge (`claim-check.ts`, eval: `scripts/claim-check-evals`); a line citing a review platform gets its real badge wired (Trustpilot, G2 and the like by name; Google, Google Play or the App Store when the line shows stars or a score, or the decision model reads it as citing them for reviews in any language, `scripts/review-citation-evals`). **You never write a model prompt**: every render prompt is compiled from this file for the model it runs on (short labelled sections for gpt-image, sentences with reasons for Gemini; each line quoted once; pictures numbered with one role each; colours from the brand; realism as capture cues; the safe area from its one owner; constraints last), on every `validate` and `run`, and shown on its node. A `prompt.json` written before the ad spec (the describe blueprint) is read through an adapter and keeps working. The source's own read (`source`, and the library's `reference`) stays as bookkeeping and is never sent to a model.
+1. **`image_describe`** (`~google/gemini-flash-latest`) — reverse-engineers the image (layout by what fills each region, copy verbatim, typefaces, capture in words, the `mechanism` and the `audience` it is built for) and writes it next to the canvas as **`prompt.json`**, an **ad spec** (`"schema": "baker-static-ad/3"`; `/2` still reads) you rewrite into the ad you want: `viewer` (who sees it and what they already know), `message` (the one thing it tells them, never printed), `copy` (each line with `lettering`: `in_scene`, written on something in the picture (`on`, `look`), or `designed`, set in the brand's face), `scene` (`description`, `look`: photo | designed | illustration, `capture` in words, `mood`, `layout`), `brand`, `colors` (each tied to an object, from the brand palette), `references` (one picture each, labelled by role: `PERSON_1`, `ANIMAL_1`, `PRODUCT_1`, `BADGE_1`, `PROP_1`), `logo` (and `logo_position`), `third_party_brands` (other brands the offer is about, a car brand on a car loan: `name`, `what`, and `logo` naming the `BADGE_n` reference of its logo; their logos may appear), an optional `direction`, the `mechanism` to rebuild for our brand, and in `/3`: `viewer.market` (`country`, `language`, `currency`), `brand_presence` (`standard` | `native`: a native disguise carries the logo as its sender and no big button), `recognition` (the kind of product a stranger must take it for at a glance, never the format), `native` (the ad is a screen people know, drawn exactly from HTML at every size by the free `static_native` node instead of painted: `x_post` (a post or a thread, with `reply_to`), `whatsapp`, `imessage`, `trustpilot`, `google_reviews`, `notes`, `slack`; on a 9:16 the app is drawn full screen as a phone shows it: status bar and app header pinned at the top, the reply bar and tab bar (or a keyboard under a chat or note) pinned at the bottom, the posts or messages as large as the clear band holds, and the frame's headline, caption and logo a card in the brand's colours under the app's header; a wall of reviews (`trustpilot`, `google_reviews`) takes up to 16 real reviews, the first two (`FEATURED_REVIEWS`) the ad's copy set whole in the safe area and the rest filling the whole frame behind them as large, sharp cards, turned and cut by its edges, because a wall wins on how many there are; a review longer than 160 characters is shown cut at a word with "…", and that cut text is the copy the review reads back; a chat (`whatsapp`, `imessage`) on a 9:16 never shrinks below about 62% of the phone scale: its earliest messages scroll up under the header, as the app does, the node's optional `scrolled` output lists the copy lines scrolled off that size, and the run review expects those lines nowhere on it; a logo file whose drawing runs off its own edge is set aside for a whole one, and a square mark where a wordmark goes is drawn larger; the run review never flags the app's own interface words (status bar, keyboard) as under Reels; those words ("Today", "Verified", "Post your reply") are printed in the viewer's language: Spanish, Portuguese and English as checked against the apps, any other written once by a text model and cached per language (`scripts/interface-words-evals`), English when it cannot; the image model renders only the screen's `photos`, each a plain phone photo of ordinary people of the market; adding the block switches an existing ad on its next run, `--fix` does not apply, an invented brand handle or a rating the Knowledge does not hold (either decimal mark) is refused as `native_screen_invalid`, and a photo of ours goes in as its `image`: a native photo takes no `avatar`, since nothing would cast it), a role on each third-party brand (`partner` | `proof` | `category_signal`), a reference's `image` (wired as a picture of ours) and a person's `avatar` (the company avatar cast), and `concept` (`why_it_wins` in five layers, `load_bearing` elements with `have`/`adapt`/`missing` and `ours`, `verdict` `use`|`adapt`|`reject`, `transfer_note`; seeded from `baker winning-ads fit`). Every render keeps the load-bearing elements; `validate`/`run` refuse a `reject` or a `missing` element with nothing named (`concept_does_not_fit`), and a plan that drops what stops the scroll (`job: stop`) or the proof (`job: proof`): one left `impossible` or replaced with nothing named, replaced with an Avatar `references` does not ground or the cast does not name, or decided otherwise in prompt.json than in the thinking's decision lines under "What survives and what changes" (the fix names each element, and says to build on another proven ad when one cannot be ours) and a rating, or a promised price, share, multiple or time, the Knowledge does not hold with that unit, or a superlative it does not make (`proof_without_source`), in any language or several in one ad: a text model reads each claim of the copy and of the Knowledge as a kind, a number and a unit (cached by text, billed with the next run), code compares them exactly, and the decision model (Jev) judges a superlative; with no model, every number the copy writes in digits must be in the Knowledge (`claim-check.ts`, eval: `scripts/claim-check-evals`); a line citing a review platform gets its real badge wired (Trustpilot, G2 and the like by name; Google, Google Play or the App Store when the line shows stars or a score, or the decision model reads it as citing them for reviews in any language, `scripts/review-citation-evals`). **You never write a model prompt**: every render prompt is compiled from this file for the model it runs on (short labelled sections for gpt-image, sentences with reasons for Gemini; each line quoted once; pictures numbered with one role each; colours from the brand; realism as capture cues; the safe area from its one owner; constraints last), on every `validate` and `run`, and shown on its node. A `prompt.json` written before the ad spec (the describe blueprint) is read through an adapter and keeps working. The source's own read (`source`, and the library's `reference`) stays as bookkeeping and is never sent to a model.
 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`). The describe pass also records the ad's **typography** (each typeface's classification, a best-guess family, and its weight/case), which seeds the spec's `brand.typeface`. Background extras are dropped. Each element becomes a `references` entry in the spec, named by its role and naming the canvas slot it fills, so the file says which slot grounds which subject.
 
 It then scaffolds a canvas on which **the image model designs the finished ad**, holding only what `prompt.json` holds; no element is mandatory:
 
-- Up to **three variants** (`--takes`, default 3) render on the model the router picks for the concept (today `openai/gpt-image-2.5-sunburst` at quality `xhigh`, about 45 s a picture against 80 s at `max`; `--gen-model` overrides), each a finished ad: the picture and every word of the copy. Each variant is **its own request** (tagged `static_variant_call`), run in parallel on its own direction (the scene as written; another picture of the same message, by the scene's look; another line leading, named by number so no word changes), and a `collect` tagged `static_variants` gathers them, on every model: one request with `n` costs the same (`n` is billed per picture) but gave fewer distinct options, so the graph never uses it. The brief quotes every line of `copy` verbatim and asks for each once; it is compiled again from `prompt.json` on every `validate` and `run`, so an edit re-keys exactly the renders it touches. The brand's **typeface** is shown to the model as a `font_specimen` set on the `designed` lines: a file in `src/brand/fonts/` (via `src/brand/tokens.json` when present), else the heading family `tokens.json` or `BRAND.md` names, fetched as a web font file; an `in_scene` line keeps its own lettering only on the real packaging, signage or screen its `on` names (handwriting on post-its, whiteboards or chalkboards, and a line naming no surface, are set as designed type). Each line's `role` sets its size: a price or stat (else the headline) leads, the `cta` is a large solid button, fine print is smallest. **The logo is optional**: the real file in `src/brand/logos/` goes to the model as a reference to reproduce once, at least a fifth of the frame wide, where it contrasts or on a small brand-colour plate, only when `prompt.json` has `"logo": true` (an older blueprint: an `advertiser_brand` entry in `brands_logos`) and the file exists; no logo is never an error, never a slot to fill and never a stand-in. Setting it false drops the logo on the next run; adding one to a canvas scaffolded without the file needs the file in `src/brand/logos/` and a re-scaffold. `prompt.json` also carries a **`brand`** block (ground, ink, accent, CTA and palette, from `src/brand/tokens.json` roles or `BRAND.md`); a colour outside it never reaches the model. The brief describes a complete ad at the master's shape and asks only for its edge margin (see below). `baker canvas set-prompt` refuses these nodes and names `prompt.json`.
+- Up to **three variants** (`--takes`, default 3) render on the model the router picks for the concept (today `openai/gpt-image-2.5-sunburst` at quality `xhigh`, about 45 s a picture against 80 s at `max`; `--gen-model` overrides), each a finished ad: the picture and every word of the copy. Each variant is **its own request** (tagged `static_variant_call`), run in parallel on its own direction (the scene as written; another picture of the same message, by the scene's look; another line leading, named by number so no word changes), and a `collect` tagged `static_variants` gathers them, on every model: one request with `n` costs the same (`n` is billed per picture) but gave fewer distinct options, so the graph never uses it. The brief quotes every line of `copy` verbatim and asks for each once; it is compiled again from `prompt.json` on every `validate` and `run`, so an edit re-keys exactly the renders it touches. The brand's **typeface** is shown to the model as a `font_specimen` set on the `designed` lines: a file in `src/brand/fonts/` (via `src/brand/tokens.json` when present), else the heading family `tokens.json` or `BRAND.md` names, fetched as a web font file; an `in_scene` line keeps its own lettering only on the real packaging, signage or screen its `on` names (handwriting on post-its, whiteboards or chalkboards, and a line naming no surface, are set as designed type). Each line's `role` sets its size: a price or stat (else the headline) leads, the `cta` is a large solid button, fine print is smallest. **The logo is optional**: when `prompt.json` has `"logo": true` (an older blueprint: an `advertiser_brand` entry in `brands_logos`) and the real file is in `src/brand/logos/`, that file is placed on every size pixel for pixel, never drawn by a model (`static_logo`, below): every render is told to draw no logo and keep its slot plain, the slot planned inside the size's safe area at the concept's `logo_position` (top-left when it names none). A creative scaffolded while the model drew the logo is moved onto the file on its next run (`[logo]` note). A file that does not open as a picture is handed to the model to draw from instead, and the run says so; no logo is never an error, never a slot to fill and never a stand-in. Setting it false drops the logo on the next run; adding one to a canvas scaffolded without the file needs the file in `src/brand/logos/` and a re-scaffold. `prompt.json` also carries a **`brand`** block (ground, ink, accent, CTA and palette, from `src/brand/tokens.json` roles or `BRAND.md`); a colour outside it never reaches the model. The brief describes a complete ad at the master's shape and asks only for its edge margin (see below). `baker canvas set-prompt` refuses these nodes and names `prompt.json`.
 - A **`static_prefilter`** node (tagged `variant_prefilter`) drops variants that fail the deterministic checks before the judge sees them, never all of them; its **judge** (`judge_model`, `judge_prompt`) compares the rest pairwise against the compiled brief when the checks tie (one variant passes through unjudged). A canvas scaffolded with a separate `image_select` judge (tagged `pick`) has it folded into the prefilter on its next run.
-- **Every placement format is made from the chosen picture, and no size is a crop or a paste of another.** The pick goes to exact pixels as the master (an `imagemagick` node tagged `static_master`) at the lead size: the 4:5 when a feed size is delivered, else the square, else the first portrait size, rendered at the model's nearest ratio (3:4 on GPT Image) and filled to Meta's pixels. It is delivered as it is. Every other size (9:16, 1:1, 16:9, …) is **re-laid out** from the master by one request (`image_generate` node `adapt_<size>`, tagged `static_adapt_format`, on the router's `relayout` model, GPT Image 2.5 at quality `xhigh`): the master, the variants' own product and people pictures and the logo file as references and a brief compiled from `prompt.json` for that frame on every run (`static-adapt.ts`): the exact lines and their hierarchy, the same people (same face, same clothes), product and label, logo and none the chosen ad does not show, the words and the button re-scaled for the frame, the frame stated as zones inside its safe area, never the master shrunk onto a background, set as a square or cut. A `size_<size>` node (`static_size`) brings it to Meta's exact pixels (1:1 at 1080×1080; a landscape size the same way). Every 9:16 Reels or Stories covers then passes a free `static_safe_fit` node (`safe_<size>`), which shrinks and shifts the picture just enough (to 85% at most) to bring a word or the logo a few points past the band back inside it; a layout further out passes unchanged and the run lays it out again. The 9:16 is never extended instead (the 4:5 set whole in the clear band, its scene continued to the frame) nor set over its own blurred copy: rated in October 2026, the first showed the ad small inside a continued scene ("text super tiny") and the second "looks bad". The master shape is one decision in the code (`DEFAULT_MASTER_SHAPE`: `relayout`; the `9x16_band` and `4x5_adapt` shapes, kept for the bench, make the sizes by cutting or reframing the master, and the person rating them rejected every such way; a canvas from the retired band master, which extended a square master into the 9:16, is upgraded to the re-layout graph on its next run). Placing the logo file on every size instead of having the model draw it (`logo_composite` nodes) is a scaffold option, off until it is proven on the bench.
+- **Every placement format is made from the chosen picture, and no size is a crop or a paste of another.** On an ad laid out again for each size (a designed or interface ad, or `--master-shape relayout`), the pick goes to exact pixels as the master (an `imagemagick` node tagged `static_master`) at the lead size: the 4:5 when a feed size is delivered, else the square, else the first portrait size, rendered at the model's nearest ratio (3:4 on GPT Image) and filled to Meta's pixels. It is delivered as it is. Every other size (9:16, 1:1, 16:9, …) is **re-laid out** from the master by one request (`image_generate` node `adapt_<size>`, tagged `static_adapt_format`, on the router's `relayout` model, GPT Image 2.5 at quality `xhigh`): the master, the variants' own product and people pictures and the logo file as references and a brief compiled from `prompt.json` for that frame on every run (`static-adapt.ts`): the exact lines and their hierarchy, the same people (same face, same clothes), product and label, logo and none the chosen ad does not show, the words and the button re-scaled for the frame, the frame stated as zones inside its safe area, never the master shrunk onto a background, set as a square or cut. A `size_<size>` node (`static_size`) brings it to Meta's exact pixels (1:1 at 1080×1080; a landscape size the same way). Every 9:16 Reels or Stories covers then passes a free `static_safe_fit` node (`safe_<size>`), which shrinks and shifts the picture just enough (to 85% at most) to bring a word or the logo a few points past the band back inside it; a layout further out passes unchanged and the run lays it out again. The 9:16 is never extended instead (the 4:5 set whole in the clear band, its scene continued to the frame) nor set over its own blurred copy: rated in October 2026, the first showed the ad small inside a continued scene ("text super tiny") and the second "looks bad". The master shape is one decision in the code (`DEFAULT_MASTER_SHAPE`: `relayout`; the `9x16_band` and `4x5_adapt` shapes, kept for the bench, make the sizes by cutting or reframing the master, and the person rating them rejected every such way; a canvas from the retired band master, which extended a square master into the 9:16, is upgraded to the re-layout graph on its next run). Every size then gets the brand's logo file placed on it last (`logo_<size>`, a `static_logo` tagged `logo_composite`); on one picture, in the slot that size's words left empty (`format_<size>`'s `logo_slot`).
+- **One picture, every size (the default for a photo-led ad, ADR 0014).** A designed or interface ad (one keeping the whole or the layout of a proven chat, screenshot, table, grid or text-card ad, or lettering words in chat bubbles or on a screen) is laid out again for each size instead; the canvas records why (`metadata.master_shape_reason`) and the scaffold and `baker creatives make` print it (`master_shape`). The first `baker canvas run` of a creative never rendered routes it once more on the prompt.json written since (`[shape]` note), since make routed it on the proven ad's drafted words. Each variant is a picture drawn without the ad's designed words (`plate_<i>`, `static_variant_call`, at the widest ratio the model draws that every tall size can be cut from: 9:16 for Meta's 4:5 and 9:16), its brief stating where the people and products stay and where the words go, the scene's own words (a chat on a phone, a label) kept. Each picture gets its lead size's words (`lead_<i>`, a `static_format` tagged `static_lead`), so the options shown are finished ads; the prefilter chooses among them and passes on the chosen one's picture (`plate`), dropping a variant whose picture cannot give every size without cutting a face or the product before any words are paid for. Every size, the lead included (`format_<size>`, `static_format`), is then cut from that picture with its words set in the lead's look; the lead's replays its option's paid words, free. A size's words call is told each line's `look` whole at every trim level (a tag, a pill, the ✗ or ✓ beside it), and the marks a look names are no stray icon, so a before/after's ✗/✓ proof is set with its lines. A wide size beside tall ones is cut from the chosen picture extended sideways (`plate_wide`, `static_plate`). A change of the words or colours in `prompt.json` keeps the pictures and the choice and sets only the words again; `--fix` corrects the picture itself (`edit_<n>`) and every size's words are set on it again; `--regenerate format_<size>` sets one size's words again on the same picture; a run correcting itself sets a size's words again for a misread line or words under the interface, and corrects the picture only for a defect of the picture. An ad of a series led by an ad on one picture draws no picture: every size is cut from the lead's picture with its own words. An existing creative stays on the shape it was made on through every run, fix, edit, ad of its series and translation. Scaffolded again with `--master-shape plate`, an approved creative made before plates moves onto one picture: its approved size is kept byte for byte, every other size cut from its picture with the words painted out (`static_plate` `from_ad`), refused when more than a quarter of its frame would be painted. `baker canvas validate` refuses a size's words set on a finished ad (`STATIC_FORMAT_PLATE_SOURCE`) and a canvas mixing these sizes with the re-layout, safe-fit or placing steps (`STATIC_MIXED_SIZE_PIPELINE`).
 - Readers go by these roles, never by node ids: the run review, `--fix`, `--use-variant`, `--regenerate static_variants`, and the dashboard. A static ad scaffolded before this graph (`ad_a`/`ad_b`/`ad_c`, `pick`, re-lays `ad_4x5`/`ad_9x16`, `fit_4x5`) is **upgraded in place** on its next `validate` or `run`: prompt.json, every asset slot, the model and the formats are kept, the render part becomes this graph, and the creative is not reported as changed by the upgrade. Its old runs stay readable.
 - Detected elements are **never slots to fill**: the source's people, products, animals and badges are its world. The original image stays on the canvas as the record of the source; when `prompt.json` keeps its concept (`concept.verdict` `use` or `adapt`) the first renders are shown it **for its structure only**, and otherwise it never reaches a render. Only the people cast from a company Avatar and the brand's logo become pictures on the canvas; everything else is described in words (a picture of ours is added through a reference's `image`). A **person** with no avatar needs no slot and no casting: the render draws an invented, realistic person from the element's description. With `--avatar <handle>` (for an actor who recurs across ads) the slot ingests the Avatar's identity sheet and `prompt.json` describes that person in the Avatar's own words. A reference's `avatar` names who was cast and draws no face on its own: its face reaches the render only with a picture behind it (the `--avatar` slot, or the identity sheet URL from `baker avatars get <handle>` as the reference's `image`).
 
@@ -6276,7 +6304,7 @@ The canvas is validated before it is written. stdout returns `{ ok, canvas_path,
 
 **Who sees the ad.** `--target-adset <id>` names the Meta ad set the ad will run in. Before anything is billed, the viewer its targeting reaches is read exactly as `baker ads meta adsets --audience` reads it (`temperature`, what they already `knows`, `placements`) and written to `_definition.md` as `targetAdSet` and `viewer` (an existing definition keeps every other field). The sizes, the brief and the prefilter keep clear of that viewer's placements (`staticSafeArea`; `automatic`, a bare `facebook`/`instagram` or no placements is Advantage+, Reels included), and every `baker canvas run` checks the ad against that viewer. With no ad account, give the viewer from the Knowledge: `--viewer-temperature cold|warm|hot [--viewer-knows brand,offer,product] [--viewer-placements <placement,…>]`, recorded with `source: knowledge`; next to `--target-adset` they correct the read, and its `reasons` say so. A bad value exits 2 (`invalid_viewer`) before any billed pass; an ad set that cannot be read never stops the scaffold (a hint says why, and the sizes keep clear of every placement). With neither flag, a `viewer` (or `targetAdSet`) already in `_definition.md` is used as it is. stdout carries `target_adset`, `viewer` and a `checklist.viewer` line.
 
-**After a run** the CLI reads the finished ad back on what makes a static win, not a checklist of elements: every delivered image's pixel shape against its format; **every line of `prompt.json`'s copy (in-scene and designed alike) read back with its box by a box reader and compared** (a line more than 2% off, missing, or joined by words nobody asked for is blocking; case and punctuation fold, as does a capital I read as an l (one stroke in a sans-serif), accents do not; words the picture adds are blocking only when set at the copy's usual size or making a claim (a figure, a price, an offer), and otherwise a note, as a screen's code, a poster or a mug in the scene, except a price (a currency sign beside a figure) the copy does not hold, blocking at any size and blurred by the correction, the document it is on kept; every render is asked for no readable prices on a bill, quote, receipt, screen or price tag beyond the copy; a copy line is "on the ad twice" only when most of its words repeat, never a word or two echoed on a prop; on a native screen, which code typesets from the spec, a line read differently is the reader's error and only a missing one counts); **the ad's own copy and its logo measured against the format's safe area** (`staticSafeArea`, the one owner of those areas; `must-show.ts` decides what is measured: never what the scene prints, nor a copy line printed again in the scene while the line itself sits clear). On a 9:16, which runs in Stories and Reels alike, what Stories' header or bottom bar covers (and any other app's interface named) is said as "where Stories and Reels cover it" ("where Reels covers it" for an ad set that runs only in Reels) and blocks for the logo, the button, the headline, the figure and the offer, while a supporting line (body, caption, label, small print) there is a note; what only Reels' taller footer covers is one note, and only for the lead line, since Stories shows it and the 9:16 is laid out in Stories' band; words merely close to where an app draws are no finding. The steps that place a size clear of an interface (`static_safe_fit`, `static_place`) are told the same copy (`prompt.json`'s lines, their roles, and the brand's name and the logo's words, a wordmark read close to them counting as the logo) and move the ad for those alone, a supporting line included only where the frame cuts it; on a feed image such as a 4:5, only a design margin, so words close to the edge are a warning and only words the frame cuts are blocking); a copy line written over two lines (`"15%\noff"`) is matched part by part wherever the reader finds each; designed type in a colour far from the brand palette is a warning; supporting lines too small to read on a phone are one note per size; the main line set smaller than a supporting one is a note, the brand's wordmark never counted as part of a line that starts with its name; the logo set twice is a note, a far smaller mark printed on something in the scene (a hoodie, a bag) is not. When the copy names a real person ("Lautaro Suarez, CTO at Vibiz", "田中 美咲、Acme 創業者"; read by a text model in any language, cached by copy, `scripts/named-people-evals`), the run casts them as themselves before it renders (`baker avatars research --create`, their avatar's sheet added to `prompt.json` `references` as a `PERSON_n`), and a face shown as a named person the ad has no photo of is blocking. When the reader cannot answer, the vision pass transcribes the copy instead and judges the safe zones by eye. Then one vision pass for clipping, overlaps, artifacts, one dominant idea, the brand with the logo covered and the concept's mechanisms (each finding typed by the model with the item it answers, what it is about, what is wrong and the edges that cut it, which the grading and the automatic correction read instead of its words), with every format shown a second time at phone-feed thumbnail size (240px wide, same call): a lead message unreadable at that size is blocking. A missing logo, CTA or copy is never a finding; a logo that is drawn and broken is. stdout carries `verdict` (`ready` | `ready_with_notes` | `needs_fixes` | `not_reviewed`), `judge` (the per-candidate scores) and hints that end with what the run made; the findings are stored on the run as its `review`. `needs_fixes` means the ad is not done even though every node completed, and the run is recorded with `presentable: false` so it is never shown as a version; every fix is an edit to `prompt.json` and a re-run (wrong words: the lines in `copy`; wrong picture: the `scene`; a bad roll: `--regenerate static_variants`; one size wrong while the chosen picture is right: `--regenerate adapt_<size>`, which re-lays it out, named in the hints); a blocking defect is first corrected by the run itself (`--autofix`, above). The checks rank the variants before the pick and the judge only breaks an exact tie, comparing pairwise against the compiled brief, knowing the brand and the viewer; every variant stays on offer to the person in Baker. Within one chat turn an ad gets two runs you start (each with its automatic corrections) and about 12 minutes in all: a correction round that would take it past that is not started (`[autofix] not started`), the version shown as it stands, and no render starts once it is spent; once the ad is `ready` or `ready_with_notes` only a correction of it starts (`--fix`, `--regenerate adapt_<size>`, or an edit of its words or colours), within the same two runs, and anything else is refused (`CONFLICT`, exit 2) with what to show instead; the person's next message starts a new turn (`turn-renders.ts`). When a defect still stands after the automatic rounds, the hints say to fix it with a `--fix`, then by changing the spec or the approach, and if it still cannot be fixed to show the best version and name what is left in one plain sentence, without a question.
+**After a run** the CLI reads the finished ad back on what makes a static win, not a checklist of elements: every delivered image's pixel shape against its format; **every line of `prompt.json`'s copy (in-scene and designed alike) read back with its box by a box reader and compared** (a line more than 2% off, missing, or joined by words nobody asked for is blocking; case and punctuation fold, as does a capital I read as an l (one stroke in a sans-serif), accents do not; words the picture adds are blocking only when set at the copy's usual size or making a claim (a figure, a price, an offer), and otherwise a note, as a screen's code, a poster or a mug in the scene, except a price (a currency sign beside a figure) the copy does not hold, blocking at any size and blurred by the correction, the document it is on kept; every render is asked for no readable prices on a bill, quote, receipt, screen or price tag beyond the copy; a copy line is "on the ad twice" only when most of its words repeat, never a word or two echoed on a prop; on a native screen, which code typesets from the spec, a line read differently is the reader's error and only a missing one counts); **the ad's own copy and its logo measured against the format's safe area** (`staticSafeArea`, the one owner of those areas; `must-show.ts` decides what is measured: never what the scene prints, nor a copy line printed again in the scene while the line itself sits clear). On a 9:16, which runs in Stories and Reels alike (Advantage+, or both named), what either covers (Stories' header and reply bar, Reels' caption and the buttons down its right side, `blockingArea`, from `AD_PLACEMENTS`; and any other app's interface named) blocks for the logo, the button, the headline, the figure and the offer, said as "where Stories and Reels cover it", or "where Reels' caption and buttons cover it" for what Stories shows ("where Reels covers it" for an ad set that runs only in Reels), while a supporting line (body, caption, label, small print) there is a note; words merely close to where an app draws are no finding. The plate's words zone, the words and re-layout briefs, the code move of the words (up to a quarter of the frame) and the safe fit keep to the same band. The steps that place a size clear of an interface (`static_safe_fit`, `static_place`) are told the same copy (`prompt.json`'s lines, their roles, and the brand's name and the logo's words, a wordmark read close to them counting as the logo) and move the ad for those alone, a supporting line included only where the frame cuts it; on a feed image such as a 4:5, only a design margin, so words close to the edge are a warning and only words the frame cuts are blocking); a copy line written over two lines (`"15%\noff"`) is matched part by part wherever the reader finds each; designed type in a colour far from the brand palette is a warning; supporting lines too small to read on a phone are one note per size; the main line set smaller than a supporting one is a note, the brand's wordmark never counted as part of a line that starts with its name; the logo set twice is a note, a far smaller mark printed on something in the scene (a hoodie, a bag) is not. When the copy names a real person ("Lautaro Suarez, CTO at Vibiz", "田中 美咲、Acme 創業者"; read by a text model in any language, cached by copy, `scripts/named-people-evals`), the run casts them as themselves before it renders (`baker avatars research --create`, their avatar's sheet added to `prompt.json` `references` as a `PERSON_n`), and a face shown as a named person the ad has no photo of is blocking. An ad that casts nobody (no person picture, and its scene names nobody or rules people out) blocks any person drawn in it, a tiny round avatar in an interface aside; a brief trimmed to fit its word budget says again what its scene ruled out ("no people, no phone"). A correction of the spec never puts a person in an ad that casts nobody. When the reader cannot answer, the vision pass transcribes the copy instead and judges the safe zones by eye. Then one vision pass for clipping, overlaps, artifacts, one dominant idea, the brand with the logo covered and the concept's mechanisms; an ad built on a proven ad is checked against that ad's picture for each element it must keep, and what stops the scroll and the proof (`job: stop | proof`) are asked one by one for every size (`keeps`): a size that lost either is blocking whatever the model graded its words, typed with the job it did, and no second look lifts it (`vitalFindings`) (each finding typed by the model with the item it answers, what it is about, what is wrong and the edges that cut it, which the grading and the automatic correction read instead of its words), with every format shown a second time at phone-feed thumbnail size (240px wide, same call): a lead message unreadable at that size is blocking. **Every size a model drew apart from the lead** (each `adapt_<size>`, or a size cut from a picture painted wider) **is compared with it**: people, faces and animals counted on two reads of the subject boxes, and a side-by-side vision comparison (catalog role `sizeMatch`) for the same product and people, nothing shown twice, never the lead boxed inside a bigger frame; a difference is one blocking `<size>: …` finding (item `sizes`) that the automatic correction answers by making that size again (painting `plate_wide` again when the size is cut from it), and a size that could not be compared is named in the hints. A size cut from the chosen picture (`format_<size>`) is consistent by construction and is not compared. A missing logo, CTA or copy is never a finding; a logo that is drawn and broken is. **The delivered logo is held to the brand's file on the pixels**: where it was placed from the file, the size at the composite's box must show the file's own pixels (98% of them), and the composite's own check must find the logo and the headline wholly inside the frame and its safe area with no line of the copy under the logo; where a model drew it, the logo is found by its shape among the file's colourways and blocked when the frame cuts it or it is not the file as it is (Red Points' "POIПTS" drawn as "POINTS"). Each is a blocking `<size>: …` finding the automatic correction answers by setting that size's words again. stdout carries `verdict` (`ready` | `ready_with_notes` | `needs_fixes` | `not_reviewed`), `judge` (the per-candidate scores) and hints that end with what the run made; the findings are stored on the run as its `review`. `needs_fixes` means the ad is not done even though every node completed, and the run is recorded with `presentable: false` so it is never shown as a version; every fix is an edit to `prompt.json` and a re-run (wrong words: the lines in `copy`; wrong picture: the `scene`; a bad roll: `--regenerate static_variants`; one size wrong while the chosen picture is right: `--regenerate format_<size>`, which sets its words again, or `adapt_<size>` on an ad laid out again for each size, named in the hints); a blocking defect is first corrected by the run itself (`--autofix`, above). The checks rank the variants before the pick and the judge only breaks an exact tie, comparing pairwise against the compiled brief, knowing the brand and the viewer; every variant stays on offer to the person in Baker. Within one chat turn an ad gets two runs you start (each with its automatic corrections) and about 12 minutes in all: a correction round that would take it past that is not started (`[autofix] not started`), the version shown as it stands, and no render starts once it is spent; once the ad is `ready` or `ready_with_notes` only a correction of it starts (`--fix`, one size's `--regenerate format_<size>` or `adapt_<size>`, or an edit of its words or colours), within the same two runs, and anything else is refused (`CONFLICT`, exit 2) with what to show instead; the person's next message starts a new turn (`turn-renders.ts`). When a defect still stands after the automatic rounds, the hints say to fix it with a `--fix`, then by changing the spec or the approach, and if it still cannot be fixed to show the best version and name what is left in one plain sentence, without a question.
 
 The render prompt is **model-aware**: each model's profile (`src/engine/lib/prompt-profiles.ts`) sets its shape, word budget, picture order and request params. gpt-image gets short labelled sections with the constraints last; Gemini gets sentences that give the reason and a positive closing list of the only words allowed. A profile change, or a new model on the router (`src/engine/lib/image-model-router.ts`), is re-run on the static bench (`scripts/creative-evals`, `--job static`) before it ships. Run `baker canvas critique` on the scaffolded canvas for an advisory read before you spend.
 
@@ -6312,7 +6340,7 @@ baker canvas run ./static-ad.canvas.json
 
 Scaffolding runs (and bills) the two vision passes; **running** the result generates billed images. `baker canvas validate` does not check that the `[TODO]` paths exist — supply the real files before `run`.
 
-Size adaptations move and proportionally scale the existing composition first, keeping its background treatment, including intentional flat colour. Generation, adaptation, correction and series briefs preserve plausible anatomy, device proportions, scale, perspective and support, and reflow text while preserving letter shapes. Recognizable app controls remain native; marketing overlays stay visibly separate. Shared guidance records applicable intent and constraints briefly in `_definition.md`, then carries them into `prompt.json` (Markdown is not a render input). Direct briefs need no invented winner or fixed template; reference adaptations reason through the mechanism, transfer hypothesis and what must survive. `creatives make` returns this preparation hint before rendering. Choose the represented role and inspect existing Avatars before creating a new actor; a real founder or customer keeps their verified identity.
+Size adaptations move and proportionally scale the existing composition first, keeping its background treatment, including intentional flat colour. Generation, adaptation, correction and series briefs preserve plausible anatomy, device proportions, scale, perspective and support, and reflow text while preserving letter shapes. Recognizable app controls remain native; marketing overlays stay visibly separate. Shared guidance thinks the ad through in `_definition.md` first (the `## Thinking` outline `creatives make` writes), then writes `prompt.json` from its plan (Markdown is not a render input). `creatives make` returns this think-first hint before the one that writes the ad. Choose the represented role and inspect existing Avatars before creating a new actor; a real founder or customer keeps their verified identity.
 
 During continuations, the accepted image's screen content takes priority over geometry references unless explicitly changed. Laptop scenes receive guidance for a real laptop and consistent display, keyboard and hinge perspective.
 
@@ -6327,7 +6355,7 @@ baker canvas run --slug spring-offer --force-remote --regenerate gen
 
 #### `baker canvas stale`
 
-Lists the creatives edited since their last render in this workspace, each with the command to re-render it: `{ ok, data: { stale: [{ slug, canvasPath, renderedRunId, sourceSha }] }, hints? }`. "Edited" is one content fingerprint of what the models would be sent: the canvas as it renders (after the copy, logo and scene projections), `prompt.json` without its bookkeeping (`reference`, `source_context`, `notes`), every `scenes/sNN.json`, every local composition directory the canvas renders, and the `formats` in `_definition.md`, so a change counts however it was made and reformatting a JSON file is not a change. The fingerprint is prefixed `v2:`; a render fingerprinted by the older rule (a bare sha) is never reported stale, so upgrading the CLI re-renders nothing. A completed `run` records the fingerprint it drew in `canvas/.rendered/<slug>.json`, and a render attempt of the current source is not asked for again until the source moves. Creatives never rendered in this workspace, and ones with an unfilled `[TODO]` asset slot, are not listed. Read-only, offline, free. The scaffold's turn-end reminder and its `validate-creative-renders` check read this list (at Publish it is a warning: Publish ships the last version the person was shown and never renders); the same fingerprint is what `sync-definition` and `run` post as `sourceSha`.
+Lists the creatives edited since their last render in this workspace, each with the command to re-render it: `{ ok, data: { stale: [{ slug, canvasPath, renderedRunId, sourceSha }] }, hints? }`. "Edited" is one content fingerprint of what the models would be sent: the canvas as it renders (after the copy, logo and scene projections), `prompt.json` without its bookkeeping (`reference`, `source_context`, `notes`), every `scenes/sNN.json`, every local composition directory the canvas renders, and the `formats` in `_definition.md`, so a change counts however it was made and reformatting a JSON file is not a change. The fingerprint is prefixed `v3:`; a render fingerprinted by an older rule (a bare sha, or `v2:`) is never reported stale, so upgrading the CLI re-renders nothing (a creative edited before the upgrade is not listed until it is rendered again). A completed `run` records the fingerprint it drew in `canvas/.rendered/<slug>.json`, and a render attempt of the current source is not asked for again until the source moves. Creatives never rendered in this workspace, and ones with an unfilled `[TODO]` asset slot, are not listed. Read-only, offline, free. The scaffold's turn-end reminder and its `validate-creative-renders` check read this list (at Publish it is a warning: Publish ships the last version the person was shown and never renders); the same fingerprint is what `sync-definition` and `run` post as `sourceSha`.
 
 #### `baker canvas inspect <run_id> [--thumbnails]`
 
@@ -6810,8 +6838,8 @@ import {
 Save a finished canvas render as a Baker creative: a static image (PNG, JPG, WebP) or a finished video (MP4, MOV, WebM). Choose and save the best finished version without waiting for the user to choose, including in the turn that rendered it. Saving pins the version as the agent's choice without recording user approval or putting an ad live. An image uploads to the Baker image library (tagged `creative`); a video uploads to the Baker video library and is saved once it plays (bounded at 3 minutes). A creative record is created/updated, and the command prints the creative reference JSON the dashboard renders in chat.
 
 ```bash
-baker creatives publish --title "Spring Offer 4x5" \
-  --slug spring-offer-4x5 --run-id r_01JXYZ... --output 4:5 \
+baker creatives publish --title "Spring Offer" \
+  --slug spring-offer --run-id r_01JXYZ... \
   --source-reference-url "https://www.facebook.com/ads/library/?id=..."
 # or from a local file
 baker creatives publish ./canvas/<run_id>/<final>.png --title "Spring Offer 4x5" --slug spring-offer-4x5 --run-id r_01JXYZ...
@@ -6826,11 +6854,11 @@ baker creatives publish ./canvas/<run_id>/final.mp4 --title "Spring Offer Reel"
 | `--title <text>` | Required. Human title for the creative. |
 | `--slug <slug>` | Creative slug (`src/creatives/<slug>/`): attaches the image or video to that creative's row, marks it `published`. Required for a video. With `--run-id` an image publish also sets `status: published` in the creative's `_definition.md` (`definitionStatus` in the output). |
 | `--run-id <r_…>` | Pins the finished generation from the creative's run history as the saved one. |
-| `--output <label\|slot\|n>` | With `--run-id` and no file: which of the run's images to save when it made several (a label such as `4:5`, a slot, or a 1-based number). |
+| `--output <label\|slot\|n>` | With `--run-id` and no file: which of the run's sizes is the creative's cover (a label such as `9:16`, a slot, or a 1-based number). Every size is saved either way; the default cover is the lead. |
 | `--source-reference-url <url>` | Original reference ad URL, recorded on the creative. |
 | `--context <text>` | Optional describe context for the uploaded image or video. |
 
-An image prints `{ ok, data: { creativeId, imageId, reference } }`. A video prints `{ ok, data: { creativeId, videoId, reference }, hints }`, where `reference.asset.kind` is `video` (with `videoId`, `muxPlaybackId`, the poster as `thumbnailUrl`, size and duration) and `hints` names the next step to put it in a Meta ad: `baker ads meta media upload --kind video --video-id <videoId>`.
+With `--run-id` and no file, every size the run made is uploaded, sha-verified, as one library set (`creative_sizes`, keyed `creative:<slug>:<runId>`, the lead first), and an image prints `{ ok, data: { creativeId, imageId, reference, sizes? }, hints? }`: `sizes` is `[{ format, imageId }]` when there were several, and the hint says which size goes to which placement (Meta: 4:5 for Feed, 9:16 for Stories and Reels; LinkedIn: the 1:1). A video prints `{ ok, data: { creativeId, videoId, reference }, hints }`, where `reference.asset.kind` is `video` (with `videoId`, `muxPlaybackId`, the poster as `thumbnailUrl`, size and duration) and `hints` names the next step to put it in a Meta ad: `baker ads meta media upload --kind video --video-id <videoId>`.
 
 Without `--slug` an image 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.
 

package/dist/account-7LUQWY6Q.js

@@ -0,0 +1,49 @@
+import {
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-OP7DNHD2.js";
+import {
+  writeAdsJson
+} from "./chunk-SWL4AAPP.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-K3TNTBZJ.js";
+import {
+  apiGet
+} from "./chunk-XDZVBX6L.js";
+import "./chunk-N5O67GK5.js";
+import "./chunk-EE72SSB2.js";
+import "./chunk-WNSE7N75.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/account.ts
+import { defineCommand } from "citty";
+var accountCommand = defineCommand({
+  meta: {
+    name: "account",
+    description: `Show single Meta ad account detail (currency, timezone, balance, business).
+
+Examples:
+  baker ads meta account --account-id act_123
+  BAKER_META_AD_ACCOUNT_ID=act_123 baker ads meta account`
+  },
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID (act_...)" },
+    "no-cache": NO_CACHE_ARG
+  },
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/meta/account", params);
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+export {
+  accountCommand
+};
+//# sourceMappingURL=account-7LUQWY6Q.js.map

package/dist/account-VH2AATWI.js

@@ -0,0 +1,79 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-RLS5OPPZ.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-SWL4AAPP.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-K3TNTBZJ.js";
+import "./chunk-FRK7SSEH.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiGet
+} from "./chunk-XDZVBX6L.js";
+import "./chunk-N5O67GK5.js";
+import "./chunk-EE72SSB2.js";
+import "./chunk-WNSE7N75.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/account.ts
+import { defineCommand } from "citty";
+var accountDetailCommand = defineCommand({
+  meta: {
+    name: "detail",
+    description: `Single LinkedIn ad account detail (currency, status, type).
+
+Examples:
+  baker ads linkedin account --account-id 503001492
+  baker ads linkedin account --account-urn urn:li:sponsoredAccount:503001492 --output md`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+    "account-urn": { type: "string", description: "Alias for --account-id" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/account", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput([data], fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var accountCommand = defineCommand({
+  meta: {
+    name: "account",
+    description: `LinkedIn ad account: its detail, and the settings that apply across every ad set in it.
+
+Examples:
+  baker ads linkedin account --account-id 503001492                          \u2014 currency, status, type
+  baker ads linkedin account url-params --param utm_source=linkedin          \u2014 UTMs for every ad in the account`
+  },
+  subCommands: {
+    detail: accountDetailCommand,
+    "url-params": () => import("./write-commands-E7JOB4HX.js").then((m) => m.accountUrlParamsCommand)
+  },
+  args: accountDetailCommand.args,
+  default: "detail"
+});
+export {
+  accountCommand
+};
+//# sourceMappingURL=account-VH2AATWI.js.map

package/dist/account-Z65CPOWE.js

@@ -0,0 +1,80 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptRead
+} from "./chunk-IG627WWY.js";
+import "./chunk-SWL4AAPP.js";
+import {
+  apiGet
+} from "./chunk-XDZVBX6L.js";
+import "./chunk-N5O67GK5.js";
+import "./chunk-EE72SSB2.js";
+import {
+  registerSchema
+} from "./chunk-WNSE7N75.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/account.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.chatgpt.account",
+  description: "The connected ChatGPT Ads account: name, currency, timezone, status, and the brand and account reviews that decide whether anything in it can serve.",
+  args: {
+    full: { type: "boolean", description: "Return ChatGPT Ads' own account object", required: false }
+  }
+});
+function accountHints(account) {
+  const hints = [];
+  if (account.brandReview.status !== "approved") {
+    const reason = account.brandReview.reason ? ` (${account.brandReview.reason})` : "";
+    hints.push(
+      `Brand review is ${account.brandReview.status}${reason}: nothing in this account serves until it is approved. Fix it in ChatGPT Ads Manager before changing campaigns.`
+    );
+  }
+  if (account.accountReview && account.accountReview.status !== "approved") {
+    hints.push(`A separate account review is ${account.accountReview.status}; delivery can wait on it too.`);
+  }
+  if (account.status === "paused") {
+    hints.push("The whole account is paused, so no campaign in it serves whatever its own status says.");
+  }
+  return hints;
+}
+var SHOW_ARGS = {
+  full: { type: "boolean", description: "Return ChatGPT Ads' own account object", required: false }
+};
+var accountShowCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "The connected ChatGPT Ads account. Example: baker ads chatgpt account"
+  },
+  args: SHOW_ARGS,
+  run: async ({ args }) => {
+    await runChatgptRead(
+      CHATGPT_ADS_REFERENCE.account,
+      () => apiGet("/api/ads/chatgpt/account", args.full ? { full: "true" } : void 0),
+      (account) => args.full ? [] : accountHints(account)
+    );
+  }
+});
+var accountCommand = defineCommand({
+  meta: {
+    name: "account",
+    description: `The connected ChatGPT Ads account. Start here: currency and timezone for every figure, and whether reviews let anything serve.
+
+Examples:
+  baker ads chatgpt account
+  baker ads chatgpt account --full
+  baker ads chatgpt account update --favicon-url https://example.com/icon.png   \u2014 staged; applies on publish`
+  },
+  subCommands: {
+    show: accountShowCommand,
+    update: () => import("./account-writes-4N2MA2ZR.js").then((m) => m.accountUpdateCommand)
+  },
+  // A parent must never declare `run`: citty falls through to it after the matched subcommand.
+  args: SHOW_ARGS,
+  default: "show"
+});
+export {
+  accountCommand,
+  accountHints
+};
+//# sourceMappingURL=account-Z65CPOWE.js.map