@koda-sl/baker-cli 0.569.0 → 0.571.0-dev.6a3439a0a

package/README.md

@@ -151,8 +151,9 @@ Commands with a compact default view declare `--full` to return every field
 (`baker ads meta ads|adsets|campaigns|audiences|creatives|insights`, `images`, `winning-ads`, …). Every other command that
 prints the JSON envelope accepts `--full` too: it already prints everything it returns, so
 the flag changes nothing and a hint in the envelope says so (on stderr when the command
-printed a readable view instead). Commands that print no data envelope (`canvas run`,
-`canvas sync-definition`, `analytics sending-events`) refuse it.
+printed a readable view instead). `canvas run` and `canvas validate` declare their own `--full`
+(the per-node detail behind their compact result). Commands that print no data envelope
+(`canvas sync-definition`, `analytics sending-events`) refuse it.
 
 ### Reading another company: `--company <id>`
 
@@ -190,7 +191,7 @@ Use `--output` to change format:
 | `csv`   | RFC 4180 comma-separated values    | Analysis tools     | `baker research …` only |
 | `jsonl` | One JSON object per line           | Streaming/appending | `baker research …` only |
 
-`--output json` is accepted even by a command that declares no `--output`: the envelope is already what it prints, and on a command whose default is a readable view (`baker tags list`, the `draft` commands) it becomes that command's `--json`. `baker canvas run` takes it too and prints its envelope alone on stdout, its progress lines on stderr; on `baker creatives publish`, whose own `--output` names the cover size, `--output json` is the envelope request and the cover keeps any other `--output` value. The few commands that print only text — `baker analytics sending-events`, `baker canvas sync-definition` — refuse it, as a command without its own `--output` refuses `files`.
+`--output json` is accepted even by a command that declares no `--output`: the envelope is already what it prints, and on a command whose default is a readable view (`baker tags list`, the `draft` commands) it becomes that command's `--json`. `baker canvas run` always prints its envelope alone on stdout and its progress lines on stderr, so it takes it as already done; on `baker creatives publish`, whose own `--output` names the cover size, `--output json` is the envelope request and the cover keeps any other `--output` value. The few commands that print only text — `baker analytics sending-events`, `baker canvas sync-definition` — refuse it, as a command without its own `--output` refuses `files`.
 
 `--output md` is accepted the same way. A command with its own Markdown view prints that; any other command, including one whose own `--output` prints only `json` (`ads linkedin demographics`), that prints the envelope gets a generic rendering — a table for a list of records, `key: value` lines for one record with a table per list it holds, then `meta`, warnings and `hints` (as `> ` lines) below. On a command whose default is already a readable view it changes nothing. Errors and dry runs stay JSON.
 
@@ -5274,11 +5275,15 @@ baker canvas validate my-canvas.json
 
 # 2. Run (executes nodes, writes files to ./canvas/<run_id>/)
 baker canvas run my-canvas.json
-#    Advisory warnings print as `[warn] <CODE>: …` before anything bills.
+#    Advisory warnings print as `[warn] <CODE>: …` (on stderr) before anything bills.
 #    Only nodes reachable from the declared output execute (orphaned nodes are skipped,
 #    not billed). Add --keep-runs N to prune old r_* run dirs, keeping the N newest.
-#    The JSON ends with `verdict` (static ads), `run_id` and `files` (each delivered size's
-#    local file by its label), so `| tail` keeps them.
+#    stdout is the compact JSON result alone, success or failure: `review`, `hints`, then
+#    `verdict` (static ads), `run_id` and `files` (each delivered size's local file by its
+#    label). Progress lines (`[exec]`, `[warn]`, …) go to stderr. --full adds the per-node
+#    `output`, `stats`, `outputs_dir`, the judge's scores and the full guide in `hints` (by
+#    default `hints` is the next step and the guide is on stderr as `[hint]` lines); on `validate` it adds
+#    `cost_preview`, the projections and `normalized_paths`.
 #    A failed run reports `error.code: "input_invalid"` when the backend refused a node's
 #    own input (it fails the same way until the input changes), `"runtime"` otherwise.
 
@@ -6805,12 +6810,12 @@ Cache policies (via `--cache-policy`):
 
 #### `baker canvas validate <file.json>`
 
-Parse + schema-check + per-node deep validation (composition `meta.json` is consulted for `hyperframe_*`). Prints a structured result with a per-node cost preview. Exits non-zero on issues. Never calls Convex, never spends credits.
+Parse + schema-check + per-node deep validation (composition `meta.json` is consulted for `hyperframe_*`). Prints a compact result (`ok`, `total_nodes`, `estimated_credits`, `canvas_updated`, `warnings`); `--full` adds the per-node cost preview (`cost_preview`), the projections and `normalized_paths`. Exits non-zero on issues. Never calls Convex, never spends credits.
 
 **The canvas file is brought up to date first.** Parts of a creative's canvas are projections of its blueprint: each video scene's frame and clip prompts (from `scenes/sNN.json`), a static ad's render prompts, judge criteria and type specimen (compiled from the ad spec in `prompt.json`), and the derived style file the frames read (`prompt.style.json`). `validate`, `run`, `critique` and `set-prompt` share one preflight that applies every projection and **writes the result back to the canvas file** (only when something changed; `canvas_updated` says so; `sync-definition`, which the file watcher runs over every creative, applies it without writing), so the file on disk, the graph the dashboard shows, the graph the critic scores and the graph that renders are the same. A scene edit that changes timing or the number of scenes is structural and still asks for a re-scaffold. Every preflight failure prints `{ ok: false, error: { code, message, fix? } }` and exits 2.
 
 ```bash
-$ baker canvas validate my-canvas.json
+$ baker canvas validate my-canvas.json --full
 {
   "ok": true,
   "total_nodes": 4,
@@ -6826,14 +6831,14 @@ On error you get `{ ok: false, error: { code: "validation", issues } }`, each is
 
 **Absolute asset paths are healed, not reported.** A `source: "path"` ingest (or a `hyperframe_render`
 composition) written as an absolute path inside the workspace is rewritten to its canvas-relative form
-and the canvas file is saved, before anything else reads it. `normalized_paths` lists what changed.
+and the canvas file is saved, before anything else reads it. `validate --full` lists what changed as `normalized_paths`.
 `run` does the same and logs it. This is not cosmetic: an absolute path resolves in the Runtime that
 wrote it, so validate, run, and the preview all pass, and only the publish build — a different checkout
 root, a different session — ever sees the break.
 
 **A URL in an ingest's `path` is healed the same way.** A `source: "path"` ingest whose `path` is an
 http(s) URL already runs as `source: "url"`; `validate` and `run` rewrite the file to say so
-(`normalized_paths` lists it as `{ param: "source", from: "path", to: "url" }`), so the commit gate,
+(`validate --full` lists it in `normalized_paths` as `{ param: "source", from: "path", to: "url" }`), so the commit gate,
 which reads the file, agrees with what rendered.
 
 Two roots count as "this workspace": the current one, and `/home/user/repo` (`REPO_PATH`), the fixed path
@@ -6891,7 +6896,7 @@ $ baker canvas viewer-check club-whiteboard
 
 #### `baker canvas run <file.json> [flags]` / `baker canvas run --slug <slug> [flags]`
 
-Validate, then execute the graph. Blocks until done. Logs one line per node. Returns `{ ok, run_id, outputs_dir, output, stats }` on stdout.
+Validate, then execute the graph. Blocks until done. Logs one line per node on stderr. Prints one compact JSON result alone on stdout: `{ ok, review?, hints?, verdict?, run_id, files }`; `--full` adds `outputs_dir`, `output`, `stats` and `judge`, and the full guide in `hints`.
 
 `--slug <slug>` runs a creative by name instead of by file: its `src/creatives/<slug>/<slug>.canvas.json` when this workspace has it, else its files restored from the newest run that recorded a portable snapshot (sha-verified, into `src/creatives/<slug>/`), then the normal run flow. Local files are never overwritten unless `--force-remote` is passed. This replaces `baker canvas rerun <slug>`, which still works as a deprecated alias.
 
@@ -6913,6 +6918,7 @@ A completed render the review calls ready (`verdict` `ready` or `ready_with_note
 | `--skip-viewer-check` | off | Static ad only: render without the viewer check (`baker canvas viewer-check`), when the person heard what the viewer would miss and wants the copy as it is. |
 | `--remote-cache <on\|off>` | `on` (or `BAKER_CANVAS_REMOTE_CACHE`) | Operator only. Company-scoped remote cache + durable asset persistence. |
 | `--no-record` | records | Skip posting the durable run-history record (and its live progress). |
+| `--full` | off | Also print the per-node `output`, `stats`, `outputs_dir`, the judge's scores and the full guide in `hints` (without it, the guide is on stderr as `[hint]` lines). |
 | `--until frames` | none | Stop before the clips with the frames settled; the run is recorded as `awaiting_approval` (not failed, not interrupted) and resumes with `--run-id`. |
 | `--cache-dir <path>` | `<workspace root>/canvas/.cache` | Operator only. Where content-addressed bytes + cache index live. |
 | `--outputs-dir <path>` | `<workspace root>/canvas` | Operator only. Root for per-run output directories. |
@@ -6924,7 +6930,7 @@ 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); 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: 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 logo the model drew that the review rejects again on a size after a correction (an earlier round of the same run, or the `--fix` this run was) is not drawn a third time: the creative's canvas is moved onto the brand's logo file (a `static_logo` on every size), the chosen picture is corrected to drop its drawn logo (on one picture, every size's words are set again with the slot kept plain), and `src/brand/tokens.json` records `"logoPlacement": "composite"`, so `scaffold-static-ad` and `baker creatives make` start that brand's later ads with the file placed. 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 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).
 
@@ -7055,7 +7061,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 (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.
+**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`), the findings as `review` and the next step as `hints`; `--full` adds `judge` (the per-candidate scores) and prints the full guide in `hints`, ending with what the run made (without it, the guide is on stderr as `[hint]` lines); 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.
 
@@ -7177,7 +7183,7 @@ baker canvas catalog --category audio --full
 { "id": "src", "type": "ingest", "params": { "source": "url", "url": "https://media.withbaker.com/canvas-assets/5b/5b50…c672.mp3", "expect": "audio" } }
 ```
 
-**Never point `path` into `canvas/`.** `canvas/.cache/` and `canvas/r_<id>/` are the engine's own working folder and are never committed, so a canvas that reads from them renders only where it was written. `canvas validate` and `canvas run` rewrite such a path to the durable URL of the same bytes (reported under `normalized_paths`), keeping the file first if the store does not hold it yet.
+**Never point `path` into `canvas/`.** `canvas/.cache/` and `canvas/r_<id>/` are the engine's own working folder and are never committed, so a canvas that reads from them renders only where it was written. `canvas validate` and `canvas run` rewrite such a path to the durable URL of the same bytes (`validate --full` reports it under `normalized_paths`), keeping the file first if the store does not hold it yet.
 
 **Strategy resolution** (deterministic from `source` + `expect` + URL extension for text):
 

package/dist/account-EXGRZIXS.js

@@ -0,0 +1,82 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-H4RHZJ65.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-MPTNN35I.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-HPF3USL2.js";
+import "./chunk-6DSPB6YA.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-IMS53EQU.js";
+import {
+  apiGet
+} from "./chunk-LJEJCIHR.js";
+import "./chunk-SIRRBWQ2.js";
+import "./chunk-B64KJW5C.js";
+import "./chunk-NXNOXZGB.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/account.ts
+import { defineCommand } from "citty";
+var accountDetailCommand = defineCommand({
+  meta: {
+    name: "detail",
+    description: `Single LinkedIn ad account detail (currency, status, type).
+
+Examples:
+  baker ads linkedin account --account-id 503001492
+  baker ads linkedin account --account-urn urn:li:sponsoredAccount:503001492 --output md`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+    "account-urn": { type: "string", description: "Alias for --account-id" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/account", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput([data], fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var accountCommand = defineCommand({
+  meta: {
+    name: "account",
+    description: `LinkedIn ad account: its detail, and the settings that apply across every ad set in it.
+
+Examples:
+  baker ads linkedin account --account-id 503001492                          \u2014 currency, status, type
+  baker ads linkedin account url-params --param utm_source=linkedin          \u2014 UTMs for every ad in the account`
+  },
+  subCommands: {
+    detail: accountDetailCommand,
+    "url-params": () => import("./write-commands-V7B4FBMX.js").then((m) => m.accountUrlParamsCommand)
+  },
+  args: accountDetailCommand.args,
+  default: "detail"
+});
+export {
+  accountCommand
+};
+//# sourceMappingURL=account-EXGRZIXS.js.map

package/dist/account-JVDP5ERG.js

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

package/dist/account-NSBALYYS.js

@@ -0,0 +1,139 @@
+import {
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-4HFM5RCP.js";
+import "./chunk-QALAJNBG.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-MPTNN35I.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-HPF3USL2.js";
+import {
+  apiGet
+} from "./chunk-LJEJCIHR.js";
+import "./chunk-SIRRBWQ2.js";
+import "./chunk-B64KJW5C.js";
+import "./chunk-NXNOXZGB.js";
+import "./chunk-YQSBHWOI.js";
+
+// ../api/src/ads-meta/accountHealth.ts
+var ACCOUNT_STATUS = {
+  1: "ACTIVE",
+  2: "DISABLED",
+  3: "UNSETTLED",
+  7: "PENDING_RISK_REVIEW",
+  8: "PENDING_SETTLEMENT",
+  9: "IN_GRACE_PERIOD",
+  100: "PENDING_CLOSURE",
+  101: "CLOSED",
+  201: "ANY_ACTIVE",
+  202: "ANY_CLOSED"
+};
+var DISABLE_REASON = {
+  1: "ads integrity policy",
+  2: "ads IP review",
+  3: "payment risk",
+  4: "gray account shut down",
+  5: "ads AFC review",
+  6: "business integrity review",
+  7: "permanently closed",
+  8: "unused reseller account",
+  9: "unused account",
+  10: "umbrella ad account",
+  11: "Business Manager integrity policy",
+  12: "misrepresented ad account",
+  13: "legal entity de-share",
+  14: "thread review",
+  15: "compromised ad account"
+};
+var DELIVERS_ANYWAY = /* @__PURE__ */ new Set([1, 9]);
+function statusBlocker(account) {
+  const status = account.account_status;
+  if (status === void 0 || status === 1) return void 0;
+  const name = ACCOUNT_STATUS[status] ?? `status ${status}`;
+  const reason = account.disable_reason ? DISABLE_REASON[account.disable_reason] : void 0;
+  const why = reason ? ` (${reason})` : "";
+  if (DELIVERS_ANYWAY.has(status)) {
+    return `the ad account is ${name}${why}: a payment failed and Meta stops delivery when the grace period ends \u2014 the account owner settles it in Meta Billing`;
+  }
+  return `the ad account is ${name}${why}, so nothing on it delivers \u2014 only the account owner can resolve that with Meta (Account Quality / Billing)`;
+}
+function metaAccountDeliveryBlockers(account) {
+  const blockers = [];
+  const status = statusBlocker(account);
+  if (status) blockers.push(status);
+  const hasFunding = Boolean(account.funding_source || account.funding_source_details?.id);
+  if (!hasFunding && !account.is_prepay_account) {
+    blockers.push(
+      "the ad account has no payment method, so Meta accepts its ads but delivers none (they wait in PENDING_BILLING_INFO) \u2014 the account owner adds one in Meta Billing"
+    );
+  }
+  if (spendCapReached(account)) {
+    blockers.push(
+      "the ad account has reached its spending limit, so Meta stops delivering every ad on it \u2014 an admin raises or removes the limit in Meta Billing \u2192 Payment settings, or Baker can change it as part of a chat"
+    );
+  }
+  return blockers;
+}
+function spendCapReached(account) {
+  const cap = Number(account.spend_cap ?? "0");
+  const spent = Number(account.amount_spent ?? "0");
+  return Number.isFinite(cap) && Number.isFinite(spent) && cap > 0 && spent >= cap;
+}
+
+// src/commands/ads/meta/account.ts
+import { defineCommand } from "citty";
+var accountCommand = defineCommand({
+  meta: {
+    name: "account",
+    description: `Show single Meta ad account detail (currency, timezone, balance, business) and whether it can deliver:
+a hint names a disabled account or a missing payment method, which Meta never refuses at publish \u2014 its ads just never run.
+\`bakerPermissions\` says which per-company Meta permissions (leadAds, catalog, pagePosts) are switched on for this
+company and held by the connection; a hint names any that still needs the user to reconnect Meta.
+
+Examples:
+  baker ads meta account --account-id act_123
+  BAKER_META_AD_ACCOUNT_ID=act_123 baker ads meta account`
+  },
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID (act_...)" },
+    "no-cache": NO_CACHE_ARG
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/meta/account", params);
+      const permissionHints = data.bakerPermissions ? accountPermissionHints(data.bakerPermissions) : [];
+      writeJsonEnvelope({ ok: true, data, hints: [...accountDeliveryHints(data), ...permissionHints] });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+function accountDeliveryHints(account) {
+  const blockers = metaAccountDeliveryBlockers(account);
+  if (blockers.length === 0) return ["The account can deliver: it is active and has a payment method."];
+  return [
+    ...blockers.map((blocker) => `Cannot deliver: ${blocker}.`),
+    "Staging still works and publishing still applies the changes, but nothing serves until this is fixed \u2014 tell the user before they publish anything they expect to run."
+  ];
+}
+var PERMISSION_LABEL = {
+  leadAds: "Lead ads (instant forms and their leads)",
+  catalog: "Catalog changes",
+  pagePosts: "Facebook Page posts"
+};
+function accountPermissionHints(permissions) {
+  return Object.keys(PERMISSION_LABEL).filter((key) => permissions[key].reconnectNeeded).map(
+    (key) => `${PERMISSION_LABEL[key]}: switched on for this company, but this Meta connection predates it \u2014 ask the user to reconnect Meta in the dashboard before relying on it.`
+  );
+}
+export {
+  accountCommand,
+  accountDeliveryHints,
+  accountPermissionHints
+};
+//# sourceMappingURL=account-NSBALYYS.js.map