@koda-sl/baker-cli 0.444.0-dev.cac1750ec → 0.447.0-dev.397af7869

package/README.md

@@ -1817,7 +1817,7 @@ baker creatives learn [--days <n>] [--dry-run]                 # what each idea'
 - `brief` returns a verdict, not raw numbers: `account.bottleneck` is `hook`, `after_click`, `none` or `too_little_data`. A part that cannot be read says `unavailable`. `market` says what competitors' ads already say (the followed brands, else the library), how sophisticated the market is, and which awareness stages nobody speaks to.
 - `ideas` is free and local. An idea's `evidence` resolves to `src/content/insights/` entries, or it is an `explore` bet. Numbers must be in the Knowledge or our own customers' quotes (a Reddit, forum or web quote never sources a claim), no two ideas may share an angle and format, and a review or testimonial format needs a quote from our own customer.
 - `learn` pools each built idea's creatives, judges them against the rest of the account's cost per result and writes `status` (`winner`, `failed`, `inconclusive`, `testing`) and a frozen `result` onto the idea. `ideas` then warns when a new idea repeats a failed one.
-- `make` builds one idea. A static searches the idea's container for ads made for our viewer, checks the closest three with `winning-ads fit` and scaffolds from the first that fits. A video idea takes its beats spec. Either way it records the idea on `_definition.md`, sets `prompt.json`'s `message` and syncs the definition. Drafted copy lines claiming a figure the company never wrote come back first in `hints`. When no proven ad fits (or with `--from-idea`), a static starts from the idea itself: `prompt.json` holds the message and placeholders, and `canvas run` refuses to render until the scene and copy are written.
+- `make` builds one idea. A static searches the idea's container for ads made for our viewer, checks the closest three with `winning-ads fit` and scaffolds from the first that fits. For a new creative it starts scaffolding the best-ranked one while the fits are asked (kept when it fits, removed whole when another is kept), so the reference's describe pass no longer waits for them. A video idea takes its beats spec. Either way it records the idea on `_definition.md`, sets `prompt.json`'s `message` and syncs the definition. Drafted copy lines claiming a figure the company never wrote come back first in `hints`. When no proven ad fits (or with `--from-idea`), a static starts from the idea itself: `prompt.json` holds the message and placeholders, and `canvas run` refuses to render until the scene and copy are written.
 
 ### Competitive Intelligence (`baker research`)
 
@@ -5833,7 +5833,7 @@ cart, a trial, a donation, a registration); who it is for is reported but never
 `_definition.md`, else the one its `targetAdSet` reaches (as `baker ads meta adsets --audience` reads it), else
 the persona and `awareness` from the Knowledge, else a cold stranger. Not understood → exit 2 with
 `viewer_check_failed` and a `fix` that starts with the one rewrite answering a missed offer (`Do this: make the biggest words say "<message>"`) and names what the viewer missed. After two failures of one ad in a chat turn the check no longer holds it back: the command answers `ok: true` with `understood: false` and what was missed, and `baker canvas run` renders it, printing the miss. The casting check is asked alongside the viewer. Answers are cached per copy, scene and viewer.
-`baker canvas run` makes the same check on a static ad before it spends (skipped for `--fix`, an autofix round, `--use-variant`, a re-layout and resumed runs, never for an edit of the words;
+Before either, a static ad whose scene quotes words, or names a price or a share, that the copy (or `scene_text`) does not hold is refused (`scene_words_not_in_copy`): the picture would print them and a correction round would erase them. An unreadable `prompt.json` names each wrong field in a line and shows that field's shape. `baker canvas run` makes the same check on a static ad before it spends (skipped for `--fix`, an autofix round, `--use-variant`, a re-layout and resumed runs, never for an edit of the words;
 `--skip-viewer-check` renders without it; a model outage lets the render through with a warning). `--full` adds
 the viewer's whole answer and how the viewer was chosen.
 
@@ -5879,7 +5879,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 2 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 only the margins that leaves and lays the ad's own pixels back over the painting, 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 is laid out again instead); a defect the spec asked for (a second subject, stars with no named source, a concept that does not read) and any defect of a native screen corrects the spec first (`static-spec-repair.ts`: a model rewrites `prompt.json` for those findings alone, every line of the copy kept word for word), then draws the ad again from it (a native screen redraws free); a picture wrong as a whole or in three places or more is made again from its brief, told what the last one got wrong, but only in a round with another after it unless the brief caused the defect; anything else on the picture is a `--fix` of the chosen picture for its own findings (`correctionOf`: the words to erase, the line to re-letter or add), naming what the last edit was already asked for, while each re-laid size the review flagged follows as an edit of its own last layout (`withSizesFollowingFix`), keeping what an earlier round fixed in it, and a size it found nothing blocking on is delivered as it was (`keep`, nothing in it made again or placed); anything else on a re-laid size alone edits just that size from its own last layout (`withRelayEdit`). 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 round is one render (a fix, or one request per re-laid size) and prints `[autofix] round N of 2: …` 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 2 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 only the margins that leaves and lays the ad's own pixels back over the painting, 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 is laid out again instead); a defect the spec asked for (a second subject, stars with no named source, a concept that does not read) and any defect of a native screen corrects the spec first (`static-spec-repair.ts`: a model rewrites `prompt.json` for those findings alone, every line of the copy kept word for word), then draws the ad again from it (a native screen redraws free); a picture wrong as a whole or in three places or more is made again from its brief, told what the last one got wrong, but only in a round with another after it unless the brief caused the defect; anything else on the picture is a `--fix` of the chosen picture for its own findings (`correctionOf`: the words to erase, the line to re-letter or add), naming what the last edit was already asked for, while each re-laid size the review flagged follows as an edit of its own last layout (`withSizesFollowingFix`), keeping what an earlier round fixed in it, and a size it found nothing blocking on is delivered as it was (`keep`, nothing in it made again or placed); anything else on a re-laid size alone edits just that size from its own last layout (`withRelayEdit`); sizes that do not show the same ad (`SIZES:`) are always the re-laid ones' fault, since every size follows the chosen picture, so they are laid out again to show exactly what it shows, never the picture edited to match them. A size a round did not touch (its file the same byte for byte) keeps the round before's verdict (`carryUnchanged`) and is not read again: the review reads only the sizes the round changed. Each round is one render (a fix, or one request per re-laid size) and prints `[autofix] round N of 2: …` 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; it replaces the variants and the judge, and every size is made again from the corrected picture. **A `prompt.json` changed only in its words, their positions or its colours** since the version shown is made the same way, as an edit of that version (`[edit]` in the output, the instruction read off the change); three new options are asked for only with `--regenerate static_variants`. A `--fix` whose defect is still blocking afterwards is recorded, and asking for it again with the same words exits 2 with `no_progress`. When every blocking finding is on re-laid-out sizes, the first hint says to lay out those sizes again (`--regenerate adapt_<size>`) before any `--fix`. Every static run's hints say what it cost in credits and what for. There is no render limit per creative. Use another variant with `--use-variant <sha256>` (`--from <run_id>`, default the last render): when the person chose another of a version's variants over the judge's pick, every size is made again from that picture, and the only requests re-lay it out for each other size; `--regenerate adapt_9x16` lays out one size again from the same chosen picture when only that size came out wrong (after a `--fix` or `--use-variant`, from that corrected or chosen picture, so the size never brings back the uncorrected one; `--from <run_id>` names another version); `baker creatives feedback --slug <slug>` prints the choice (`variantChoice`) and the exact command.
 

package/dist/{chunk-GY352NRN.js → chunk-WMAHVZMY.js}

@@ -3594,23 +3594,6 @@ function resolveConcurrency(...candidates) {
   }
   return DEFAULT_CONCURRENCY;
 }
-async function mapWithConcurrency(items, limit, fn) {
-  const results = new Array(items.length);
-  let next = 0;
-  const worker = async () => {
-    while (next < items.length) {
-      const index = next++;
-      try {
-        results[index] = { status: "fulfilled", value: await fn(items[index], index) };
-      } catch (reason) {
-        results[index] = { status: "rejected", reason };
-      }
-    }
-  };
-  const workers = Array.from({ length: Math.min(limit, items.length) }, worker);
-  await Promise.all(workers);
-  return results;
-}
 
 // src/engine/lib/json-walk.ts
 function isContainerObject(value) {
@@ -6931,6 +6914,49 @@ function unwrittenProblems(spec) {
   }
   return problems;
 }
+var QUOTED = /"([^"]{2,})"|“([^”]{2,})”|(?<![\p{L}\p{N}])['‘]([^'’]{2,}?)['’](?![\p{L}\p{N}])/gu;
+var FIGURE = /[£$€]\s?\d[\d.,]*|\d+(?:[.,]\d+)?\s?%/g;
+var comparable = (text2) => text2.normalize("NFD").replace(new RegExp("\\p{M}", "gu"), "").toLowerCase().replace(/[^\p{L}\p{N}£$€%]+/gu, " ").trim();
+function sceneWordProblems(spec) {
+  const held = [...spec.copy.map((l) => l.text), ...spec.scene_text].map(comparable);
+  const holds = (text2) => {
+    const want = comparable(text2);
+    return want.length === 0 || held.some((h) => h.includes(want));
+  };
+  const scene = [spec.scene.description, spec.scene.layout ?? ""].join(" ");
+  const quoted = [...scene.matchAll(QUOTED)].map((m) => (m[1] ?? m[2] ?? m[3] ?? "").trim()).filter((q) => !holds(q));
+  const figures = (scene.match(FIGURE) ?? []).map((f) => f.trim()).filter((f) => !holds(f));
+  const unheld = [.../* @__PURE__ */ new Set([...quoted, ...figures])];
+  if (unheld.length === 0) return [];
+  return [
+    `The scene asks the picture to show ${unheld.map((w) => `"${w}"`).join(", ")}, which the copy does not hold: the picture would print it and the run would then spend a round erasing it. Put each one the ad needs in \`copy\` as an \`in_scene\` line with \`on\` (the bill, the phone), or describe that surface without words (blank, blurred, face-down).`
+  ];
+}
+var FIELD_SHAPES = {
+  copy: '"copy": [{"text": "Book your free survey", "lettering": "designed", "role": "cta"}]',
+  scene: '"scene": {"description": "a family on a sunny roof terrace", "look": "photo"}',
+  colors: '"colors": [{"object": "the button", "name": "deep green", "hex": "#1F5C3A"}]',
+  references: '"references": [{"id": "PRODUCT_1", "role": "product", "what": "the solar panel kit"}]',
+  third_party_brands: '"third_party_brands": [{"name": "Trustpilot", "role": "proof", "logo": "BADGE_1"}]',
+  mechanism: '"mechanism": [{"device": "a before and after", "why_it_works": "the change is seen, not told"}]',
+  viewer: '"viewer": {"who": "homeowners with high energy bills", "knows": "nothing about us yet"}'
+};
+var SPEC_SHAPES_HINT = `prompt.json shapes: ${["copy", "colors", "viewer"].map((f) => FIELD_SHAPES[f]).join("; ")}.`;
+function adSpecErrorText(e) {
+  if (!(e instanceof z7.ZodError)) return e instanceof Error ? e.message : String(e);
+  const items = /* @__PURE__ */ new Map();
+  for (const issue of e.issues) {
+    const [field2, index, key] = issue.path;
+    const at2 = typeof index === "number" ? `${String(field2)}[${index}]` : issue.path.map(String).join(".") || "the spec";
+    const what = issue.code === "unrecognized_keys" ? `no field ${issue.keys.map((k) => `"${k}"`).join(", ")}` : key !== void 0 && typeof index === "number" ? `"${String(key)}" ${issue.message.replace(/^Invalid input: /, "")}` : issue.message.replace(/^Invalid input: /, "");
+    items.set(at2, [...items.get(at2) ?? [], what]);
+  }
+  const fields = [...new Set(e.issues.map((i) => String(i.path[0] ?? "")))].filter((f) => FIELD_SHAPES[f]);
+  return [
+    ...[...items].map(([at2, whats]) => `${at2}: ${[...new Set(whats)].join("; ")}`),
+    ...fields.map((f) => `Shape: ${FIELD_SHAPES[f]}`)
+  ].join("\n");
+}
 function readAdSpec(raw) {
   if (isAdSpec(raw)) return AdSpecSchema.parse(raw);
   const advertiser = raw?.reference?.advertiser;
@@ -10209,6 +10235,17 @@ function unwrap(schema) {
 }
 
 // src/engine/engine/executor.ts
+function throwRunOutcome(signal, failures, held) {
+  if (signal?.aborted) throw new RunAbortedError("signal", "run aborted by signal");
+  if (failures.length === 1 && failures[0]) throw failures[0].reason;
+  if (failures.length > 1) throw new LayerExecutionError([...failures]);
+  if (held.length > 0) {
+    throw new RunAbortedError(
+      "checkpoint",
+      `stopped before ${held.join(", ")} \u2014 everything up to here is done and cached, so continuing this run id pays for none of it again`
+    );
+  }
+}
 function heldByCheckpoint(canvas, layer, kinds) {
   if (!kinds?.size) return [];
   return layer.filter((id) => {
@@ -10297,45 +10334,61 @@ var Engine = class {
     return { run_id: runId, output, outputs_by_node: outputs, stats, outputs_dir: writer.runDir, node_runs: nodeRuns };
   }
   async runLayers(canvas, graph, outputs, runId, writer, opts, counters, nodeRuns, needsBytes) {
-    const layers = topologicalLayers(graph);
+    const order = topologicalLayers(graph).flat();
     const limit = resolveConcurrency(opts.concurrency);
-    for (const layer of layers) {
-      this.assertLayerMayRun(canvas, layer, opts);
-      const settled = await mapWithConcurrency(layer, limit, (nodeId) => {
-        if (opts.signal?.aborted) {
-          return Promise.reject(new RunAbortedError("signal", "run aborted before node dispatch"));
-        }
-        this.emitProgress(opts, { kind: "node_start", node_id: nodeId });
-        return this.executeOne(canvas, nodeId, outputs, runId, writer, opts, needsBytes.has(nodeId)).then((r) => {
-          if (r.cached) counters.cachedNodes++;
-          counters.totalCredits += r.credits;
-          const node = canvas.nodes.find((n) => n.id === nodeId);
-          if (node) {
-            const run = {
-              node_id: nodeId,
-              node_type: node.type,
-              cached: r.cached,
-              duration_ms: r.durationMs,
-              credits: r.credits
-            };
-            nodeRuns.push(run);
-            this.emitProgress(opts, { kind: "node_settled", run, outputs: outputs[nodeId] ?? {} });
-          }
-        });
-      });
-      const failures = [];
-      settled.forEach((result, i) => {
-        const nodeId = layer[i];
-        if (result.status === "rejected" && nodeId) {
-          if (result.reason instanceof RunAbortedError) return;
-          failures.push({ nodeId, reason: result.reason });
-          this.emitProgress(opts, { kind: "node_failed", node_id: nodeId, error: failureDetail(result.reason) });
+    if (opts.signal?.aborted) throw new RunAbortedError("signal", "run aborted before dispatch");
+    const waitingOn = new Map(order.map((id) => [id, new Set(graph.get(id) ?? [])]));
+    const running = /* @__PURE__ */ new Map();
+    const failures = [];
+    const held = [];
+    const dispatch = (nodeId) => {
+      waitingOn.delete(nodeId);
+      this.emitProgress(opts, { kind: "node_start", node_id: nodeId });
+      const settled = this.executeOne(canvas, nodeId, outputs, runId, writer, opts, needsBytes.has(nodeId)).then(
+        (r) => {
+          this.recordRun(canvas, nodeId, r, counters, nodeRuns, outputs, opts);
+          for (const deps of waitingOn.values()) deps.delete(nodeId);
+        },
+        (reason) => {
+          failures.push({ nodeId, reason });
+          this.emitProgress(opts, { kind: "node_failed", node_id: nodeId, error: failureDetail(reason) });
         }
-      });
-      if (opts.signal?.aborted) throw new RunAbortedError("signal", "run aborted by signal");
-      if (failures.length === 1 && failures[0]) throw failures[0].reason;
-      if (failures.length > 1) throw new LayerExecutionError(failures);
+      );
+      running.set(
+        nodeId,
+        settled.finally(() => running.delete(nodeId))
+      );
+    };
+    const isHeld = (nodeId) => heldByCheckpoint(canvas, [nodeId], opts.stop_before_kinds).length > 0;
+    for (; ; ) {
+      const ready = opts.signal?.aborted ? [] : order.filter((id) => waitingOn.get(id)?.size === 0);
+      for (const nodeId of ready) {
+        if (running.size >= limit) break;
+        if (isHeld(nodeId)) {
+          waitingOn.delete(nodeId);
+          held.push(nodeId);
+        } else dispatch(nodeId);
+      }
+      if (running.size === 0) break;
+      await Promise.race(running.values());
     }
+    throwRunOutcome(opts.signal, failures, held);
+  }
+  /** A settled node counted, recorded and announced. */
+  recordRun(canvas, nodeId, r, counters, nodeRuns, outputs, opts) {
+    if (r.cached) counters.cachedNodes++;
+    counters.totalCredits += r.credits;
+    const node = canvas.nodes.find((n) => n.id === nodeId);
+    if (!node) return;
+    const run = {
+      node_id: nodeId,
+      node_type: node.type,
+      cached: r.cached,
+      duration_ms: r.durationMs,
+      credits: r.credits
+    };
+    nodeRuns.push(run);
+    this.emitProgress(opts, { kind: "node_settled", run, outputs: outputs[nodeId] ?? {} });
   }
   /** Progress consumers are observers only — an exception there must never fail the run. */
   emitProgress(opts, event) {
@@ -10427,20 +10480,6 @@ var Engine = class {
     this.logOutputWarnings(node.id, outputsObj);
     return { cached: false, credits, durationMs: elapsed };
   }
-  /**
-   * Every reason a layer must not dispatch, checked before any of its nodes starts, so a stop
-   * never leaves a layer half billed: a signal, the cost cap and a checkpoint.
-   */
-  assertLayerMayRun(canvas, layer, opts) {
-    if (opts.signal?.aborted) throw new RunAbortedError("signal", "run aborted before layer dispatch");
-    const held = heldByCheckpoint(canvas, layer, opts.stop_before_kinds);
-    if (held.length > 0) {
-      throw new RunAbortedError(
-        "checkpoint",
-        `stopped before ${held.join(", ")} \u2014 everything up to here is done and cached, so continuing this run id pays for none of it again`
-      );
-    }
-  }
   /** A cache hit replayed as this node's result: its outputs written, and free. */
   async replayCached(node, cacheKey, outputs, writer) {
     const cacheT0 = Date.now();
@@ -15710,7 +15749,7 @@ function contextItems(opts) {
       opts.thumbnails ? "7. THUMBNAIL: at thumbnail size the lead line (the largest words) cannot be read. Judge only whether those words can be read, nothing else. That is blocking: most people only ever see the ad that small." : "7. THUMBNAIL: the lead line (the largest words) would be unreadable on a phone feed. That is blocking."
     ],
     sizes: opts.formats.length > 1 ? [
-      "12. SIZES: one size loses what the others are built on: the letter sheet, the email or chat window, the post card, the comic's panels and their order, the product the ad is about (blocking). Rearranged for its shape is fine."
+      `12. SIZES: one size loses what the others are built on: the letter sheet, the email or chat window, the post card, the comic's panels and their order, the product the ad is about, or a size that shows something the others do not (blocking; start the finding with "SIZES:" and report it on the size that differs). Rearranged for its shape is fine.`
     ] : []
   };
 }
@@ -18488,6 +18527,9 @@ export {
   conceptSummary,
   conceptProblems,
   unwrittenProblems,
+  sceneWordProblems,
+  SPEC_SHAPES_HINT,
+  adSpecErrorText,
   readAdSpec,
   withRenderedLettering,
   conceptClassOf,
@@ -18575,4 +18617,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-GY352NRN.js.map
+//# sourceMappingURL=chunk-WMAHVZMY.js.map