@koda-sl/baker-cli 0.481.0-dev.2d33e194f → 0.482.0-dev.a5555ab55

package/README.md

@@ -128,6 +128,19 @@ envelope to narrow; without it a note on stderr says the flag changed nothing. A
 that prints its result beside `ok` rather than under `data` (`canvas validate`,
 `canvas critique`) comes back whole, with a hint saying `--fields` was not applied.
 
+### Reading another company: `--company <id>`
+
+Only an organization's workspace (where its Reports across every company are built) may name a company. Any read takes `--company <id>` and runs as that company of the same organization; a write, stage or generate naming a company is refused, and so is any credential of an ordinary company. The ids come from:
+
+```bash
+baker organization companies     # every company: id, name, domain, timezone, suspended, connected platforms
+baker organization pull          # what each company made, as published, into ~/companies/<company>/ (read-only) + INDEX.md
+```
+
+`baker organization pull [--company <id>] [--dir <path>] [--force]` downloads each company's knowledge, landing pages, Forms, brand, documents, custom agents and checks and Reports, as published, one read-only folder per company, and writes `INDEX.md`. A second run only fetches companies that published since, and removes the folder of a company that left the organization or was renamed.
+
+On the organization workspace's Runtime (`BAKER_WORKSPACE_KIND=organization`) the CLI offers only reads, plus research and judgment run as the workspace itself (not `research customers` or `winning-ads fit`, which work on one company's own workspace); any other command is left out of `--help` and `baker schema` and refused before it is sent. So are the flags that change something on a command it reads (`funnel --add-trigger`, `analytics sources --create`, …), and help never names a command or flag it may not use, nor offers the staging of a family it only reads. Everywhere else the `organization` family is left out of help, and so is any mention of it.
+
 ### Fresh reads: `--no-cache`
 
 Every command that caches takes `--no-cache`, and it skips **both** cache layers — the
@@ -163,79 +176,6 @@ Multi-platform ad commands. Google, Meta, and LinkedIn support both reads and **
 
 ---
 
-### `baker ads performance`
-
-Every connected ad platform's numbers from Baker's stored copy (refreshed every few hours, full history), without calling the platforms. Read-only. Results are the company's chosen conversion goals, else each platform's headline conversions; money is shown in the company's reporting currency at the period's average ECB rate (`--currency <ISO>` for another, `--currency native` for each ad account's own), and comparisons use only days whose conversions have settled.
-
-It is the first read for any ads report, analysis or alert: no rate limit and the whole history, a few hours behind (`status` says how fresh). The live `baker ads <platform>` reads are for today's numbers and what this lacks, and their answers name the synced command that covers the same question.
-
-```bash
-baker ads performance overview --days 30          # spend, results, cost per result per platform, vs the period before
-baker ads performance setup                       # is everything set up: one headline and what to fix, in order
-baker ads performance accounts --days 30          # each ad account against its own target, with its weeks
-baker ads performance attention                   # the few things that matter most now: fix now, worth a look, opportunities
-baker ads performance attention claim <id>        # this chat works on it (at once; lapses when the chat ends)
-baker ads performance attention fixed <id> --note "Cut the budget 20%"   # staged: at Publish it shows "Fixed, checking it worked"
-baker ads performance attention dismiss <id> --wrong --reason "Paused on purpose"   # staged; without --wrong it is "not now"
-baker ads performance entities --level ad --sort cost_per_result
-baker ads performance entities --platforms google --compare   # each row against the settled days before; what stopped, and who stopped it
-baker ads performance entity <id> --platform meta --level ad_group   # one entity + verdict before changing it
-baker ads performance changes --days 14
-baker ads performance impact --actor-kinds baker
-baker ads performance creatives   # each row also names the Baker creative (and version) it is: madeInBaker
-baker ads performance creative-health --sections trending,poor   # trending creatives, poor performers, launch hit rate, freshness
-baker ads performance families --by hook   # launched creatives by winning-ads library family, hook, angle, framework… with real spend and results
-baker ads performance creative-assets --ad-ids <id>   # every version of an ad's pictures and videos, stored at full size
-baker ads performance health --platforms meta   # spend vs last month, cost per result, budget in learning, audiences, copy, frequency
-baker ads performance breakdown --dimension placement   # also country, device; Meta: age, gender, audience_segment
-baker ads performance search-terms --zero-results
-baker ads performance search-terms --term-segments brand --campaign-segments non_brand   # brand searches bought by non-brand campaigns
-baker ads performance brand-split --days 30      # Google Search: brand, competitor and non-brand apart, each against its own target
-baker ads performance impression-share           # per Search campaign: share, lost to budget / ad rank, top of page, change in points
-baker ads performance keyword-quality --max-quality-score 5   # quality score and its parts, and the pages keywords lead to
-baker ads performance google-report --days 7     # every section of a Google Ads review in one read
-baker ads performance budgets                    # monthly budgets and how this month paces against each
-baker ads performance pacing --month 2026-10
-baker ads performance funnel --level campaign
-baker ads performance tracking
-baker ads performance landings
-baker ads performance live-in --landing <slug>   # live campaigns sending people to a landing; --creative <slug> for the ads showing a creative
-baker ads performance goals
-baker ads performance status                     # freshness per account; adsInManyAdGroups names ads counted under two ad groups
-baker ads performance people --level campaign  # who each campaign brought, how far up the ladder, cost per step
-baker ads performance people --level ad --ad-group-ids <id>  # the same, for the ads inside one ad set
-baker ads performance personas --dimension role  # the same people by role, company size, industry...
-baker ads performance ladder                     # the lead-to-customer steps and what they can be made of
-baker ads performance persona-fields             # which Form fields say who people are
-baker ads performance progress --status worsening  # worst first: really getting worse, how sure, and why
-baker ads performance diagnose <id> --platform meta --level campaign   # one entity: what moved, findings, weekly line
-baker ads performance pulse                      # last settled day against the 7 before, per ad account
-baker ads performance anomalies --cpa-spike 0.3  # unusual days in the last 2 settled weeks, what carried them, event health
-baker ads performance recap --days 7             # the week's changes as plain sentences: what, where, who, when
-baker ads performance targets --days 30          # per ad account and event: numbers against the target, what counts as a result
-baker ads performance targets set --platform meta --account 123 --event offsite_conversion.fb_pixel_lead --cost 25 --currency EUR
-baker ads performance targets set --company --roas 3   # the company default; --clear removes a target
-baker ads performance targets unstage --all      # take back what this chat staged
-baker ads performance goals set --platform google --account 456 --count "Lead form" --uncount Calls
-baker ads performance goals name --singular "demo request" --plural "demo requests"   # what the company calls a result; --reset
-baker ads performance budget-recommendations --moves scale,cut   # scale, hold, cut or pause each campaign against the target that judges it (its brand/non-brand target, else its account's, else the default)
-baker ads performance segments                   # the brand and competitor names, a person's choices, segment targets
-baker ads performance segments set --brand "Acme, acme.com" --competitors "Globex"
-baker ads performance segments set --campaign <id> --account <id> --segment brand   # or --term "<term>"; --clear
-baker ads performance segments set --target non_brand --cost 40 --currency EUR
-baker ads performance budgets set --amount 45000 --currency USD   # --platform --account [--segment brand] for one account
-```
-
-Brand, competitor and non-brand are read per search term and keyword by Baker's decision model against the brand and competitor names, and per campaign from what its keywords spent on; a person's choice always wins.
-
-`targets set`, `goals set`, `goals name`, `segments set` and `budgets set` stage on the chat (they need `BAKER_CHAT_ID`) and apply when it is published; a target someone changes in the dashboard meanwhile is kept and the staged one reported as not applied. Event targets are Meta and LinkedIn only — the other platforms cannot split spend by event.
-
-`progress` and `diagnose` judge the last 2 settled weeks against the 4 before, on the metric each entity is for (falling back to cost per click when results are too few), and separate a real decline from a measurement change (`not_comparable`), the market, scaling, fatigue, one child, the landing page and noise, with a confidence.
-
-Compact by default; `--full` returns every field. Errors with `ADS_NOT_CONNECTED` (and a `fix`) when no ad platform is connected.
-
----
-
 ### `baker ads google accounts`
 
 List the Google Ads accounts selected for this company. Run this first to find account IDs.
@@ -462,19 +402,19 @@ The same lines also go to stderr. A read with nothing to report prints none of i
 
 | Preset                 | Description                              | Default date range |
 |------------------------|------------------------------------------|--------------------|
-| `campaign-performance` | Campaign metrics, all conversions included, and bidding type | LAST_30_DAYS |
+| `campaign-performance` | Campaign metrics overview                | LAST_30_DAYS       |
 | `conversions-by-action` | Which conversion action each campaign's conversions actually are | LAST_30_DAYS |
-| `keyword-analysis`     | Keyword performance per ad group, with first-page, top-of-page and first-position CPC estimates | LAST_30_DAYS |
+| `keyword-analysis`     | Keyword performance per ad group         | LAST_30_DAYS       |
 | `keyword-serving`      | Why a keyword is limited — status reasons, first-page bid estimate vs max CPC, quality score | ALL_TIME |
 | `positive-keywords`    | Positive (targeting) keywords only       | ALL_TIME           |
 | `negative-keywords`    | Negative (blocking) keywords only        | ALL_TIME           |
 | `negative-keyword-lists`   | Shared negative lists + their terms  | ALL_TIME           |
 | `negative-list-attachments`| Which campaigns each shared list covers | ALL_TIME        |
-| `search-terms`         | Actual user queries triggering ads, with the match type that matched | LAST_7_DAYS |
-| `ad-copy-performance`  | Every ad's metrics, cost included, with RSA headlines/descriptions | LAST_30_DAYS |
+| `search-terms`         | Actual user queries triggering ads       | LAST_7_DAYS        |
+| `ad-copy-performance`  | Ad headline/description effectiveness    | LAST_30_DAYS       |
 | `asset-performance`    | PMax assets: serving status + metrics    | LAST_30_DAYS       |
 | `shopping-products`    | Product-level shopping metrics           | LAST_30_DAYS       |
-| `account-summary`      | Account-level totals, all conversions included | LAST_30_DAYS |
+| `account-summary`      | Account-level totals                     | LAST_30_DAYS       |
 | `pmax-channels`        | PMax spend/results per channel (Search, YouTube, Display, …) | LAST_30_DAYS |
 | `pmax-placements`      | Where PMax ads showed (impressions)      | LAST_30_DAYS       |
 | `placements`           | Display / Video / Demand Gen placements with cost and conversions | LAST_30_DAYS |
@@ -483,8 +423,6 @@ The same lines also go to stderr. A read with nothing to report prints none of i
 | `geo-performance`      | Results by country and location type (in vs interested in) | LAST_30_DAYS |
 | `age-performance` / `gender-performance` | Results by age range / gender per ad group | LAST_30_DAYS |
 | `ai-max-search-terms`  | AI Max search terms with the headline and landing page used | LAST_30_DAYS |
-| `bidding-strategy-performance` | Portfolio bidding strategies: type, status, targets and metrics | LAST_30_DAYS |
-| `conversion-tags`      | Website and call conversions' tracking code (Google tag + event snippet) | — |
 | `account-budget`       | Account budget: limit, served, pending change | —               |
 | `recommendations`      | Google's open recommendations with impact | —                 |
 | `campaign-simulations` / `keyword-bid-simulations` | Google's what-if points (budget, tCPA, tROAS, CPC bid) | — |
@@ -1335,11 +1273,18 @@ baker ads linkedin conversions health --account-id 503001492
 # "Pre-launch sanity check: is this audience too narrow?"
 baker ads linkedin audience-size --account-id 503001492 --targeting-file targeting.json
 
-# "What bid should I start at?"
+# "What bid should I start at?" — LinkedIn's suggested bid, in the account's currency
 baker ads linkedin bid-pricing --account-id 503001492 \
   --objective LEAD_GENERATION --cost-type CPC --targeting-file targeting.json
+
+# "What would 7,250 over 4 weeks get us?" — LinkedIn's forecast; a budget is required.
+# Without --bid it forecasts automated bidding; --bid 5.57 forecasts that manual bid.
+baker ads linkedin forecast --account-id 503001492 \
+  --objective LEAD_GENERATION --total-budget 7250 --days 28 --targeting-file targeting.json
 ```
 
+`forecast` returns the whole period's `results` (impressions, clicks, leads, spend, …), LinkedIn's `unitCosts` (cpc, cpm, costPerLead, …) and `rates` (ctr, …), each `{ value, low, high }`, plus the `period`, `budget` and `bidding` it forecast. The period starts tomorrow (or `--start YYYY-MM-DD`) and lasts `--days` (default 30); `--full` adds LinkedIn's daily, 7-day and 30-day series. Amounts without a currency use the ad account's.
+
 #### Smart defaults
 
 **`analytics`** — the 3-axis workhorse:
@@ -1386,7 +1331,7 @@ facets list                    # all targeting facets (industries, seniorities,
 facets values --facet titles --query "..."   # typeahead → URNs
 audience-size                  # estimate reach for a targetingCriteria payload + sweet-spot warnings
 bid-pricing                    # min/suggested/max bid + playbook §06 floor (2/3 of suggested)
-forecast                       # adSupplyForecasts wrapper for greenfield planning
+forecast                       # LinkedIn's results / cost forecast for a budget, bid and period
 
 leads                          # Lead Gen Form responses (90d retention — sync to your CRM)
 conversions list               # conversion rules (Insight Tag + CAPI)
@@ -1602,8 +1547,11 @@ baker analytics sources --map --source <id> --field email={{contact.email}} --fi
 baker analytics sources --create-hubspot --property lifecyclestage --value customer   # an event HubSpot keeps for Baker each time the property changes
 baker analytics sources --create-hubspot --property deal_value --operator greaterThan --value 1000   # any condition a Form's filter can say
 baker analytics sources --map --source <id> --field email={{work_email}} --field value={{deal_value}} --field currency=EUR   # repoint a HubSpot read
+baker analytics sources --create-activecampaign --events subscribe,deal_update   # ActiveCampaign's webhook sends these; each is an activecampaign.<event>
 ```
 
+**ActiveCampaign events.** `--create-activecampaign [--events …] [--name …] [--account <id>]` makes a source that ActiveCampaign's own webhook sends to — set up on the account when the chat is published (at once outside a chat), deleted when the source is removed. Each arrival is an event named `activecampaign.<event>` (`activecampaign.subscribe`, `activecampaign.deal_update`, …), about its contact, with the rest of the payload as `properties.*` — the name a scheduled agent on `event.received` is narrowed to.
+
 **Sources: where events reach Baker from a server.** Measure → Sources is three built-in doors — the Baker landings, the website tag, and **the client's own server** — plus the connections Baker reads (HubSpot today). `--server` prints the server's one address: made once, the same for ever, `counting` at once, Baker's own format (`sending-events` is the contract; `X-Baker-Mode: test` rehearses). A HubSpot event is a trigger in HubSpot's own words, kept by HubSpot's journal each time the property changes and counted within a minute. `--create --name <tool>` still makes an address for a tool that cannot be told what to send — its first send is a masked sample counted as nothing until `--map` confirms the rows — but the dashboard no longer offers those; a tool worth reading is a connection, requested from the Sources page. Each `--field` is a **template**: text with `{{path}}` mentions, one thing per mention (`--field currency=EUR` types a value, `--field first_name="{{who.first}} {{who.last}}"` joins two; there is no `{{a|b}}` fallback); a bare path is read as its mention when the sample has it. From then on every arrival is an ordinary event carrying `baker_source: <name>`, listed by `feed --source <name>`, and `--pause`, `--resume` and `--remove` are by `--source <id>`.
 
 **`--preview` then `--create-hubspot --property <name> [--operator <op>] --value <value>… [--name <name>] [--field <field>=<template>…] [--amount-property <n> --currency <c>]`: a HubSpot event.** HubSpot keeps each change to the property for Baker, filtered to the condition — on any plan, nothing to set up in HubSpot, an account of any size — and every contact whose new value satisfies the condition is one event, within a minute, named after the source (default: the trigger's words). The condition is any a Form's filter can say, by the property's kind: `is` / `isNot` (a dropdown, `--value` repeated for several), `contains` / `startsWith` / `endsWith` (text), `greaterThan` / `lessThanOrEqual` … (numbers), `isAfter` / `isBetween` (dates, `YYYY-MM-DD`), `isEmpty` / `isNotEmpty` (any); `--operator` is `is` when unsaid. Names, kinds and operators come from `baker hubspot contacts properties` and row properties from `baker hubspot contacts fields`; `--preview --property … [--operator …] --value … [--field …] [--contact <id or email>]` says how many contacts satisfy it today (NOT counted — only contacts that come to satisfy it from now on are) and returns `preview.record`, the one most recently there or the one asked for, to check every row against before making anything. `--set-trigger --source <id> --property … [--operator …] --value …` changes what an event watches later: the rows stay and `countingSince` moves to now. The connection must be allowed to read contacts, and a refusal names the reconnect. `counting` at once, no URL; the source carries `hubspot { property, propertyLabel, kind, operator, values, valueLabels }`, `countingSince`, `listening` (whether HubSpot has been told to keep its changes: `listening`, `not_configured` or `failed`, with a `detail`), `lastError` and `mapping` — the same field → template table as an address, over the contact's properties plus `{{id}}`, defaulting to HubSpot's standard ones (email, phone, the contact id, name, address, `hs_google_click_id`, `hs_facebook_click_id`); a `--field` row at creation replaces the default it names, `--map --field` replaces the whole set later, and `--amount-property … --currency …` is the short spelling for the `value` and `currency` rows. `--field properties.<name>=<template>` adds an extra property of the event (`--field properties.plan={{plan_tier}}`): it breaks the event down on Measure → Events and a send reads it back as `{{properties.<name>}}`. A deal is watched the same way with `--object deal`, and a lead with `--object lead` (`baker hubspot leads properties|fields`) — where HubSpot records qualification and disqualification as the lead's stage. A deal's or a lead's event is about its contacts (`--contacts every|first`), read as `{{contact.<name>}}`; a lead has no amount. Leads need Sales Hub Professional or Enterprise. Where the event is sent on (Meta, Google Ads…) is `sends`, edited on the event's own card on the Sources page.
@@ -1933,6 +1881,38 @@ baker ga4 draft clear
 
 ---
 
+### ActiveCampaign reads (`baker activecampaign`)
+
+Read the connected ActiveCampaign account live; nothing is stored and nothing in ActiveCampaign changes.
+
+```bash
+baker activecampaign account                                   # contacts, site tracking on/off + tracking account id, allowed domains, event tracking
+baker activecampaign campaigns [--status completed] [--since 2026-09-01] [--limit 20]   # email reports, most recently sent first
+baker activecampaign automations [--active-only]               # on/off, entered/exited, what starts each one
+baker activecampaign contacts [--id <contact id> | --email a@b.com | --tag <id|name> | --list <id|name> | --search <text>] [--limit 20]
+baker activecampaign deals [--pipeline <id|title>] [--stage <id|title>] [--status open|won|lost] [--owner <id|username|email>]
+baker activecampaign pipelines | lists | tags [--search <text>] | fields | users
+```
+
+A contact looked up by `--id` or `--email` also carries its `tags` and its `activity`: custom events, page visits, campaign emails sent, opened and clicked, automation runs and list subscriptions. Campaign rows carry `sends`, `opens`, `uniqueOpens`, `clicks`, `uniqueClicks`, `unsubscribes`, `hardBounces`, `softBounces` and `rates` (`open`, `click`, `unsubscribe` and `bounce` as shares of sends; `clickToOpen` as unique clicks over unique opens; `null` before anything is sent). Deal values are in the currency's major units, and `totals` sums every matching deal per currency. Every command takes `--account <id>` when the company has more than one ActiveCampaign connection, and `--full` adds each row's untouched ActiveCampaign payload as `raw`. Nothing connected answers `NO_ACTIVECAMPAIGN_CONNECTION`, a key ActiveCampaign stopped accepting `ACTIVECAMPAIGN_RECONNECT_REQUIRED` — both with a `request_connection` fix.
+
+### ActiveCampaign changes (`baker activecampaign stage` / `unstage` / `drafts`)
+
+Stage a custom contact field, list, tag or deal pipeline on the connected ActiveCampaign account. Nothing changes in ActiveCampaign until the chat is published; then each change is created — or, when the account already has it (a field by its personalization tag, the rest by name), reused rather than duplicated.
+
+```bash
+baker activecampaign stage field --utm                                   # UTM_SOURCE, UTM_MEDIUM, UTM_CAMPAIGN, UTM_CONTENT, UTM_TERM
+baker activecampaign stage field --title "Plan" --type dropdown --options "Basic,Pro"
+baker activecampaign stage list --name "Webinar sign-ups"
+baker activecampaign stage tag --name "hot-lead"
+baker activecampaign stage pipeline --title "Inbound" --stages "New lead,Qualified,Won" --currency usd
+baker activecampaign drafts [--chat <id>]                                # what is staged; after Publish, what happened to each
+baker activecampaign unstage <ref|name|perstag>                          # drop one staged change
+baker activecampaign unstage --all                                       # drop every staged change
+```
+
+A field is put on every list. Field types: `text`, `textarea`, `date`, `datetime`, `dropdown`, `listbox`, `radio`, `checkbox`, `hidden`; `dropdown`, `listbox`, `radio` and `checkbox` need `--options`. A new pipeline gets exactly `--stages`; an existing one only gains the stages it lacks. Every `stage` takes `--account <id>` when the company has more than one ActiveCampaign connection.
+
 ### Google Search Console (`baker gsc`)
 
 GSC commands for PPC-SEO arbitrage, brand halo analysis, and negative keyword discovery.
@@ -2012,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. When the idea says what it `shows` (what the scroller sees first: a before/after, a reaction, a real review…), it first searches for ads that show that, from any category, in its market and then anywhere (ADR 0015). It then searches for ads of what this ad sells, in its market and then anywhere, first in the idea's container (when it names one) 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: make fails with `REFERENCE_SEARCH_UNAVAILABLE` and is run again). 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 (does it show what ours shows, when the idea says? 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 make fails (`REFERENCE_SLOW`): run it again, the searches and checks already made are kept, so it goes further each time. 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: first the moment in the feed, what ours shows, how it stops this viewer, says "this is for me" and makes them want more, and whether the proven ad shows it (else rebuild on one that does with `--reference`), or why the bet should work; then, sending the agent to that picture and seeded with the fit's read, what the reference is and why it won; 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, or the proven ad it picked could not be read; a slow or unavailable search never starts an ad from the idea, and 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.
 
@@ -2588,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 |
@@ -2630,11 +2620,11 @@ 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>`
 
-Search the company library (hybrid BM25 + vector + Cohere rerank). Use this FIRST before any external provider.
+Search the company library (hybrid BM25 + vector + rerank). Use this FIRST before any external provider.
 
 ```bash
 baker images library "hero banner"
@@ -2665,7 +2655,7 @@ Fanout image search: library first, then opted-in providers in parallel.
 
 ```bash
 baker images find "office" --sources library,pexels,pixabay --limit 20
-baker images find "office" --sources library,pexels --fallback --threshold 0.4
+baker images find "office" --sources library,pexels --fallback
 baker images find "celebration" --sources library,giphy --auto-ingest 3
 ```
 
@@ -2678,7 +2668,7 @@ Providers: `library`, `pexels`, `pixabay`, `google`, `iconify`, `giphy`, `pinter
 | `--sources`      | Comma-separated providers (default `library`)                                              |
 | `--limit`        | Max results per group (default 20, max 50)                                                 |
 | `--fallback`     | Skip external providers when the top library score ≥ `--threshold`                         |
-| `--threshold`    | Library score floor for `--fallback` (default `0.4`)                                       |
+| `--threshold`    | Library score floor for `--fallback` (default `0.6`)                                       |
 | `--auto-ingest`  | Ingest top N external hits into the library (0–20, default 0) and return Baker-owned URLs on ingested hits |
 | `--context`      | Free-text hint passed to Gemini describe to bias the generated description and tags (overrides provider-derived context on auto-ingest paths) |
 
@@ -3575,7 +3565,7 @@ Search the **ad-dna** corpus of scored "winning" competitor ads for reference cr
 
 > Replaces the old `baker ads google library` tree, which has been removed. Competitor-by-keyword discovery still lives at `baker research advertisers`.
 
-`baker winning-ads profile <advertiserId>` returns what one brand is doing: an estimated spend in USD (a range over every ad since `since`, the last 30 days, and a minimum, split by channel in `by_platform` — a channel that publishes no delivery is marked `unpriced`; `ads_counted` says how many ads were measured, estimated from similar ads, or not counted for lack of reach), what it launched lately and which of those still run, the concepts it tested and the version it kept, its format and platform mix, top landing pages, audiences and similar brands. `--platform` narrows it, `--full` returns everything. `baker winning-ads launches [--since 7] [--advertiser a,b]` lists what the followed brands (or the named ones) launched in the last N days and which still run.
+`baker winning-ads profile <advertiserId>` returns what one brand is doing: an estimated spend in USD (a range over every ad since `since`, the last 30 days, and a minimum, split by channel in `by_platform` — a channel that publishes no delivery is marked `unpriced`; `ads_counted` says how many ads were measured, estimated from similar ads, or not counted for lack of reach), what it launched lately and which of those still run, the concepts it tested and the version it kept, its format and platform mix, top landing pages, audiences and similar brands. `--platform` narrows it, `--full` returns everything. `baker winning-ads launches [--since 7] [--advertiser a,b]` lists what the followed brands (or the named ones) launched in the last N days and which still run. Both say, for every launch, whether it was a `new` idea, another version of one still in `testing`, or a version built on a `winner` the brand had already kept; the profile also counts new ideas per week and `unique_ideas` overall.
 
 `baker winning-ads landings <advertiserId>` lists every landing page the brand's ads point to, most ads first, with how many ads point there, how many still run, the platforms and when each was last used. `address_only` marks an address only Google search ads print: Google publishes no search ad's destination, so it may not be a real page and is never analysed. `--analyse` studies the top 5 pages not analysed yet (`--pages a,b` to name them): each page's headline, value propositions, offer, pricing, calls to action, proof, audience and sections in order. Analysis takes a few minutes per page and is shared by every company, so a page analysed once is ready for all. `--platform` narrows it, `--full` returns every field.
 
@@ -3630,6 +3620,7 @@ baker winning-ads search "delivery driver recruitment" --audience-temperature 0_
 | `--first-seen-after` / `--first-seen-before` | ISO date (`2026-01-01`, read as the start of that day in UTC) or datetime bounds (recency) |
 | `--hook-archetype <list>` | Narrow to ads on a proven hook **seed** (from `winning-ads hooks`) |
 | `--format-pattern <list>` | Narrow to statics in these containers (from `winning-ads formats`, e.g. `comparison_table`) |
+| `--partnership only\|exclude` | `only` = just Meta partnership ads (the brand ran it with a creator or another brand); `exclude` = the brand's own ads. Every partnership row carries `partnership: true` and the `partner` it was run with |
 | `--diverse` | One varied page (different brands, containers, hooks) instead of rank order; ignores paging |
 | `--all-kinds` | Also return Google search text, Shopping and app ads. By default only designed pictures and videos come back; `--format text` (or a query asking for search ads) returns search ads alone |
 | `--output json\|md\|files` | Output format (default json) |
@@ -3674,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.
@@ -3840,9 +3836,10 @@ baker scheduled-agents unstage <id-or-temp_agent_id> --index 2  # one staged cha
 
 baker scheduled-agents run <id>
 
-baker scheduled-agents templates --list                  # every recipe this company can run
-baker scheduled-agents templates --category measurement  # one group only
-baker scheduled-agents create --template baker-ads --name "Weekly ad review" --description "..." --cron "0 8 * * MON"
+# Organization workspace only: hear what happens in its companies — all of them, or the ones named
+baker scheduled-agents create --name "Reconnect alert" --description "A client's tool stopped working" --prompt "Say who has to reconnect what." --trigger connection.needs_reconnect --slack me
+baker scheduled-agents update <id-or-temp_agent_id> --companies <company-id>,<company-id>   # `all` hears every company again
+
 ```
 
 Triggers:
@@ -3859,8 +3856,6 @@ Triggers:
 | `experiment.concluded` | The winner has been moved into the page | `--experiment <id>` |
 | `task.completed` | A Task is closed | `--tag <slug>` |
 | `task.claimed` | An agent picks up a Task | `--tag <slug>` |
-| `ad_alert.opened` | Baker raises an ad alert (new, back, or a fix that did not hold) | `--ad-account <platform>:<id>`, `--alert <rule>` |
-| `ad_alert.claimed` / `ad_alert.fixed` / `ad_alert.closed` | An ad alert is picked up, marked fixed, or leaves the list (`how` says why) | `--ad-account`, `--alert` |
 
 Rules:
 
@@ -3872,39 +3867,12 @@ Rules:
 - `--occurrences 1` runs only the first time the trigger ever fires; `--occurrences 1,3` the first and the third. Omit it to run every time. It counts firings of this item's trigger, so a firing that `--occurrences` declines is still counted.
 - A signal-triggered item will not start a second run while its last one is still going, and never wakes itself.
 - `--prompt` is the whole job: there is no mode and no `--spawn-agent`. If a run should only advise, the brief says so.
+- Keep `--prompt` to five to eight schematic lines: `Goal:`, `Tools:` with each tool tagged (`@[Google Ads](integration:google-ads)`, `@[Gmail](mcp:gmail)`, `/skill`), numbered steps with the exact `baker` commands and flags, and `Report:`. A brief over 1,500 characters comes back with a hint to shorten it.
 - Publishing every run's work unreviewed is a standing authorization only the user can grant, on the item in Baker. The API refuses `autoPublish` outright.
 - Draft-created ids use `temp_agent_*`; use them with `get`, `update`, or `delete` before publish.
 - Staged commands require `BAKER_CHAT_ID` to point to an `in_progress` chat.
 - `run` rejects `temp_agent_*` and only accepts published ids. It returns the `chatId` of the Session it opened.
 - Company Timezone is the default; `--timezone` is an explicit IANA override.
-- `--template <id>` copies a marketplace recipe's brief onto the item — a copy, not a link, so the owner can read and edit every word, and a later change to the recipe does not reach it. `--prompt` is appended after it. The same recipe can be used more than once.
-
-#### Marketplace recipes (`templates`)
-
-`templates` lists every recipe a company can build an item from — the ones Baker maintains plus any the company wrote — and is also how one of theirs is written. Recipes we maintain take priority: a company recipe can never use one of our ids, and resolution reads ours first.
-
-```bash
-baker scheduled-agents templates --list --drafts        # include theirs not offered yet
-
-# Writing one of theirs, in this order:
-baker scheduled-agents templates --save weekly-posthog-check \
-  --name "Weekly PostHog check" \
-  --tagline "What moved in the funnel, from PostHog rather than GA4." \
-  --recipe-category measurement --frequency weekly \
-  --brief-file ./brief.md
-
-# ...build an item from it with --template, run that item, read what it produced, then:
-baker scheduled-agents templates --publish weekly-posthog-check
-baker scheduled-agents templates --delete weekly-posthog-check
-```
-
-- **Saving does not offer it.** A saved recipe is invisible and cannot be scheduled until `--publish`. The step between the two is running it: nothing enforces that, and it is the only way to know it produces anything worth reading.
-- **`--publish` refuses what it can check**: a brief too short to run unattended, a cadence or category that does not exist, an id that shadows one of Baker's, and a brief naming no source this company has connected. The problems come back as text addressed to the agent.
-- **Only company-wide and organization-wide connections count.** A run fires unattended, so a tool one person connected for themselves works in the chat where the recipe was written and returns nothing every run after that.
-- **Prefer `--brief-file`** over `--brief`: shell quoting eats apostrophes and newlines, and the brief is the whole recipe.
-- **Publishing stages**, like every other Session effect. The recipe reaches the marketplace when the chat is published and is listed there as a change; discarding the chat leaves the marketplace as it was. `BAKER_CHAT_ID` is required for `--save`, `--publish` and `--delete`.
-- **A company's own starts on Recommends** and offers every cadence. The company changes that from its Marketplace tab.
-- **`--delete` stops any schedule still pointing at it** — the response says how many.
 
 ---
 
@@ -3958,13 +3926,14 @@ baker flows options calendly                        # what a step/destination ca
 baker flows connect contact --node book --resource <id>          # fill a Calendly/SavvyCal/GoHighLevel step yourself
 baker flows connect contact --side-effect se-gsheet-1 --resource <spreadsheetId>   # a sheet Baker can reach (--tab to pick the tab)
 baker flows connect contact --side-effect se-gsheet-1 --new-sheet "Contact leads" --columns "Name,Email"   # create one and wire it
-baker flows connect contact --side-effect se-pipedrive-1         # Pipedrive / GoHighLevel contact: the account is the destination
+baker flows connect contact --side-effect se-pipedrive-1         # Pipedrive / GoHighLevel / ActiveCampaign contact: the account is the destination
 baker flows connect contact --side-effect se-email-1 --email "ana@x.com, luis@x.com" --subject "New lead — Contact"   # an email destination: the agent states it, never a card
 baker flows connect contact --side-effect se-httpWebhook-1 --url https://hooks.example.com/lead   # a webhook that needs no token
 baker flows connect contact --all --type googleSpreadsheet --same-as madrid:se-gsheet-1   # copy another Form's destination
 baker flows map contact --from map.json --write     # a whole mapping at once — past ~3 fields, use this
 baker flows map contact --map A=nombre --write      # one or two fields
 baker flows map contact --hubspot-form <guid> --from map.json --write   # HubSpot: field types read off the form
+baker flows map contact --map email=email --map 'tags="withbaker-"+tracking:page_path' --write   # ActiveCampaign: fields read off the account; tag each lead with its page
 baker flows map contact --side-effect <id> --hubspot-form <guid> --prune-missing --write   # drop dead mappings
 baker flows map contact --from map.json --replace --write   # the slot becomes exactly this; drops everything not named
 baker flows normalize contact --write              # repairs a nulled optional; runs pre-commit anyway
@@ -3974,13 +3943,13 @@ Notes:
 
 - **`schema` takes the kind as an argument because `hubspot` is both** — a node type (embeds a form on the page) and a side-effect type (fires a behavioural event). They are different things with one name.
 - **`connect` wires a HubSpot form without asking the user.** When HubSpot is connected and the agent knows which form is meant, `baker flows connect <slug> --hubspot-form <formId> [--side-effect <id>]` attaches the account and the form to a `hubspotForm` side effect (`--all`: every one in the Form still missing it, never repointing one already wired) — the same thing the chat card writes, sealed by Baker so the config never passes through the agent. It refuses a form with spam prevention (captcha) on, and returns `destination.formGuid` for `map --hubspot-form`. The card (`request_flow_input`) stays for an unconnected account or an ambiguous choice.
-- **`options` + `connect` do the same for every other connected platform.** `baker flows options <kind>` lists what the connected account holds (Calendly events, SavvyCal links, GoHighLevel calendars and forms, the Google spreadsheets Baker can reach); `connect --node|--side-effect <id> --resource <id>` writes exactly what the card would. Pipedrive and a GoHighLevel contact take no resource. `--new-sheet` creates a spreadsheet in the connected Google account (Google only lets Baker reach sheets it created or the user chose), `--same-as <slug>:<id>` copies another Form's wired destination, `--all --type <kind>` fills every unwired one of a kind. Nothing connected answers `NOT_CONNECTED` with the `request_connection` fix; several accounts connected need `--account <id>`.
+- **`options` + `connect` do the same for every other connected platform.** `baker flows options <kind>` lists what the connected account holds (Calendly events, SavvyCal links, GoHighLevel calendars and forms, the Google spreadsheets Baker can reach); `connect --node|--side-effect <id> --resource <id>` writes exactly what the card would. Pipedrive, a GoHighLevel contact and an ActiveCampaign contact take no resource. `--new-sheet` creates a spreadsheet in the connected Google account (Google only lets Baker reach sheets it created or the user chose), `--same-as <slug>:<id>` copies another Form's wired destination, `--all --type <kind>` fills every unwired one of a kind. Nothing connected answers `NOT_CONNECTED` with the `request_connection` fix; several accounts connected need `--account <id>`.
 - **`--email` / `--url` replace a destination whole, so they leave alone what only the user can set.** `--all --email` passes over an email that replies to the visitor's own answer (and says so in its hints); naming one is refused. A webhook that sends a credential keeps its address until the user re-enters both through `request_flow_input`. Unreadable settings are also left alone by default. For one unreadable email, `--replace-unreadable --email <complete list> --subject <text>` replaces the old setup when the user intends replacement, without revealing it. Never use this to add to an unknown recipient list; it cannot override `--all`, a known visitor reply, or a webhook. `flows show` reads back only destinations sealed for this company.
 - **Configure the destination before you map.** `columnMapping`/`fieldMapping` describe a *specific* destination — sheet columns, a portal's field names — that only `connect` or `request_flow_input` can set, and both return it. A mapping written first is valid JSON that ships and drops every submission; `verify` blocks the half-wired result.
-- **`map` reads the record shape off the side effect's type.** One property name, four record shapes: a Sheet is addressed by column letter, HubSpot by property name, Pipedrive and GoHighLevel by field key, Crmble by field id. That is why there is no `--key`, and why `--entity` and `--custom`/`--standard` are required rather than defaulted.
+- **`map` reads the record shape off the side effect's type.** One property name, four record shapes: a Sheet is addressed by column letter, HubSpot by property name, Pipedrive and GoHighLevel by field key, ActiveCampaign by field key (`email`, `firstName`, a custom field's id, `tags`, `lists`, `automations`, `note`, or a qualified `deal.title` / `account.name` / `event.name`), Crmble by field id. That is why there is no `--key`, and why `--entity` and `--custom`/`--standard` are required rather than defaulted for Pipedrive and GoHighLevel.
 - **A mapping is usually eight to fifteen fields, so `--from` is the main door.** It takes `{ "map": { "<destField>": "<value>" } }` from a file or stdin; `--map` flags are for one or two. Both produce identical output.
 - **Most CRM fields are not fed by a form field.** The value grammar is a bare form field (`nombre`), `field:Step.name` when two steps share a name, `tracking:utm_source`, `global:Name`, `code:exposed_value`, a `"literal"`, or any of those joined with `+`. Tracking names are validated against the engine's own `TRACKING_FIELD_IDS`, read out of the workspace rather than copied — attribution columns are the most common CRM mapping there is, and they were unexpressible before.
-- **A CRM mapping's field type is derived from the destination, never defaulted.** Every CRM record types `fieldType` as required, and it is the account's answer, not the agent's — HubSpot builds its submission key as `<objectTypeId>.<fieldType>.<fieldName>`, so a wrong type on a date property skips the `YYYY-MM-DD` coercion and the value is dropped. `--hubspot-form <formGuid>` (or `"hubspotForm"` in the mapping file) reads every property's type and object type off the form, so nothing has to state one. Where a destination cannot be read, put the type on the LEFT — `c0ffee:varchar=email` — which leaves `:` on the right for the value kinds. A mapping with no type from either route is refused, never written without one.
+- **A CRM mapping's field type is derived from the destination, never defaulted.** Every CRM record types `fieldType` as required, and it is the account's answer, not the agent's — HubSpot builds its submission key as `<objectTypeId>.<fieldType>.<fieldName>`, so a wrong type on a date property skips the `YYYY-MM-DD` coercion and the value is dropped. `--hubspot-form <formGuid>` (or `"hubspotForm"` in the mapping file) reads every property's type and object type off the form, so nothing has to state one. An `activeCampaignContact` mapping reads the connected ActiveCampaign account's field list on every call — no flag — so its types (`standard`, `custom`, `tags`, `lists`, `automations`, `deal`, `account`, `note`, `event`) are derived too, a custom field may be named by its id, personalization tag or label (stored as the id) — or as `custom.<TAG>` for one that is only staged so far, resolved when each lead is sent — and a name the account does not have is refused with the list of the ones it does. Its `tags`, `lists` and `automations` mappings are comma-separated names or ids that may mix text and variables, e.g. `tags="withbaker-"+tracking:page_path`; `deal.title` or `deal.pipeline` creates a deal (`deal.value` in major units, `deal.stage` / `deal.owner` by name or id), `account.name` finds or creates the lead's company, `note` leaves a note and `event.name` records an event (it needs the account's event key on the connection). The answer's `hints` name a list, automation, pipeline, stage or user the account does not have, a deal nothing creates, and an event with no event key. Where a destination cannot be read, put the type on the LEFT — `c0ffee:varchar=email` — which leaves `:` on the right for the value kinds. A mapping with no type from either route is refused, never written without one.
 - **`email` maps like anything else**, into `body.fields`, while `body.format` is `"json"`. A `"body"`-format email is one written message with no keys to address, and `map` refuses it rather than reshaping the body.
 - **A Form can look finished and be losing every lead.** HubSpot refuses a submission that names a property it does not have — the whole submission, not the field — and the visitor still reaches the thank-you screen. Baker re-checks each Form's destination and `baker flows show <slug>` reports what it found: `data.drift[]` carries **one entry per drifted destination** — a Form with two HubSpot side effects has two mappings, two form ids and two repairs — each with the severity, a sentence naming the fields, the side-effect id and that destination's HubSpot form id; the hints carry one repair command per entry. `drift: null` means the check could not be made and is not the same answer as `[]`.
 - **`--prune-missing` is the repair; `--replace` is not.** With `--side-effect <id>` and `--hubspot-form <guid>`, `--prune-missing` drops exactly the mappings whose destination field is absent from that form's live field list, names each one in `dropped`, and leaves every other mapping alone. It needs no `--map` and runs on its own. `--replace` drops everything the call does not name, so using it to remove three dead mappings means first restating the ten good ones correctly.
@@ -3990,7 +3959,7 @@ Notes:
 - **`normalize` exists so authoring a Form does not require remembering an exception.** `oauthProviderId` is an optional `string`, so a `null` there fails typecheck one build later — it is repaired and staged instead of rejected.
 
 - **Secrets never travel through this CLI or the chat.** `show` reports only whether each field is configured (`[set]`/`[missing]`, `[connected]`/`[needs connection]`, selected/not selected) — never a value. Configured secrets appear only as `[configured]` ciphertext markers.
-- Confidential side-effect types: `httpWebhook`, `zapier`, `crmble` (typed credentials); `pipedrive`, `googleSpreadsheet`, `hubspotForm`, `goHighlevelContact` (OAuth connection + resource); `email`. Widget node types needing a resource pick: `calendly`, `savvycal`, `hubspot`, `hubspotMeeting`, `highlevel`, `highlevelForm`.
+- Confidential side-effect types: `httpWebhook`, `zapier`, `crmble` (typed credentials); `pipedrive`, `googleSpreadsheet`, `hubspotForm`, `goHighlevelContact`, `activeCampaignContact` (connected account + resource); `email`. Widget node types needing a resource pick: `calendly`, `savvycal`, `hubspot`, `hubspotMeeting`, `highlevel`, `highlevelForm`.
 - `request_flow_input` changes stage on the chat's branch and apply when the chat is published; discarding the chat drops them.
 
 ### Action Items (`baker actions`)
@@ -4394,7 +4363,6 @@ baker studio generate "flat geometric mascot, brand palette" \
 | `google/gemini-3.1-flash-lite-image` | Cheapest tier (Nano Banana 2 Lite) — half the flash price per output token. High-volume variants and any 1K-sufficient frame, portrait ad formats included | standard **+** `1:4` `4:1` `1:8` `8:1` | `1K` **only** |
 | `google/gemini-3-pro-image` | Highest fidelity (Nano Banana Pro) — strong prompt adherence and reference grounding | standard set | `1K` `2K` `4K` |
 | `openai/gpt-image-2` | Photoreal + cleanest in-image text — ad/landing reproduction | standard set **minus** `4:5` `5:4` | *(none — derived from the ratio)* |
-| `openai/gpt-5.4-image-2` | **Legacy** — accepted so canvases authored before the gpt-image-2 switch still re-run. Don't pick it for new work. | standard set | `1K` `2K` `4K` (ignored upstream) |
 | `recraft/recraft-v4.1-pro-vector` | Vector/flat/SVG-style with palette control. Writes **SVG**, so its output cannot be fed back as a reference | `1:1` `4:3` `3:4` `16:9` `9:16` **only** | *(none — refuses `image_size`)* |
 
 Standard aspect ratios: `1:1` `2:3` `3:2` `3:4` `4:3` `4:5` `5:4` `9:16` `16:9` `21:9`.
@@ -4517,7 +4485,7 @@ Compact output per take is `{ slot, status, imageId | videoId, url, inLibrary, e
 | `product-pack-shot` | `openai/gpt-image-2` | `1:1` | 3 | **yes** |
 | `ugc-selfie-hook` | `openai/gpt-image-2` | `9:16` | 3 | **yes** |
 | `lifestyle-scene` | `openai/gpt-image-2` | `4:5` | 3 | **yes** |
-| `cinematic-still` | `google/gemini-3-pro-image-preview` | `16:9` | 3 | no |
+| `cinematic-still` | `google/gemini-3-pro-image` | `16:9` | 3 | no |
 | `brand-icon` | `recraft/recraft-v4.1-pro-vector` | `1:1` | 4 | no |
 | `background-plate` | `google/gemini-3.1-flash-image` | `4:5` | 3 | no |
 
@@ -4600,7 +4568,8 @@ baker canvas run my-canvas.json --regenerate gen,adapt
 #     edit (a file watcher), but you can invoke it directly. Accepts the
 #     .canvas.json, its prompt.json, or the creative folder. The rendered image
 #     still only changes on a real `run`, so the dashboard shows an "edited since
-#     last render" badge in the meantime.
+#     last render" badge in the meantime. It also carries the creative's
+#     _definition.md, which the dashboard shows as the ad's brief.
 baker canvas sync-definition src/creatives/<slug>/
 
 # 3. Inspect a finished run (per-node timing, file list, optional video thumbs)
@@ -4943,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.
@@ -5117,9 +5098,9 @@ No `image_size`: OpenAI derives the pixel dimensions from the ratio, so a size i
   "params": { "model": "openai/gpt-image-2", "prompt": "Photorealistic photo of …", "aspect_ratio": "16:9", "quality": "high" } }
 ```
 
-###### Model: `openai/gpt-5.4-image-2` (legacy)
+###### Superseded model ids
 
-Kept only so canvases authored before the gpt-image-2 switch still validate and re-run unchanged — `baker canvas run --slug` replays a recorded canvas verbatim. It keeps the full standard ratio set (including `4:5` / `5:4`) and still accepts `image_size`, which the provider ignores. Prefer `openai/gpt-image-2` for anything new.
+`openai/gpt-5.4-image-2`, `google/gemini-3.1-flash-image-preview` and `google/gemini-3-pro-image-preview` are no longer offered, but a canvas, Studio request or skill that still names one keeps working — `baker canvas run --slug` replays a recorded canvas verbatim. Each runs on its successor: `openai/gpt-image-2.5-sunburst` (a `4:5` / `5:4` snaps to `3:4` and `image_size` is dropped, since GPT Image 2.5 takes neither), `google/gemini-3.1-flash-image` and `google/gemini-3-pro-image` (same params). Never pick them for new work.
 
 ###### Model: `google/gemini-3.1-flash-image` (legacy id `google/gemini-3.1-flash-image-preview` still accepted)
 
@@ -6143,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.
@@ -6190,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]`
 
@@ -6305,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 (every new ad; `--master-shape plate` asks for one picture instead), 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). The model draws the brand's logo from its file, handed to every render beside the reference, so the ad is designed around it; the review holds the drawn logo to its file. A canvas made with the logo placed from its file keeps it placed (`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 (`--master-shape plate`, ADR 0014).** It was the default for a photo-led ad until its ads came back stamped (words set by a second call, the logo pasted); every new ad is now drawn whole and laid out again for each size. The canvas records which kind of ad it read (photo-led, designed or interface: 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) and 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), which also moves one made on one picture without asking for it back to the re-laid-out shape. 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`).
 
@@ -6322,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.
 
@@ -6358,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.
 
@@ -6373,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]`
 
@@ -6856,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...
@@ -6872,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.