@koda-sl/baker-cli 0.551.0 → 0.554.0

package/dist/make-365ZJ25L.js

@@ -0,0 +1,1367 @@
+import {
+  scaffoldDelivery
+} from "./chunk-JBMZVC5D.js";
+import {
+  buildSearchBody
+} from "./chunk-LK5OKVCM.js";
+import "./chunk-DEZBCK5P.js";
+import "./chunk-RIVHJC6L.js";
+import {
+  NO_FIT_HINT,
+  conceptFromFit,
+  fitReference,
+  notADesignReference,
+  pictureOf,
+  resolveSourcePlatform
+} from "./chunk-BRNZMKO4.js";
+import {
+  makeSeriesAd,
+  seriesMadeEnvelope
+} from "./chunk-IBBGABK2.js";
+import {
+  runBaker
+} from "./chunk-FSEFZZ2T.js";
+import "./chunk-OIORUNKH.js";
+import "./chunk-IZROFBH7.js";
+import {
+  parseDefinitionDelivery,
+  parseDefinitionSourceFields,
+  platformsNamedIn,
+  projectAdaptBriefs,
+  projectFormatBriefs,
+  projectStaticBriefs,
+  recordedShape,
+  reroutedOnSpec,
+  thinkingOutline,
+  withThinking
+} from "./chunk-QFVZIQRQ.js";
+import "./chunk-NE3OMP7R.js";
+import {
+  storeProductReads
+} from "./chunk-QFODAMYR.js";
+import "./chunk-EKX37C3T.js";
+import {
+  audienceQuery,
+  definitionFieldsOf,
+  fitBetOf,
+  fitsIdea,
+  freshReferencesFirst,
+  ideaSpec,
+  isOwnBrand,
+  isTakenReference,
+  isVideoIdea,
+  missingElements,
+  personaWho,
+  pooledCandidates,
+  rankedForOf,
+  referenceSearchesFor,
+  referenceWhereOf,
+  setDefinitionFields,
+  setSpecMessage,
+  setSpecViewer,
+  unsourcedCopyLines,
+  whyUnfit,
+  withFitConcept
+} from "./chunk-X3YYZLBH.js";
+import {
+  IDEAS_DIR,
+  coverageOf,
+  readCreativeRecords,
+  readIdeas,
+  readInsights,
+  readKnowledgeCorpus,
+  readPersonaIds
+} from "./chunk-XXBP73RV.js";
+import {
+  liveViewerLookups,
+  readPersonas
+} from "./chunk-5AOTCCTT.js";
+import "./chunk-2RL2T5JO.js";
+import {
+  castInventory,
+  companyName
+} from "./chunk-SP3MHBME.js";
+import "./chunk-PGAYESXE.js";
+import {
+  avoidOf,
+  memeRegister,
+  readCompanyReading,
+  readCreativeContext
+} from "./chunk-B5UVOCYA.js";
+import {
+  checkIdeas,
+  sourcesClaims
+} from "./chunk-UKZKLXTE.js";
+import "./chunk-OKXLOLEV.js";
+import "./chunk-LFELUKCA.js";
+import "./chunk-TGT4XHLX.js";
+import "./chunk-G6XKD7QE.js";
+import "./chunk-4H6XLX7E.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-Y3SK6EMU.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-XB4NKZAQ.js";
+import "./chunk-J5UTL4HE.js";
+import "./chunk-5NLUTJCQ.js";
+import "./chunk-GWLP45WQ.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-6QINKM6T.js";
+import {
+  SPEC_SHAPES_HINT,
+  decisionOf,
+  isVital,
+  readAdSpec,
+  unwrittenProblems
+} from "./chunk-H3HA22Z3.js";
+import {
+  askAboutImages,
+  askAboutText
+} from "./chunk-DLM5OSHM.js";
+import "./chunk-MCJ5I5LR.js";
+import {
+  describeMarket,
+  marketFromCompanyDoc,
+  viewerFromKnowledge
+} from "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import {
+  askJevQuestions
+} from "./chunk-E56V3RFO.js";
+import "./chunk-ZANXEMON.js";
+import "./chunk-G6U45QD3.js";
+import "./chunk-4ULGRGBG.js";
+import "./chunk-RCNAKWK7.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-MSMTG6OC.js";
+import {
+  apiPost
+} from "./chunk-GFWWHCBF.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/make.ts
+import { mkdir as mkdir2, mkdtemp, readdir, readFile as readFile2, rm, stat, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import path2 from "path";
+import { defineCommand } from "citty";
+
+// src/commands/creatives/reference-brief.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var text = z.string().transform((s) => s.trim()).pipe(z.string().min(1)).optional().catch(void 0);
+var shortList = (max) => z.array(z.string()).transform(
+  (list) => list.map((s) => s.trim()).filter(Boolean).slice(0, max)
+).catch([]);
+var BriefSchema = z.object({
+  category: text,
+  industry: text,
+  audience: text,
+  buyer: z.enum(["consumer", "small_business", "enterprise"]).optional().catch(void 0),
+  country: z.string().transform((s) => s.trim().toUpperCase()).pipe(z.union([z.literal("").transform(() => null), z.string().regex(/^[A-Z]{2}$/)])).optional().catch(void 0),
+  humour: z.enum(["fits", "risky", "off_brand"]).optional().catch(void 0),
+  avoid: shortList(5),
+  brands: shortList(4),
+  wider: shortList(4),
+  shows: shortList(2)
+});
+function parseReferenceBrief(reply) {
+  const parsed = BriefSchema.safeParse(reply);
+  if (!parsed.success || !parsed.data.category) return null;
+  const { category, avoid, brands, wider, shows, ...rest } = parsed.data;
+  const known = Object.fromEntries(Object.entries(rest).filter(([, v]) => v !== void 0));
+  return { category, ...known, avoid, brands, wider, ...shows.length > 0 ? { shows } : {} };
+}
+var REFERENCE_BRIEF_MODEL = "google/gemini-3.5-flash-lite";
+var REFERENCE_BRIEF_REQUEST = {
+  provider: { order: ["google-vertex"], allow_fallbacks: false },
+  seed: 0,
+  temperature: 0,
+  response_format: { type: "json_object" }
+};
+var REFERENCE_BRIEF_TIMEOUT_MS = 2e4;
+var MAX_COMPANY_CHARS = 12e3;
+function referenceBriefPrompt(companyDoc, ad) {
+  return `You prepare a search of a library of proven ads (Meta, LinkedIn, TikTok, Google) for the ad below. The library's search reads short English phrases the way it files ads: by what the ad sells, its industry and who it is for.
+
+The company (its own notes):
+"""
+${companyDoc.slice(0, MAX_COMPANY_CHARS)}
+"""
+
+The ad we are making:
+- Says: ${ad.message}
+- For: ${ad.who}${ad.shows ? `
+- Shows first: ${ad.shows}` : ""}
+
+Answer only JSON:
+{
+ "category": "what THIS ad sells, 2-6 plain English words a library would file it under, no brand names (e.g. 'electrician training course', 'pet health insurance', 'ecommerce customer service AI')",
+ "industry": "the broader industry, 1-3 English words (e.g. 'vocational education', 'insurance', 'customer service software')",
+ "audience": "who the ad is for and the problem they have, 4-9 plain English words (e.g. 'unemployed adults looking for a stable trade')",
+ "wider": ["4 library searches of 2-6 English words that widen from this ad, closest first, for when ads of exactly this product are few. 1: an adjacent product the same buyer weighs (e.g. 'tennis court construction'). 2: the same buyer buying something else (e.g. 'gym and sports club owners'). 3 and 4: the same kind of decision with NO word of this product's category, as other industries sell it (e.g. for a padel-court builder: 'turnkey franchise investment', 'commercial real estate investment'; for an acne serum: 'skincare before and after'). Never brand names"]${ad.shows ? `,
+ "shows": ["2 library searches of 6-14 English words for the KIND of picture 'Shows first' describes, the way the library describes an ad's visual: the device and what it contrasts or proves, with no word of this product, no numbers and no brand (e.g. for 'a calendar strip, 9 days green against 31 grey': 'time comparison graphic: the usual long wait against a much shorter one', 'two bars side by side, ours far shorter than the competition'; for 'a phone with missed calls next to a quote': 'phone screen full of missed calls and notifications, the stress of chasing')"]` : ""}
+}`;
+}
+var askBriefModel = (root) => async (prompt) => {
+  const spent = [];
+  const answer = await askAboutText(REFERENCE_BRIEF_MODEL, prompt, (u) => spent.push(u), {
+    timeoutMs: REFERENCE_BRIEF_TIMEOUT_MS,
+    request: REFERENCE_BRIEF_REQUEST
+  }).catch(() => null);
+  await holdUnbilledSpend(path.join(root, "canvas", ".cache"), spent).catch(() => void 0);
+  return answer;
+};
+var briefCachePath = (root, key) => path.join(root, "canvas", ".cache", "reference-brief", `${key}.json`);
+async function referenceBriefFor(root, ad, ask = askBriefModel(root)) {
+  const companyDoc = await readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => "");
+  const [company, own] = await Promise.all([readCompanyReading(root, ask), adBrief(root, companyDoc, ad, ask)]);
+  if (!own) return null;
+  const {
+    sells: _sells,
+    category: _category,
+    industry,
+    memes: _memes,
+    memes_why: _why,
+    ...facts
+  } = company ?? { brands: [] };
+  const register = memeRegister(company);
+  return {
+    ...facts,
+    ...register ? { memes: register.memes, ...register.why ? { memesWhy: register.why } : {} } : {},
+    ...own,
+    ...own.industry ?? industry ? { industry: own.industry ?? industry } : {},
+    brands: own.brands.length > 0 ? own.brands : facts.brands
+  };
+}
+async function adBrief(root, companyDoc, ad, ask) {
+  const prompt = referenceBriefPrompt(companyDoc, ad);
+  const file = briefCachePath(root, createHash("sha256").update(prompt).digest("hex").slice(0, 16));
+  const cached = await readFile(file, "utf8").then((raw) => parseReferenceBrief(JSON.parse(raw))).catch(() => null);
+  if (cached) return cached;
+  const brief = parseReferenceBrief(await ask(prompt));
+  if (!brief) return null;
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(brief, null, 2)}
+`, "utf8");
+  return brief;
+}
+
+// src/commands/creatives/reference-rank.ts
+var BUYERS = {
+  consumer: "people buying for themselves",
+  small_business: "small businesses buying for work",
+  enterprise: "large companies buying for work"
+};
+function memesLine(bet) {
+  return bet.memes === "off_brand" ? ` Our brand's voice does not run memes${bet.memesWhy ? ` (${bet.memesWhy})` : ""}: rank meme and reaction-face ads last.` : "";
+}
+function oursText(bet) {
+  const sells = `${bet.category}${bet.industry ? ` (${bet.industry})` : ""}`;
+  const buyer = bet.buyer ? `, to ${BUYERS[bet.buyer]}` : "";
+  const humour = bet.humour === "off_brand" ? " Our brand does not joke in ads." : "";
+  const avoid = bet.avoid?.length ? ` Our brand never uses: ${bet.avoid.join(", ")}.` : "";
+  const shows = bet.shows ? ` It shows: ${bet.shows}.` : "";
+  return `We sell: ${sells}${buyer}. Our ad says: "${bet.message}". It is for: ${bet.who}.${shows}${humour}${memesLine(bet)}${avoid}`;
+}
+function cardText(c) {
+  const d = c.dna ?? {};
+  const line = (label, value) => value ? `${label}: ${value}` : "";
+  return [
+    line("Advertiser", c.advertiser),
+    line("Industry", [d.industry, d.business_model].filter(Boolean).join(", ")),
+    line("Made for", d.target_persona),
+    line("Looks like", [d.container ?? c.format, d.visual].filter(Boolean).join(": ")),
+    line("Concept", d.creative_concept),
+    line("Why it works", d.mechanism)
+  ].filter(Boolean).join("\n").slice(0, 1400);
+}
+var QUESTIONS_PER_REQUEST = 60;
+var QUESTIONS = [
+  "Was `ad` made for the same kind of buyer as `ours`: a person buying for themselves, or a business buying for work, of a similar size?",
+  "Would the viewer `ours` is for feel that `ad` speaks to someone like them, about a problem like theirs?",
+  "Could the brand of `ours` run an ad made like `ad` (its look, its tone, its kind of hook) without breaking its own rules or looking out of character?"
+];
+var SHOWS_QUESTION = "Does `ad` show what `ours` shows (its `It shows:`), or the same kind of picture doing the same job, so that ours could be made in its image?";
+var REMADE_QUESTION = "Remade with the product, people and words of `ours`, would a picture made like `ad` speak to the viewer `ours` is for, about a problem like theirs?";
+function questionsFor(bet) {
+  return bet.shows ? [SHOWS_QUESTION, REMADE_QUESTION, QUESTIONS[2] ?? ""] : QUESTIONS;
+}
+async function rankForBet(candidates, bet, askOverride, onSpend) {
+  const ask = askOverride ?? ((questions2) => askJevQuestions(questions2, onSpend));
+  if (candidates.length < 2) return [...candidates];
+  const ours = oursText(bet);
+  const asks = questionsFor(bet);
+  const questions = candidates.flatMap(
+    (c) => asks.map((question) => ({ type: "noul", instructions: { ours, ad: cardText(c), question } }))
+  );
+  const parts = [];
+  for (let start = 0; start < questions.length; start += QUESTIONS_PER_REQUEST) {
+    parts.push(questions.slice(start, start + QUESTIONS_PER_REQUEST));
+  }
+  const replies = await Promise.all(parts.map((part) => ask(part).catch(() => null)));
+  if (replies.some((r, i) => !r || r.length !== parts[i]?.length)) return [...candidates];
+  const answers = replies.flatMap((r) => r ?? []);
+  const scored = candidates.map((c, i) => ({
+    c,
+    i,
+    score: asks.reduce((product, _, k) => {
+      const answer = answers[i * asks.length + k];
+      return product * (answer && "noul" in answer ? answer.noul : 0.5);
+    }, 1)
+  }));
+  return scored.sort((a, b) => b.score - a.score || a.i - b.i).map((s) => s.c);
+}
+
+// src/commands/creatives/reference-pick.ts
+var REFERENCE_PICK_MODEL = "~google/gemini-pro-latest";
+var REFERENCE_PICK_TIMEOUT_MS = 6e4;
+function vitalRead(fit) {
+  const vital = (fit.load_bearing ?? []).filter(isVital).map((l) => {
+    const ours = decisionOf(l) === "keep" ? "kept as it is" : l.ours?.trim() ? `ours: ${l.ours.trim()}` : "";
+    return `${l.job === "stop" ? "stops the scroll with" : "proof:"} ${l.element}${ours ? ` (${ours})` : ""}`;
+  });
+  return vital.length > 0 ? ` It ${vital.join("; ")}.` : "";
+}
+var TAKE_ELEMENTS = ["hook", "visual", "who_appears", "proof", "layout", "call_to_action"];
+function referencePickPrompt(options, bet) {
+  const reads = options.map((o, i) => {
+    const wins = Object.values(o.fit.why_it_wins ?? {}).filter(Boolean).join("; ");
+    const viewer = o.fit.our_viewer ? ` Our viewer: ${o.fit.our_viewer.stops}, ${o.fit.our_viewer.why}` : "";
+    return `${i + 1}. ${o.advertiser ?? "an advertiser"}: wins on ${wins || "(not read)"}.${vitalRead(o.fit)}${viewer}`;
+  }).join("\n");
+  const avoid = bet.avoid?.length ? ` The brand never uses: ${bet.avoid.join(", ").replace(/\.$/, "")}. Its rules forbid only what they name: "no stock photography" never rules out a meme's reaction face, our own people or our Avatars.` : "";
+  const humour = `${bet.humour === "off_brand" ? " The brand does not joke in ads." : ""}${memesLine(bet)}`;
+  return `Pick the proven ad our next ad should be built on. Images 1..${options.length} are proven ads of other advertisers, each already checked to be adaptable.
+
+We sell: ${bet.category}${bet.industry ? ` (${bet.industry})` : ""}. Our ad says: "${bet.message}". It is for: ${bet.who}.${bet.shows ? ` It shows first: ${bet.shows}; the ad built on wins only if it can show that as strongly as its own picture shows its offer.` : ""}${humour}${avoid}
+
+What the check read of each:
+${reads}
+
+Rank them by how likely a version of each, made for us, stops this exact viewer and makes them act: the viewer must see themselves and their problem in it, its winning move must carry our offer as strongly as theirs, and our brand must be able to run it.
+
+Then, as a media buyer does, say what our ad takes. Our ad may combine several: the hook of one, the visual of another, the proof of a third. For each element worth taking (${TAKE_ELEMENTS.join(", ")}), the image whose version of it would work best for us, exactly what to take, and why it applies to this viewer. Leave out an element no image does well for us. Then what our ad must not copy from them: a device that misleads or that the platform restricts (a fake newspaper or news page, a fake app notification), dated urgency, another brand's marks, words that hide what is sold; never what stops the scroll or the proof, which ours keeps as named above. A rule forbids only what it names: "no stock photography" never rules out a meme's reaction face, our own people or our Avatars; when a rule of ours is why, quote the rule word for word.
+
+Answer only JSON: {"ranking": [image numbers, best first], "why": "one sentence on why the first beats the others", "takes": [{"element": "hook", "from": image number, "what": "...", "applies": "..."}], "avoid": [{"from": image number, "what": "...", "why": "..."}]}`;
+}
+function readPickRanking(reply, count) {
+  const ranking = reply?.ranking;
+  if (!Array.isArray(ranking)) return null;
+  const order = [];
+  for (const n of ranking) {
+    const index = Number(n) - 1;
+    if (Number.isInteger(index) && index >= 0 && index < count && !order.includes(index)) order.push(index);
+  }
+  if (order.length === 0) return null;
+  for (let i = 0; i < count; i++) if (!order.includes(i)) order.push(i);
+  return order;
+}
+var text2 = (value) => typeof value === "string" ? value.trim() : "";
+function adOf(from, options) {
+  return options[Number(from) - 1]?.adId ?? null;
+}
+function readTakes(reply, options) {
+  const takes = reply?.takes;
+  if (!Array.isArray(takes)) return [];
+  const read = [];
+  for (const t of takes) {
+    const element = TAKE_ELEMENTS.find((e) => e === t?.element);
+    const adId = adOf(t?.from, options);
+    if (!element || !adId || !text2(t.what) || read.some((r) => r.element === element)) continue;
+    read.push({ element, adId, what: text2(t.what), applies: text2(t.applies) });
+  }
+  return read;
+}
+function readAvoid(reply, options) {
+  const avoid = reply?.avoid;
+  if (!Array.isArray(avoid)) return [];
+  return avoid.flatMap((a) => {
+    const adId = adOf(a?.from, options);
+    return adId && text2(a.what) ? [{ adId, what: text2(a.what), why: text2(a.why) }] : [];
+  });
+}
+var askPickModel = (onSpend) => (pictures, prompt) => askAboutImages(REFERENCE_PICK_MODEL, pictures, prompt, onSpend, REFERENCE_PICK_TIMEOUT_MS).catch(() => null);
+async function pickAmong(options, bet, ask = askPickModel()) {
+  const reply = await ask(
+    options.map((o) => o.picture),
+    referencePickPrompt(options, bet)
+  );
+  const order = readPickRanking(reply, options.length);
+  if (!order) return null;
+  const why = text2(reply.why);
+  const takes = readTakes(reply, options);
+  const avoid = readAvoid(reply, options);
+  return {
+    order,
+    ...why ? { why } : {},
+    ...takes.length > 0 ? { takes } : {},
+    ...avoid.length > 0 ? { avoid } : {}
+  };
+}
+
+// src/commands/creatives/make.ts
+var FITS_TRIED = 6;
+var FITS_AT_ONCE = 3;
+var RANKED_POOL = 24;
+var SEARCH_TIMEOUT_MS = 12e4;
+var REFERENCE_MS = 15e4;
+var DESCRIPTION = `Build one idea from src/creatives/_ideas/ into a creative. For a static it builds on a proven winning ad: it reads what this ad sells and for whom, searches ads of that in its market (the idea's container first, then any), then ads made for the idea's persona, its industry, the idea's message, then the container's strongest winners from any category; leaves out the company's own ads, ranks the rest for this ad's buyer, viewer and brand (a proven ad, or brand, another creative is already built on last, so a batch of ideas builds on different winners), checks which fit us (one whose scroll-stopper or proof cannot be ours is passed over, and the first hint says which and why) and, when several do, compares them side by side, scaffolds the creative on the best-ranked one, records the idea on it and sets the ad's message. The fit says what made that ad win, so what ours carries of it (\`reference.carry\`: whole_ad, layout, hook or angle); its first hint names the ad: tell the person. When no proven ad fits, it starts the ad from the idea itself and says why (never a dead end, never retry with another format). You then write the copy lines and the scene in prompt.json and run it. Takes up to about two and a half minutes: run it in the foreground, once per idea.
+
+Where the ad runs decides its sizes (Meta 4:5 + 9:16, LinkedIn 1:1, TikTok 9:16): it is the idea's \`platforms\`, or --platforms from the person's request; nothing saying so is refused, never defaulted to Meta.
+
+Start here, with an idea from \`baker creatives ideas\` build_next:
+  baker creatives make phone-payroll                         # static: reference found and checked for you
+  baker creatives make phone-payroll --platforms linkedin    # where it runs, when the idea does not say
+  baker creatives make phone-payroll --adset 120210000000    # written for that ad set's viewer
+  baker creatives make phone-payroll --reference 1310524137919413   # your own reference instead
+  baker creatives make founder-story --spec beats.json       # a video idea: from its beats spec
+  baker creatives make phone-payroll --slug phone-payroll-h2 # another hook of the same idea
+  baker creatives make tiktok-speed --series zernio-live     # another message in the style of a ready ad
+Then: edit src/creatives/<slug>/prompt.json (copy + scene; the message is set), and \`baker canvas run src/creatives/<slug>/<slug>.canvas.json\`.`;
+var ARGS = {
+  idea: { type: "positional", required: true, description: "The idea id (src/creatives/_ideas/<idea>.md)" },
+  slug: { type: "string", required: false, description: "Creative slug (default: the idea id)" },
+  adset: { type: "string", required: false, description: "Meta ad set the ad is for: its viewer and placements" },
+  reference: {
+    type: "string",
+    required: false,
+    description: "A library ad id to build on instead of searching (statics)"
+  },
+  platforms: {
+    type: "string",
+    required: false,
+    description: "Where the ad runs, the main platform first: meta (4:5 + 9:16), linkedin (1:1), tiktok (9:16), google_demandgen, \u2026 Take it from the person's request; default the creative's definition (and the sizes it records), then the idea's `platforms`, then the ad set's (Meta). Nothing saying so is refused, never defaulted."
+  },
+  formats: {
+    type: "string",
+    required: false,
+    description: "Exactly the sizes to make, when the person asks for others than the platform's (`--platforms linkedin --formats 1:1,4:5`)."
+  },
+  "reference-platform": {
+    type: "string",
+    required: false,
+    description: "Library platform of --reference: meta|linkedin|tiktok|google (default meta). On google only display ads are built on (a static needs a picture)"
+  },
+  platform: {
+    type: "string",
+    required: false,
+    description: "Retired: --platforms says where the ad runs; --reference-platform says which library --reference is in."
+  },
+  spec: {
+    type: "string",
+    required: false,
+    description: "Video ideas: the beats spec for `baker canvas scaffold-ad --spec`"
+  },
+  series: {
+    type: "string",
+    required: false,
+    description: "Statics: make this idea as another ad of the series led by this creative (its slug): the same design, only its words changed. No reference is searched; seconds. The lead must have a ready version. Then write its words and run the whole series: baker canvas run --series <lead>"
+  },
+  avatar: {
+    type: "string",
+    required: false,
+    description: "Statics: the Avatar(s) the ad's people are cast as (`@eduard` or `eduard,lucia`; `baker avatars list`). Run make again with it once the definition decides the cast, before prompt.json is written: it rebuilds the canvas on them and keeps the thinking"
+  },
+  "from-idea": {
+    type: "boolean",
+    required: false,
+    default: false,
+    description: "Statics: skip the reference search and start from the idea (what make does by itself when no proven ad fits)"
+  }
+};
+registerSchema({ command: "creatives.make", description: DESCRIPTION, args: ARGS });
+function fail(error) {
+  writeJson({ ok: false, error });
+  process.exit(1);
+}
+async function viewerTemperature(root, adSet, awareness) {
+  if (adSet) {
+    const read = await liveViewerLookups(root).adSetViewer(adSet).catch(() => null);
+    if (read) return read.temperature;
+  }
+  return viewerFromKnowledge({ personas: [], awareness }).temperature;
+}
+var PASSED_SAID = 3;
+function passedOver(candidates, fits) {
+  return candidates.flatMap((candidate, i) => {
+    const fit = fits[i];
+    if (!fit?.ok || fitsIdea(fit.fit)) return [];
+    return [
+      {
+        adId: String(candidate.ad_id),
+        ...candidate.advertiser ? { advertiser: candidate.advertiser } : {},
+        why: whyUnfit(fit.fit)
+      }
+    ];
+  }).slice(0, PASSED_SAID);
+}
+function candidatePlatform(c) {
+  const resolved = resolveSourcePlatform(typeof c.platform === "string" ? c.platform : void 0);
+  return resolved.ok ? resolved.platform : null;
+}
+function buildable(c) {
+  const platform = candidatePlatform(c);
+  if (!platform || notADesignReference(platform, String(c.ad_id), { format: c.format ?? null })) return [];
+  return [{ ...c, platform }];
+}
+function liveReferenceDeps(root, bet, rankedFor, brands = []) {
+  return {
+    search: async (body) => {
+      const ask = () => apiPost("/api/ad-library/winners/search", body, {
+        timeoutMs: SEARCH_TIMEOUT_MS
+      }).catch(() => null);
+      return (await ask() ?? await ask())?.results ?? null;
+    },
+    fit: (platform, adId) => fitReference(root, platform, adId, bet),
+    ...rankedFor ? {
+      rank: async (found) => {
+        const spent = [];
+        try {
+          return await rankForBet(
+            found.filter((c) => !isOwnBrand(c.advertiser, brands)),
+            rankedFor,
+            void 0,
+            (u) => spent.push(u)
+          );
+        } finally {
+          await holdUnbilledSpend(path2.join(root, "canvas", ".cache"), spent).catch(() => void 0);
+        }
+      },
+      choose: (fitting) => chooseLive(root, fitting, rankedFor)
+    } : {}
+  };
+}
+async function chooseLive(root, fitting, rankedFor) {
+  const options = (await Promise.all(
+    fitting.map(async (f) => {
+      const picture = await pictureOf(f.candidate.media_url);
+      return picture ? [
+        {
+          adId: f.adId,
+          picture,
+          fit: f.fit,
+          ...f.candidate.advertiser ? { advertiser: f.candidate.advertiser } : {}
+        }
+      ] : [];
+    })
+  )).flat();
+  if (options.length < 2) return null;
+  const spent = [];
+  const picked = await pickAmong(
+    options,
+    rankedFor,
+    askPickModel((u) => spent.push(u))
+  );
+  await holdUnbilledSpend(path2.join(root, "canvas", ".cache"), spent).catch(() => void 0);
+  if (!picked) return null;
+  const byAd = new Map(fitting.map((f, i) => [f.adId, i]));
+  const order = picked.order.flatMap((i) => {
+    const at = byAd.get(options[i]?.adId ?? "");
+    return at === void 0 ? [] : [at];
+  });
+  return { ...picked, order };
+}
+async function findCandidates(searches, deps) {
+  const results = await Promise.all(searches.map((search) => deps.search(search).catch(() => null)));
+  const topics = searches.flatMap((search, i) => search.free_text_query ? [results[i]] : []);
+  if (topics.length > 0 && topics.every((found) => found === null)) return "unavailable";
+  const pooled = pooledCandidates(
+    results.map((found) => (found ?? []).flatMap(buildable)),
+    deps.rank ? RANKED_POOL : FITS_TRIED
+  );
+  const fresh = (found) => deps.taken ? freshReferencesFirst(found, deps.taken) : found;
+  if (!deps.rank) return fresh(pooled);
+  const ranked = await deps.rank(pooled).catch(() => pooled);
+  return fresh(ranked.flatMap(buildable)).slice(0, FITS_TRIED);
+}
+var candidateOf = (c) => ({
+  adId: String(c.ad_id),
+  platform: c.platform,
+  ...c.advertiser_id ? { advertiserId: c.advertiser_id } : {}
+});
+async function pickReference(root, searches, deps = liveReferenceDeps(root), prepare, within) {
+  const out = whenAborted(within);
+  const found = await Promise.race([findCandidates(searches, deps), out]);
+  if (found === "out") return slowReference();
+  if (found === "unavailable") return searchUnavailable();
+  const candidates = found.slice(0, FITS_TRIED);
+  const first = candidates[0];
+  const stop = new AbortController();
+  const building = first && prepare ? prepare(candidateOf(first), stop.signal) : void 0;
+  void building?.catch(() => void 0);
+  let settled = false;
+  const asked = [];
+  const askNext = () => {
+    const index = asked.length;
+    const candidate = candidates[index];
+    if (settled || !candidate) return;
+    asked.push(
+      askFit(deps, candidate).then((fit) => {
+        if (!(fit.ok && fitsIdea(fit.fit))) askNext();
+        return fit;
+      })
+    );
+  };
+  for (let slot = 0; slot < FITS_AT_ONCE; slot++) askNext();
+  const deciding = deps.choose ? chosenFitting(candidates, asked, deps.choose, deps.taken) : firstFitting(candidates, asked);
+  const kept = await Promise.race([deciding, out]);
+  settled = true;
+  if (kept === "out") {
+    stop.abort();
+    return { ...slowReference(), ...building ? { discarded: building } : {} };
+  }
+  if (kept.index !== 0) stop.abort();
+  const speculated = building ? kept.index === 0 ? { prepared: building } : { discarded: building } : {};
+  return { ...kept.picked, ...speculated };
+}
+var askFit = (deps, c) => Promise.resolve().then(() => deps.fit(c.platform, String(c.ad_id))).catch((e) => ({ ok: false, error: { code: "UNAVAILABLE", message: String(e), fix: "" } }));
+var whenAborted = (signal) => new Promise((resolve) => {
+  if (signal?.aborted) resolve("out");
+  signal?.addEventListener("abort", () => resolve("out"), { once: true });
+});
+function pickedOf(candidate, fit, index, preferred) {
+  const layers = fit.why_it_wins;
+  return {
+    ...candidateOf(candidate),
+    why: [layers.disguise, layers.trigger, layers.logic].filter(Boolean).join("; "),
+    tried: index + 1,
+    fit,
+    ...candidate.dna?.container ? { container: candidate.dna.container } : {},
+    ...preferred ? { preferred } : {}
+  };
+}
+async function firstFitting(candidates, fits) {
+  let unchecked = null;
+  let checked = 0;
+  const lacking = [];
+  const answered = [];
+  for (const [index, candidate] of candidates.entries()) {
+    const fit = await fits[index];
+    answered.push(fit);
+    if (!fit) continue;
+    if (!fit.ok) unchecked = fit.error;
+    else checked += 1;
+    if (fit.ok && !fitsIdea(fit.fit)) lacking.push(...missingElements(fit.fit));
+    if (!(fit.ok && fitsIdea(fit.fit))) continue;
+    const passed = passedOver(candidates, answered);
+    return { picked: { ...pickedOf(candidate, fit.fit, index), ...passed.length > 0 ? { passed } : {} }, index };
+  }
+  return { picked: noReference(candidates.length, checked, unchecked, lacking), index: -1 };
+}
+async function allFits(fits) {
+  let seen = -1;
+  while (seen !== fits.length) {
+    seen = fits.length;
+    await Promise.all(fits);
+  }
+  return await Promise.all(fits);
+}
+async function chosenFitting(candidates, fits, choose, taken) {
+  const answered = await allFits(fits);
+  const fitted = answered.flatMap((fit, index) => {
+    const candidate = candidates[index];
+    return candidate && fit.ok && fitsIdea(fit.fit) ? [{ index, candidate, fit: fit.fit }] : [];
+  });
+  const fresh = taken ? fitted.filter((f) => !isTakenReference(f.candidate, taken)) : [];
+  const fitting = fresh.length > 0 ? fresh : fitted;
+  if (fitting.length < 2) return await firstFitting(candidates, fits);
+  const chosen = await choose(
+    fitting.map((f) => ({ adId: String(f.candidate.ad_id), candidate: f.candidate, fit: f.fit }))
+  ).catch(() => null);
+  const kept = chosen && fitting[chosen.order[0] ?? 0] || fitting[0];
+  if (!kept) return await firstFitting(candidates, fits);
+  const ordered = chosen ? chosen.order.flatMap((i) => fitting[i] ?? []) : fitting;
+  const passed = passedOver(candidates, answered);
+  return {
+    picked: {
+      ...pickedOf(kept.candidate, kept.fit, kept.index, chosen?.why),
+      board: [kept, ...ordered.filter((f) => f !== kept)].map((f) => boardAdOf(f.candidate)),
+      ...chosen?.takes ? { takes: chosen.takes } : {},
+      ...chosen?.avoid ? { avoid: chosen.avoid } : {},
+      ...passed.length > 0 ? { passed } : {}
+    },
+    index: kept.index
+  };
+}
+var boardAdOf = (c) => ({
+  adId: String(c.ad_id),
+  ...c.advertiser ? { advertiser: c.advertiser } : {},
+  ...c.media_url ? { mediaUrl: c.media_url } : {}
+});
+var lackingText = (lacking) => {
+  const named = [...new Set(lacking.map((l) => l.trim()).filter(Boolean))].slice(0, 3);
+  return named.length > 0 ? ` (they won on ${named.join(", ")})` : "";
+};
+var searchUnavailable = () => ({
+  code: "REFERENCE_SEARCH_UNAVAILABLE",
+  message: "The ads library could not search for this ad's category just now.",
+  fix: "Run make again in a minute: every ad is built on a proven one. Only when the person asks for an ad without one, pass --from-idea."
+});
+var slowReference = () => ({
+  code: "REFERENCE_SLOW",
+  message: `Finding and checking a proven ad took longer than ${REFERENCE_MS / 1e3} s.`,
+  fix: "Run make again: the searches and checks already made are kept, so it goes further each time. Or pass --reference <adId> for one you looked at (`baker winning-ads search`). Never start the ad from the idea for this."
+});
+function startsFromIdea(failure) {
+  return failure.code === "FROM_IDEA" || failure.code === "NO_REFERENCE_FITS";
+}
+function noReference(found, checked, unchecked, lacking = []) {
+  if (found > 0 && checked === 0 && unchecked) {
+    return {
+      code: "FIT_UNAVAILABLE",
+      message: `Could not check whether the references fit (${unchecked.message})`,
+      fix: "Run make again in a moment. To build now, pass --reference <adId> with one you looked at yourself (`baker winning-ads search`)."
+    };
+  }
+  return {
+    code: "NO_REFERENCE_FITS",
+    message: found === 0 ? "The library has no proven ad in this idea's format." : `None of the ${found} proven ads checked wins on something this company has, for a viewer who would stop for it${lackingText(lacking)}.`,
+    fix: "Nothing to do to go on: the ad starts from the idea. To build on a proven ad instead, pass --reference <adId> for one you looked at (`baker winning-ads search --format static` with what the company sells or who the ad is for). Do not stop the batch: build the other ideas."
+  };
+}
+function alreadyWritten(promptJson, slug, draft) {
+  if (promptJson === null || promptJson === void 0) return null;
+  if (draft !== void 0 && sameJson(promptJson, draft)) return null;
+  try {
+    if (unwrittenProblems(readAdSpec(promptJson)).length > 0) return null;
+  } catch {
+  }
+  return {
+    code: "ALREADY_MADE",
+    message: `"${slug}" is already made and its ad is written: building it again would replace that ad with placeholders.`,
+    fix: `To change this ad, edit src/creatives/${slug}/prompt.json and run \`baker canvas run\` on it. For another ad of the same idea, run make again with --slug <new-slug>.`
+  };
+}
+function sameJson(parsed, text3) {
+  try {
+    return JSON.stringify(parsed) === JSON.stringify(JSON.parse(text3));
+  } catch {
+    return false;
+  }
+}
+var draftPath = (root, slug) => path2.join(root, "canvas", ".cache", "make-drafts", `${slug}.json`);
+function castRebuild(definition, args) {
+  if (!definition || !args.avatar || args.reference || args.fromIdea) return null;
+  const { sourceAdId, sourcePlatform } = parseDefinitionSourceFields(definition);
+  return sourceAdId ? { adId: sourceAdId, platform: sourcePlatform ?? "meta" } : null;
+}
+function ideaRecast(definition, args) {
+  if (!definition || !args.avatar || args.reference || args.fromIdea) return false;
+  return !parseDefinitionSourceFields(definition).sourceAdId;
+}
+function castFlags(avatar) {
+  const handles = (avatar ?? "").split(/[\s,]+/).map((h) => h.replace(/^@/, "").toLowerCase()).filter(Boolean);
+  return handles.length > 0 ? ["--avatar", handles.join(",")] : [];
+}
+var flag = (value) => typeof value === "string" && value ? value : void 0;
+async function loadIdea(root, ideaId) {
+  const { ideas, unreadable } = await readIdeas(root);
+  const bad = unreadable.find((u) => u.id === ideaId);
+  if (bad) {
+    fail({
+      code: "INVALID_IDEA",
+      message: bad.problems.join("; "),
+      fix: `Fix ${IDEAS_DIR}/${ideaId}.md, then run make again.`
+    });
+  }
+  const idea = ideas.find((i) => i.id === ideaId);
+  if (!idea) {
+    fail({
+      code: "NOT_FOUND",
+      message: `No idea "${ideaId}" in ${IDEAS_DIR}/.`,
+      fix: `Ideas on file: ${ideas.map((i) => i.id).join(", ") || "none"}. Write it there first.`
+    });
+  }
+  const [insights, knowledge, personas, creatives, products] = await Promise.all([
+    readInsights(root),
+    readKnowledgeCorpus(root),
+    readPersonaIds(root),
+    readCreativeRecords(root),
+    storeProductReads([idea.product])
+  ]);
+  const check = checkIdeas({ ideas, insights, knowledge, personas, products, ...coverageOf(ideas, creatives) }).find(
+    (c) => c.id === idea.id
+  );
+  if (check && check.problems.length > 0) {
+    fail({
+      code: "IDEA_HAS_PROBLEMS",
+      message: check.problems.join("; "),
+      fix: "Fix the idea file and run `baker creatives ideas` again."
+    });
+  }
+  const product = idea.product ? products.get(idea.product) : void 0;
+  return { idea, check, productRecord: product && "record" in product ? product.record : "" };
+}
+async function scaffoldIdea(root, idea, args, slug, temperature, whereFlags) {
+  const viewerFlags = [
+    ...args.adset ? ["--target-adset", args.adset] : ["--viewer-temperature", temperature],
+    ...whereFlags
+  ];
+  if (isVideoIdea(idea)) {
+    if (!args.spec) {
+      fail({
+        code: "SPEC_REQUIRED",
+        message: `"${idea.id}" is a video idea (${idea.format}): it is built from its beats.`,
+        fix: `Write the beats spec (one spoken line plus one shot each; references/video-flow.md), message first, then: baker creatives make ${idea.id} --spec <file>.`
+      });
+    }
+    return {
+      scaffold: await runBaker(["canvas", "scaffold-ad", "--spec", args.spec, "--slug", slug, ...viewerFlags]),
+      reference: null
+    };
+  }
+  return await scaffoldStatic(root, idea, args, slug, temperature, [...viewerFlags, ...castFlags(args.avatar)]);
+}
+async function checkedByHand(adId, platform, deps) {
+  const byHand = handPickedReference(adId, platform);
+  if ("code" in byHand) return byHand;
+  const fit = await deps.fit(byHand.platform, byHand.adId).catch(() => null);
+  if (!fit?.ok) return byHand;
+  if (!fitsIdea(fit.fit)) {
+    return {
+      code: "REFERENCE_UNFIT",
+      message: `The proven ad ${adId} does not fit this idea: ${whyUnfit(fit.fit)}.`,
+      fix: "Pick another proven ad (`baker winning-ads search`), or run make without --reference to build from the idea."
+    };
+  }
+  const layers = fit.fit.why_it_wins;
+  return { ...byHand, why: [layers.disguise, layers.trigger, layers.logic].filter(Boolean).join("; "), fit: fit.fit };
+}
+async function chooseReference(args, deps, pick) {
+  if (args.reference) {
+    const byHand = await checkedByHand(args.reference, args.referencePlatform, deps);
+    if ("code" in byHand) fail(byHand);
+    return byHand;
+  }
+  if (args.fromIdea) return { code: "FROM_IDEA", message: "Asked to start from the idea." };
+  return await pick();
+}
+async function referenceTarget(root, idea) {
+  const market = marketFromCompanyDoc(await readFile2(path2.join(root, "COMPANY.md"), "utf8").catch(() => ""));
+  const personas = await readPersonas(root).catch(() => []);
+  const [found, company, context] = await Promise.all([
+    referenceBriefFor(root, {
+      message: idea.message,
+      who: personaWho(idea, personas),
+      ...idea.shows ? { shows: idea.shows } : {}
+    }),
+    readCompanyReading(root),
+    readCreativeContext(root, { kind: "static" })
+  ]);
+  const brief = found && { ...found, avoid: avoidOf(context.rules) };
+  const category = company?.category ?? company?.sells;
+  const where = referenceWhereOf(brief, {
+    ...market && market.country !== "global" ? { country: market.country } : {},
+    ...category ? { category } : {},
+    audience: audienceQuery(idea, personas)
+  });
+  return { market, personas, brief, where };
+}
+async function takenReferencesIn(root, slug) {
+  const creatives = path2.join(root, "src", "creatives");
+  const names = await readdir(creatives).catch(() => []);
+  const sources = await Promise.all(
+    names.filter((name) => name !== slug && !name.startsWith("_")).map(
+      (name) => readFile2(path2.join(creatives, name, "_definition.md"), "utf8").then(
+        parseDefinitionSourceFields,
+        () => ({})
+      )
+    )
+  );
+  return {
+    adIds: new Set(sources.flatMap((s) => s.sourceAdId ? [s.sourceAdId] : [])),
+    advertiserIds: new Set(sources.flatMap((s) => s.sourceAdvertiserId ? [s.sourceAdvertiserId] : []))
+  };
+}
+async function scaffoldStatic(root, idea, args, slug, temperature, viewerFlags) {
+  const onReference = (c, signal) => runBaker(
+    [
+      "canvas",
+      "scaffold-static-ad",
+      "--source-ad-id",
+      c.adId,
+      "--source-platform",
+      c.platform,
+      ...c.advertiserId ? ["--source-advertiser-id", c.advertiserId] : [],
+      "--slug",
+      slug,
+      "--title",
+      idea.message.slice(0, 120),
+      ...viewerFlags
+    ],
+    signal
+  );
+  const dir = path2.join(root, "src", "creatives", slug);
+  const fresh = !await stat(dir).catch(() => null);
+  const budget = AbortSignal.timeout(REFERENCE_MS);
+  const { market, personas, brief, where } = await referenceTarget(root, idea);
+  const bet = fitBetOf(
+    idea,
+    personas,
+    await readInsights(root).catch(() => []),
+    market ? describeMarket(market) : void 0
+  );
+  const deps = {
+    ...liveReferenceDeps(root, bet, rankedForOf(brief, where, bet), brief?.brands),
+    taken: await takenReferencesIn(root, slug)
+  };
+  const definition = await readFile2(path2.join(dir, "_definition.md"), "utf8").catch(() => null);
+  const recast = castRebuild(definition, args);
+  const fromIdea = args.fromIdea || ideaRecast(definition, args);
+  const reference = await chooseReference({ ...args, fromIdea }, deps, async () => {
+    if (recast) {
+      const kept = await checkedByHand(recast.adId, recast.platform, deps);
+      if ("code" in kept) fail(kept);
+      return kept;
+    }
+    return await pickReference(
+      root,
+      referenceSearchesFor(idea, temperature, where).map(buildSearchBody),
+      deps,
+      fresh ? (c, signal) => onReference(c, AbortSignal.any([signal, budget])) : void 0,
+      budget
+    );
+  });
+  if ("discarded" in reference && reference.discarded) {
+    await reference.discarded.catch(() => void 0);
+    await rm(dir, { recursive: true, force: true });
+  }
+  if ("code" in reference) return await fromIdeaWhenNoneFits(reference, idea, slug, viewerFlags);
+  const prepared = "prepared" in reference ? await reference.prepared?.catch(() => null) : null;
+  if (prepared?.ok !== true && budget.aborted && !args.reference) {
+    await rm(dir, { recursive: true, force: true });
+    fail(slowReference());
+  }
+  const scaffold = prepared?.ok === true ? prepared : await onReference(reference);
+  if (scaffold.ok !== true && scaffold.error?.code === "avatar") {
+    fail(scaffoldFailure(scaffold));
+  }
+  const unbuilt = unbuiltReference(scaffold, { adId: reference.adId, byHand: Boolean(args.reference || recast) });
+  if (!unbuilt) return await withKeptConcept(dir, slug, scaffold, reference);
+  if (fresh) await rm(dir, { recursive: true, force: true });
+  return { scaffold: await scaffoldFromIdea(idea, slug, viewerFlags), reference: null, fromIdea: unbuilt };
+}
+async function fromIdeaWhenNoneFits(failure, idea, slug, viewerFlags) {
+  if (!startsFromIdea(failure)) fail(failure);
+  return { scaffold: await scaffoldFromIdea(idea, slug, viewerFlags), reference: null, fromIdea: failure.message };
+}
+function handPickedReference(adId, platform) {
+  const resolved = resolveSourcePlatform(platform);
+  if (!resolved.ok) {
+    return {
+      code: "INVALID_ARGUMENT",
+      message: resolved.message.replace("--source-platform", "--platform"),
+      fix: "Pass the platform `baker winning-ads search` names beside the ad."
+    };
+  }
+  return { adId, platform: resolved.platform, why: "chosen by hand", tried: 0 };
+}
+function unbuiltReference(scaffold, reference) {
+  if (scaffold.ok === true || reference.byHand) return null;
+  return `The proven ad ${reference.adId} could not be read to build on.`;
+}
+async function withKeptConcept(dir, slug, scaffold, reference) {
+  if (scaffold.ok !== true || !reference.fit) return { scaffold, reference };
+  const unseeded = await seedConcept(dir, slug, conceptFromFit(reference.fit, reference.adId));
+  return { scaffold, reference, ...unseeded ? { conceptUnseeded: unseeded } : {} };
+}
+async function seedConcept(dir, slug, seeded) {
+  const promptPath = path2.join(dir, "prompt.json");
+  const canvasPath = path2.join(dir, `${slug}.canvas.json`);
+  let prompt;
+  try {
+    prompt = withFitConcept(await readFile2(promptPath, "utf8"), seeded);
+    await writeFile2(promptPath, prompt, "utf8");
+  } catch (e) {
+    return `prompt.json could not take the proven ad's concept (${e instanceof Error ? e.message : String(e)})`;
+  }
+  try {
+    const spec = JSON.parse(prompt);
+    const { canvas, rerouted } = reroutedOnSpec(JSON.parse(await readFile2(canvasPath, "utf8")), spec);
+    const briefed = projectStaticBriefs(canvas, spec) + projectAdaptBriefs(canvas, spec) + projectFormatBriefs(canvas, spec);
+    if (rerouted || briefed > 0) {
+      await writeFile2(canvasPath, `${JSON.stringify(canvas, null, 2)}
+`, "utf8");
+    }
+  } catch {
+  }
+  return null;
+}
+async function scaffoldFromIdea(idea, slug, viewerFlags) {
+  const dir = await mkdtemp(path2.join(tmpdir(), "idea-spec-"));
+  const specPath = path2.join(dir, "prompt.json");
+  await writeFile2(specPath, JSON.stringify(ideaSpec(idea, idea.who.replace(/[-_]/g, " ")), null, 2), "utf8");
+  try {
+    return await runBaker([
+      "canvas",
+      "scaffold-static-ad",
+      "--spec",
+      specPath,
+      "--slug",
+      slug,
+      "--title",
+      idea.message.slice(0, 120),
+      ...viewerFlags
+    ]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+function referencePictureUrl(canvas) {
+  const nodes = canvas?.nodes;
+  if (!Array.isArray(nodes)) return null;
+  const original = nodes.find(
+    (n) => n?.id === "original"
+  );
+  const url = original?.params?.url;
+  return typeof url === "string" && /^https?:\/\//.test(url) ? url : null;
+}
+async function saveReferencePicture(root, canvasPath, adId) {
+  const url = await readFile2(canvasPath, "utf8").then(
+    (text3) => referencePictureUrl(JSON.parse(text3)),
+    () => null
+  );
+  return url ? await savePicture(root, url, adId) : null;
+}
+async function savePicture(root, url, adId) {
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(2e4) });
+    if (!response.ok) return null;
+    const ext = path2.extname(new URL(url).pathname).toLowerCase() || ".jpg";
+    const relative = path2.join("canvas", "references", `${adId}${ext}`);
+    await mkdir2(path2.join(root, "canvas", "references"), { recursive: true });
+    await writeFile2(path2.join(root, relative), Buffer.from(await response.arrayBuffer()));
+    return relative;
+  } catch {
+    return null;
+  }
+}
+async function withPictures(root, canvasPath, reference) {
+  const picture = await saveReferencePicture(root, canvasPath, reference.adId);
+  const board = reference.board ? await savedBoard(root, reference.board, reference.adId, picture) : void 0;
+  return { ...reference, ...picture ? { picture } : {}, ...board ? { board } : {} };
+}
+async function savedBoard(root, board, keptId, keptPicture) {
+  return await Promise.all(
+    board.map(async ({ adId, advertiser, mediaUrl }) => {
+      const picture = adId === keptId ? keptPicture : mediaUrl ? await savePicture(root, mediaUrl, adId) : null;
+      return { adId, ...advertiser ? { advertiser } : {}, ...picture ? { picture } : {} };
+    })
+  );
+}
+async function recordIdea(root, slug, idea, evidence, productRecord, reference) {
+  const dir = path2.join(root, "src", "creatives", slug);
+  const definitionPath = path2.join(dir, "_definition.md");
+  const definition = await readFile2(definitionPath, "utf8").catch(() => null);
+  if (definition !== null) {
+    const recorded = setDefinitionFields(definition, { ...definitionFieldsOf(idea, evidence) });
+    const thinkingReference = reference ? await withPictures(root, path2.join(dir, `${slug}.canvas.json`), reference) : null;
+    const inventory = await castInventory(root, idea.message, await companyName(root));
+    const castRules = (await readCreativeContext(root, { kind: idea.format?.startsWith("video_") ? "video" : "static" })).rules.filter((r) => r.applies === "cast" || r.applies === "picture" || r.applies === "logo").map((r) => ({ id: r.id, strength: r.strength, text: r.text }));
+    const audience = memeRegister(await readCompanyReading(root).catch(() => null));
+    await writeFile2(
+      definitionPath,
+      withThinking(
+        recorded,
+        thinkingOutline({
+          idea,
+          reference: thinkingReference,
+          inventory,
+          rules: castRules,
+          ...audience ? { audience } : {}
+        })
+      ),
+      "utf8"
+    );
+  }
+  const promptPath = path2.join(dir, "prompt.json");
+  const prompt = isVideoIdea(idea) ? null : await readFile2(promptPath, "utf8").catch(() => null);
+  if (prompt !== null) {
+    const personas = await readPersonas(root).catch(() => []);
+    const written = (() => {
+      try {
+        return setSpecViewer(setSpecMessage(prompt, idea.message), idea, personas);
+      } catch {
+        return null;
+      }
+    })();
+    if (written !== null) await writeFile2(promptPath, written, "utf8").catch(() => void 0);
+  }
+  const unsourcedCopy = prompt === null ? [] : await draftedClaims(root, prompt, productRecord);
+  await keepDraft(root, slug, promptPath);
+  if (idea.status === "idea") {
+    const ideaPath = path2.join(root, IDEAS_DIR, `${idea.id}.md`);
+    await writeFile2(ideaPath, setDefinitionFields(await readFile2(ideaPath, "utf8"), { status: "built" }), "utf8");
+  }
+  await runBaker(["canvas", "sync-definition", dir]);
+  return { dir, unsourcedCopy };
+}
+async function keepDraft(root, slug, promptPath) {
+  const written = await readFile2(promptPath, "utf8").catch(() => null);
+  if (written === null) return;
+  await mkdir2(path2.dirname(draftPath(root, slug)), { recursive: true });
+  await writeFile2(draftPath(root, slug), written, "utf8");
+}
+async function draftedClaims(root, prompt, productRecord) {
+  const [knowledge, insights] = await Promise.all([readKnowledgeCorpus(root), readInsights(root)]);
+  const own = insights.filter(sourcesClaims).map((i) => i.quote);
+  try {
+    return unsourcedCopyLines(prompt, `${knowledge}
+${own.join("\n")}
+${productRecord}`);
+  } catch {
+    return [];
+  }
+}
+function makeArgsOf(args) {
+  const opts = {};
+  for (const key of ["slug", "adset", "reference", "platforms", "formats", "spec", "series", "avatar"]) {
+    const value = flag(args[key]);
+    if (value) opts[key] = value;
+  }
+  const referencePlatform = flag(args["reference-platform"]) ?? (opts.reference ? flag(args.platform) : void 0);
+  if (referencePlatform) opts.referencePlatform = referencePlatform;
+  if (flag(args.platform) && !opts.reference) {
+    return {
+      code: "INVALID_ARGUMENT",
+      message: `--platform ${flag(args.platform)} is ambiguous: it named the library of --reference.`,
+      fix: "--platforms says where the ad runs (baker creatives make <idea> --platforms linkedin); --reference-platform says which library the reference is in."
+    };
+  }
+  if (args["from-idea"] === true) opts.fromIdea = true;
+  return opts;
+}
+function deliveryFlags(delivery, args, kind = "static") {
+  const sizes = args.formats && kind === "static" ? ["--formats", args.formats] : [];
+  return ["--platforms", delivery.platforms.join(","), ...sizes];
+}
+function scaffoldFailure(scaffold) {
+  const error = scaffold.error ?? {};
+  return {
+    code: error.code ?? "SCAFFOLD_FAILED",
+    message: error.message ?? "The creative could not be scaffolded.",
+    ...error.fix ? { fix: error.fix } : {}
+  };
+}
+var CARRY_WORDS = {
+  whole_ad: "the whole ad (its disguise, layout and hook)",
+  layout: "its layout",
+  hook: "its hook",
+  angle: "its angle"
+};
+function builtOnHint(reference) {
+  const tell = "Tell the person which proven ad this builds on";
+  const ours = "the words, brand, people and claims stay ours.";
+  if (!reference.fit) {
+    return `Built on proven ad ${reference.adId}, the one chosen for it; no check read what made it win. The canvas shows that ad as \`original\`. ${tell}; ${ours}`;
+  }
+  const carried = CARRY_WORDS[reference.fit.carry ?? "whole_ad"];
+  const why = reference.fit.carry_why ? ` (${reference.fit.carry_why})` : "";
+  const won = reference.why ? ` It won on: ${reference.why}.` : "";
+  const chosen = reference.preferred ? ` Chosen over the other proven ads that fit because ${reference.preferred.replace(/\.$/, "")}.` : "";
+  const passed = (reference.passed ?? []).map(
+    (p) => ` Passed over ${p.advertiser ? `${p.advertiser}'s proven ad` : "proven ad"} ${p.adId}: ${p.why.replace(/\.$/, "")}.`
+  ).join("");
+  const whyNot = passed ? ", and in one line why not the ones passed over" : "";
+  const byHand = reference.tried === 0 ? ", the one chosen for it" : "";
+  return `Built on proven ad ${reference.adId}${byHand}: it carries ${carried}${why}.${won}${chosen}${passed} The canvas shows that ad as \`original\`. ${tell} and what it takes from it${whyNot}; ${ours}`;
+}
+var unseededHint = (reference, slug, why) => `${why}, so the render does not see proven ad ${reference.adId} yet. \`baker winning-ads fit ${reference.adId} --platform ${reference.platform} --full\` prints the check already made (free): write its \`read\` into src/creatives/${slug}/prompt.json as \`concept\`, with \`reference_ad_id: "${reference.adId}"\`.`;
+function thinkFirstHint(made) {
+  const basis = made.reference ? "what the proven ad is and why it won" : "why this bet should work";
+  const board = (made.reference?.board?.length ?? 0) > 1 ? " what to take from which of the proven ads that fit (the hook of one, the proof of another)," : "";
+  const survives = made.reference ? " what of it must survive," : "";
+  const read = made.reference ? "first open the proven ads' pictures the outline names and read .claude/skills/creative-canvas-ads/references/reading-a-winner.md, then " : "";
+  const recast = made.reference ? ` When the cast is an Avatar the canvas was not built with, \`baker creatives make ${made.idea.id}${made.slug === made.idea.id ? "" : ` --slug ${made.slug}`} --avatar <handle>\` rebuilds it on the same proven ad before you write prompt.json.` : "";
+  return `Think first: ${read}answer every question under "Thinking" in src/creatives/${made.slug}/_definition.md before you touch prompt.json (how: .claude/skills/creative-canvas-ads/references/creative-intent.md): ${basis},${board} whether it fits our viewer, our hook, who appears and what of the product shows (decided from what the company has, listed there: its Avatars, real customers, founder, product pictures, logos),${survives} and the plan.${recast} This thinking decides the ad; the run renders nothing while a question is open or the cast is not ours.`;
+}
+function writeTheAdHint(made, quote) {
+  const words = `say the message in the customer's words${quote ? ` ("${quote.slice(0, 80)}")` : ""}; keep \`message\` as it is`;
+  if (made.idea.format?.startsWith("video_")) {
+    return `Then write the ad from "The plan": its scene files and prompt.json carry every decision (the render never reads the definition); ${words}.`;
+  }
+  const drafted = made.reference ? " The drafted lines are the reference's: keep one only if the Knowledge says it (badges, ratings and guarantees too)." : "";
+  return `Then write the ad from "The plan" in src/creatives/${made.slug}/prompt.json, every decision in its fields (the render never reads the definition); ${words}.${drafted} Read static-image-flow.md first. Inspect existing Avatars before creating an actor. Keep interfaces native and requested overlays separate. Preserve plausible anatomy, device proportions, scale, perspective and support; reflow text rather than distort it. Honour the requested sizes.`;
+}
+function makeEnvelope(made) {
+  const quote = made.check?.quote;
+  return {
+    ok: true,
+    data: {
+      creative: made.slug,
+      idea: made.idea.id,
+      message: made.idea.message,
+      evidence: made.check?.evidence ?? "explore",
+      ...quote ? { customer_quote: quote } : {},
+      ...made.fromIdea ? { built_from: "idea" } : {},
+      ...made.reference ? {
+        reference: {
+          ad_id: made.reference.adId,
+          platform: made.reference.platform,
+          why_it_wins: made.reference.why,
+          ...made.reference.fit?.carry ? { carry: made.reference.fit.carry } : {},
+          ...made.reference.preferred ? { chosen_because: made.reference.preferred } : {}
+        }
+      } : {},
+      viewer: made.viewer,
+      ...made.delivery ? { platforms: made.delivery.platforms, lead: made.delivery.lead } : {},
+      ...made.shape ? { master_shape: made.shape } : {},
+      canvas_path: made.canvasPath
+    },
+    hints: [
+      ...made.reference ? [builtOnHint(made.reference)] : [],
+      ...made.reference && made.conceptUnseeded ? [unseededHint(made.reference, made.slug, made.conceptUnseeded)] : [],
+      ...made.fromIdea ? [
+        `${made.fromIdea} So this ad starts from the idea: write the scene and every line of copy in src/creatives/${made.slug}/prompt.json (a placeholder refuses to run). Tell the person this ad is not built on a proven ad, and why, in plain words.`
+      ] : [],
+      ...made.unsourcedCopy.length > 0 ? [
+        `Rewrite before running: ${made.unsourcedCopy.map((l) => JSON.stringify(l)).join(", ")} claim a figure nothing the company wrote holds (the reference's promise, not ours).`
+      ] : [],
+      thinkFirstHint(made),
+      writeTheAdHint(made, quote),
+      SPEC_SHAPES_HINT,
+      `Then: baker canvas run ${made.canvasPath} (it validates and asks the viewer itself: nothing to run before it).`,
+      // The scaffold's own next steps name a separate validate; the run does it (dev, Oct 2026: five validates before one run).
+      ...made.scaffoldHints.filter((h) => !/canvas (?:validate|viewer-check)/.test(h)).filter((h) => !(made.reference?.fit && h.startsWith(NO_FIT_HINT))).slice(0, 4)
+    ]
+  };
+}
+function ideaPlatforms(idea) {
+  if (idea.platforms && idea.platforms.length > 0) return idea.platforms;
+  const named = platformsNamedIn([idea.message, idea.who, idea.why, idea.format].join(" "));
+  return named.length > 0 ? named : void 0;
+}
+async function makeDelivery(root, idea, args, slug) {
+  const definition = await readFile2(path2.join(root, "src", "creatives", slug, "_definition.md"), "utf8").catch(
+    () => null
+  );
+  const flags = { platforms: args.platforms, formats: args.formats, "target-adset": args.adset };
+  const resolved = await scaffoldDelivery(flags, definition, ideaPlatforms(idea));
+  const video = isVideoIdea(idea);
+  if (resolved.ok)
+    return { delivery: resolved.delivery, flags: deliveryFlags(resolved.delivery, args, video ? "video" : "static") };
+  if (video && resolved.error.code === "platform_required") return { flags: [] };
+  return fail({ code: resolved.error.code.toUpperCase(), message: resolved.error.message, fix: resolved.error.fix });
+}
+async function makeInSeries(root, idea, slug, lead, evidence) {
+  if (isVideoIdea(idea)) {
+    fail({
+      code: "SERIES_STATIC_ONLY",
+      message: `"${idea.id}" is a video idea: a series repeats one static ad with other words.`,
+      fix: `Make it on its own: baker creatives make ${idea.id} --spec <beats file>.`
+    });
+  }
+  const made = await makeSeriesAd(root, idea, slug, lead, evidence, {
+    sync: (dir) => runBaker(["canvas", "sync-definition", dir, "--title"])
+  });
+  if ("code" in made) fail(made);
+  const leadDefinition = await readFile2(path2.join(root, "src", "creatives", lead, "_definition.md"), "utf8").catch(
+    () => ""
+  );
+  const leadPlatforms = parseDefinitionDelivery(leadDefinition)?.platforms;
+  writeJson(
+    seriesMadeEnvelope(
+      { ...made, canvasPath: path2.relative(root, made.canvasPath), ...leadPlatforms ? { leadPlatforms } : {} },
+      idea
+    )
+  );
+}
+var makeCommand = defineCommand({
+  meta: { name: "make", description: DESCRIPTION },
+  args: ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const opts = makeArgsOf(args);
+    if ("code" in opts) return fail(opts);
+    const { idea, check, productRecord } = await loadIdea(root, String(args.idea));
+    const slug = opts.slug ?? idea.id;
+    const written = await readFile2(path2.join(root, "src", "creatives", slug, "prompt.json"), "utf8").then(
+      (text3) => {
+        try {
+          return JSON.parse(text3);
+        } catch {
+          return {};
+        }
+      },
+      (err) => err.code === "ENOENT" ? null : {}
+    );
+    const draft = await readFile2(draftPath(root, slug), "utf8").catch(() => void 0);
+    const refused = alreadyWritten(written, slug, draft);
+    if (refused) fail(refused);
+    if (opts.series) {
+      await makeInSeries(root, idea, slug, opts.series, check?.evidence ?? "explore");
+      return;
+    }
+    const { delivery, flags } = await makeDelivery(root, idea, opts, slug);
+    const temperature = await viewerTemperature(root, opts.adset, idea.awareness);
+    const { scaffold, reference, fromIdea, conceptUnseeded } = await scaffoldIdea(
+      root,
+      idea,
+      opts,
+      slug,
+      temperature,
+      flags
+    );
+    if (scaffold.ok !== true) fail(scaffoldFailure(scaffold));
+    const { dir, unsourcedCopy } = await recordIdea(
+      root,
+      slug,
+      idea,
+      check?.evidence ?? "explore",
+      productRecord,
+      reference
+    );
+    const canvasPath = String(scaffold.canvas_path ?? path2.join(dir, `${slug}.canvas.json`));
+    const shape = recordedShape(await readFile2(canvasPath, "utf8").then(JSON.parse, () => null));
+    writeJson(
+      makeEnvelope({
+        slug,
+        idea,
+        check,
+        reference,
+        ...fromIdea ? { fromIdea } : {},
+        ...conceptUnseeded ? { conceptUnseeded } : {},
+        viewer: opts.adset ? { adset: opts.adset } : { temperature },
+        canvasPath: path2.relative(root, canvasPath),
+        scaffoldHints: Array.isArray(scaffold.hints) ? scaffold.hints : [],
+        unsourcedCopy,
+        ...delivery ? { delivery } : {},
+        ...shape ? { shape } : {}
+      })
+    );
+  }
+});
+export {
+  alreadyWritten,
+  castFlags,
+  castRebuild,
+  checkedByHand,
+  deliveryFlags,
+  handPickedReference,
+  ideaPlatforms,
+  ideaRecast,
+  makeArgsOf,
+  makeCommand,
+  makeEnvelope,
+  noReference,
+  pickReference,
+  referencePictureUrl,
+  seedConcept,
+  startsFromIdea,
+  unbuiltReference
+};
+//# sourceMappingURL=make-365ZJ25L.js.map