@koda-sl/baker-cli 0.569.0 → 0.570.0

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. |
@@ -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-52WDLW4Z.js

@@ -0,0 +1,82 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptRead
+} from "./chunk-H7LKYGLJ.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-3BJSUM2V.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-52WDLW4Z.js.map

package/dist/account-7KZ7MHMN.js

@@ -0,0 +1,82 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-CDPX6WAL.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-MPTNN35I.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-HPF3USL2.js";
+import "./chunk-2Q7K4F4H.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-XHWHBGKX.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-R42DQEW6.js").then((m) => m.accountUrlParamsCommand)
+  },
+  args: accountDetailCommand.args,
+  default: "detail"
+});
+export {
+  accountCommand
+};
+//# sourceMappingURL=account-7KZ7MHMN.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