@koda-sl/baker-cli 0.477.0-dev.55c09e3e8 → 0.495.0-dev.c2b64ccca

package/dist/make-4XCSN76S.js

@@ -0,0 +1,1137 @@
+import {
+  buildSearchBody
+} from "./chunk-RVXN2YTM.js";
+import "./chunk-6EV5MXLQ.js";
+import "./chunk-4R7H4RV6.js";
+import {
+  NO_FIT_HINT,
+  conceptFromFit,
+  fitReference,
+  notADesignReference,
+  pictureOf,
+  resolveSourcePlatform
+} from "./chunk-T5HB6R4I.js";
+import {
+  makeSeriesAd,
+  seriesMadeEnvelope
+} from "./chunk-OFTU5XBQ.js";
+import "./chunk-WDAWTHQK.js";
+import {
+  runBaker
+} from "./chunk-QAOEVZYY.js";
+import {
+  parseDefinitionSourceFields
+} from "./chunk-SQQ4VBNI.js";
+import "./chunk-72QBQS63.js";
+import {
+  projectStaticBriefs,
+  thinkingOutline,
+  withThinking
+} from "./chunk-WZDKROPU.js";
+import "./chunk-L44WSWSZ.js";
+import {
+  audienceQuery,
+  definitionFieldsOf,
+  fitBetOf,
+  fitsIdea,
+  ideaSpec,
+  isOwnBrand,
+  isVideoIdea,
+  missingElements,
+  personaWho,
+  pooledCandidates,
+  rankedForOf,
+  referenceSearchesFor,
+  referenceWhereOf,
+  setDefinitionFields,
+  setSpecMessage,
+  setSpecViewer,
+  unsourcedCopyLines,
+  withFitConcept
+} from "./chunk-PALFKSJV.js";
+import {
+  IDEAS_DIR,
+  coverageOf,
+  readCreativeRecords,
+  readIdeas,
+  readInsights,
+  readKnowledgeCorpus,
+  readPersonaIds
+} from "./chunk-B2SAOVMU.js";
+import {
+  liveViewerLookups,
+  readPersonas
+} from "./chunk-IGOOLUE2.js";
+import {
+  castInventory
+} from "./chunk-BVMXTD4B.js";
+import "./chunk-AN7CMLYY.js";
+import {
+  avoidOf,
+  readCompanyReading,
+  readCreativeContext
+} from "./chunk-7XH4UQWS.js";
+import {
+  checkIdeas,
+  sourcesClaims
+} from "./chunk-S4ROJTDY.js";
+import "./chunk-YJAQWTS6.js";
+import "./chunk-MNPBPU3G.js";
+import "./chunk-WJNLQEOZ.js";
+import "./chunk-BITS62MF.js";
+import "./chunk-MMU6XHCH.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-6FHP2HIK.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-DS2ZRTAL.js";
+import "./chunk-XXU7XRMM.js";
+import "./chunk-XQ4KKF5E.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-SYED65QF.js";
+import {
+  SPEC_SHAPES_HINT,
+  readAdSpec,
+  unwrittenProblems
+} from "./chunk-5IGQ6IQO.js";
+import "./chunk-QK5PEHFX.js";
+import {
+  askAboutImages,
+  askAboutText
+} from "./chunk-QEW64BBR.js";
+import {
+  describeMarket,
+  marketFromCompanyDoc,
+  viewerFromKnowledge
+} from "./chunk-KPYDTIAI.js";
+import "./chunk-KIGGMKAE.js";
+import {
+  askJevQuestions
+} from "./chunk-4TBDEV7X.js";
+import "./chunk-EIJDXZW5.js";
+import "./chunk-2WRK44LZ.js";
+import "./chunk-3FFJYMKM.js";
+import "./chunk-MV2J73HP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-I2DNBEV6.js";
+import {
+  apiPost
+} from "./chunk-OSWCEDFE.js";
+import "./chunk-D53AAUG4.js";
+import {
+  optionalChatId
+} from "./chunk-FZKUUI3F.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-4WYEGE4N.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/make.ts
+import { mkdir as mkdir2, mkdtemp, 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)
+});
+function parseReferenceBrief(reply) {
+  const parsed = BriefSchema.safeParse(reply);
+  if (!parsed.success || !parsed.data.category) return null;
+  const { category, avoid, brands, wider, ...rest } = parsed.data;
+  const known = Object.fromEntries(Object.entries(rest).filter(([, v]) => v !== void 0));
+  return { category, ...known, avoid, brands, wider };
+}
+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}
+
+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"]
+}`;
+}
+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, ...facts } = company ?? { brands: [] };
+  return {
+    ...facts,
+    ...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-pick.ts
+var REFERENCE_PICK_MODEL = "~google/gemini-pro-latest";
+var REFERENCE_PICK_TIMEOUT_MS = 6e4;
+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)"}.${viewer}`;
+  }).join("\n");
+  const avoid = bet.avoid?.length ? ` The brand never uses: ${bet.avoid.join(", ")}.` : "";
+  const humour = bet.humour === "off_brand" ? " The brand does not joke in ads." : "";
+  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}.${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.
+
+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/reference-rank.ts
+var BUYERS = {
+  consumer: "people buying for themselves",
+  small_business: "small businesses buying for work",
+  enterprise: "large companies buying for work"
+};
+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(", ")}.` : "";
+  return `We sell: ${sells}${buyer}. Our ad says: "${bet.message}". It is for: ${bet.who}.${humour}${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?"
+];
+async function rankForBet(candidates, bet, ask = (questions) => askJevQuestions(questions)) {
+  if (candidates.length < 2) return [...candidates];
+  const ours = oursText(bet);
+  const questions = candidates.flatMap(
+    (c) => QUESTIONS.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: QUESTIONS.reduce((product, _, k) => {
+      const answer = answers[i * QUESTIONS.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/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, checks which fit us 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.
+
+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 --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)"
+  },
+  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)"
+  },
+  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;
+}
+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: (found) => rankForBet(
+        found.filter((c) => !isOwnBrand(c.advertiser, brands)),
+        rankedFor
+      ),
+      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
+  );
+  if (!deps.rank) return pooled;
+  const ranked = await deps.rank(pooled).catch(() => pooled);
+  return 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) : 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 = [];
+  for (const [index, candidate] of candidates.entries()) {
+    const fit = await fits[index];
+    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;
+    return { picked: pickedOf(candidate, fit.fit, index), 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) {
+  const fitting = (await allFits(fits)).flatMap((fit, index) => {
+    const candidate = candidates[index];
+    return candidate && fit.ok && fitsIdea(fit.fit) ? [{ index, candidate, fit: fit.fit }] : [];
+  });
+  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;
+  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 } : {}
+    },
+    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: "Nothing to do to go on: the ad starts from the idea rather than from another category's winners. To build on a proven ad, run make again in a few minutes."
+});
+var slowReference = () => ({
+  code: "REFERENCE_SLOW",
+  message: `Finding and checking a proven ad took longer than ${REFERENCE_MS / 1e3} s.`,
+  fix: "Nothing to do: the ad starts from the idea. To build on a proven ad anyway, run make again (the checks already made are kept) or pass --reference <adId>."
+});
+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 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] = await Promise.all([
+    readInsights(root),
+    readKnowledgeCorpus(root),
+    readPersonaIds(root),
+    readCreativeRecords(root)
+  ]);
+  const check = checkIdeas({ ideas, insights, knowledge, personas, ...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."
+    });
+  }
+  return { idea, check };
+}
+async function scaffoldIdea(root, idea, args, slug, temperature) {
+  const viewerFlags = args.adset ? ["--target-adset", args.adset] : ["--viewer-temperature", temperature];
+  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 rebuiltOn(recast, deps) {
+  const byHand = handPickedReference(recast.adId, recast.platform);
+  if ("code" in byHand) return byHand;
+  const fit = await deps.fit(byHand.platform, byHand.adId).catch(() => null);
+  if (!fit?.ok) return byHand;
+  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, pick) {
+  if (args.reference) {
+    const byHand = handPickedReference(args.reference, args.platform);
+    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) }),
+    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 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);
+  const recast = castRebuild(await readFile2(path2.join(dir, "_definition.md"), "utf8").catch(() => null), args);
+  const reference = await chooseReference(
+    args,
+    () => recast ? rebuiltOn(recast, deps) : 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 { scaffold: await scaffoldFromIdea(idea, slug, viewerFlags), reference: null, fromIdea: reference.message };
+  }
+  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 });
+    const slow = slowReference().message;
+    return { scaffold: await scaffoldFromIdea(idea, slug, viewerFlags), reference: null, fromIdea: slow };
+  }
+  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) });
+  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 };
+}
+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 canvas = JSON.parse(await readFile2(canvasPath, "utf8"));
+    if (projectStaticBriefs(canvas, JSON.parse(prompt)) > 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 companyName(root) {
+  const doc = await readFile2(path2.join(root, "COMPANY.md"), "utf8").catch(() => "");
+  const title = /^#\s+(.+?)\s*$/m.exec(doc)?.[1] ?? "";
+  return title.replace(/[*_`]/g, "").replace(/^(?:company|empresa|compañía)\s*:\s*/i, "") || void 0;
+}
+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, 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 }));
+    await writeFile2(
+      definitionPath,
+      withThinking(recorded, thinkingOutline({ idea, reference: thinkingReference, inventory, rules: castRules })),
+      "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);
+  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) {
+  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")}`);
+  } catch {
+    return [];
+  }
+}
+function makeArgsOf(args) {
+  const opts = {};
+  for (const key of ["slug", "adset", "reference", "platform", "spec", "series", "avatar"]) {
+    const value = flag(args[key]);
+    if (value) opts[key] = value;
+  }
+  if (args["from-idea"] === true) opts.fromIdea = true;
+  return opts;
+}
+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(/\.$/, "")}.` : "";
+  return `Built on proven ad ${reference.adId}: it carries ${carried}${why}.${won}${chosen} The canvas shows that ad as \`original\`. ${tell} and what it takes from it; ${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 " : "";
+  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. 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 before you write prompt.json. 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,
+      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)
+    ]
+  };
+}
+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"]),
+    chatId: optionalChatId() ?? null
+  });
+  if ("code" in made) fail(made);
+  writeJson(seriesMadeEnvelope({ ...made, canvasPath: path2.relative(root, made.canvasPath) }, 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);
+    const { idea, check } = 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 temperature = await viewerTemperature(root, opts.adset, idea.awareness);
+    const { scaffold, reference, fromIdea, conceptUnseeded } = await scaffoldIdea(root, idea, opts, slug, temperature);
+    if (scaffold.ok !== true) fail(scaffoldFailure(scaffold));
+    const { dir, unsourcedCopy } = await recordIdea(root, slug, idea, check?.evidence ?? "explore", reference);
+    writeJson(
+      makeEnvelope({
+        slug,
+        idea,
+        check,
+        reference,
+        ...fromIdea ? { fromIdea } : {},
+        ...conceptUnseeded ? { conceptUnseeded } : {},
+        viewer: opts.adset ? { adset: opts.adset } : { temperature },
+        canvasPath: path2.relative(root, String(scaffold.canvas_path ?? path2.join(dir, `${slug}.canvas.json`))),
+        scaffoldHints: Array.isArray(scaffold.hints) ? scaffold.hints : [],
+        unsourcedCopy
+      })
+    );
+  }
+});
+export {
+  alreadyWritten,
+  castFlags,
+  castRebuild,
+  handPickedReference,
+  makeCommand,
+  makeEnvelope,
+  noReference,
+  pickReference,
+  referencePictureUrl,
+  seedConcept,
+  unbuiltReference
+};
+//# sourceMappingURL=make-4XCSN76S.js.map