@koda-sl/baker-cli 0.447.0 → 0.448.0-dev.ccc3c9a37

package/dist/make-NZHJ7ICV.js

@@ -0,0 +1,633 @@
+import {
+  liveViewerLookups
+} from "./chunk-BIZH3X6P.js";
+import {
+  buildSearchBody
+} from "./chunk-HKSLIV4T.js";
+import "./chunk-57XJ7QF7.js";
+import "./chunk-ICJFL7DU.js";
+import {
+  NO_FIT_HINT,
+  conceptFromFit,
+  fitReference,
+  notADesignReference,
+  resolveSourcePlatform
+} from "./chunk-AOCG7COT.js";
+import {
+  makeSeriesAd,
+  seriesMadeEnvelope
+} from "./chunk-UF55TADX.js";
+import {
+  runBaker
+} from "./chunk-O356YNIW.js";
+import "./chunk-G7QKXFQ2.js";
+import "./chunk-UUBHU2TY.js";
+import {
+  definitionFieldsOf,
+  fitsIdea,
+  ideaSpec,
+  isVideoIdea,
+  missingElements,
+  pooledCandidates,
+  referenceSearchesFor,
+  setDefinitionFields,
+  setSpecMessage,
+  unsourcedCopyLines,
+  withFitConcept
+} from "./chunk-MMBHCAON.js";
+import "./chunk-RH2H5PBV.js";
+import {
+  projectStaticBriefs
+} from "./chunk-YOARYFC2.js";
+import "./chunk-G7XY4T6K.js";
+import {
+  IDEAS_DIR,
+  checkIdeas,
+  coverageOf,
+  readCreativeRecords,
+  readIdeas,
+  readInsights,
+  readKnowledgeCorpus,
+  readPersonaIds,
+  sourcesClaims
+} from "./chunk-VKVIBQP3.js";
+import "./chunk-KWMYTVHI.js";
+import "./chunk-I4IVUAQN.js";
+import "./chunk-NFSLRRIE.js";
+import "./chunk-YTWNY3RF.js";
+import "./chunk-JF5LNI6O.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-F3IVR3V3.js";
+import "./chunk-LO7OQKUD.js";
+import "./chunk-WMN2WKNZ.js";
+import "./chunk-DGCUPJZD.js";
+import {
+  SPEC_SHAPES_HINT,
+  readAdSpec,
+  unwrittenProblems
+} from "./chunk-3KPQDXIU.js";
+import "./chunk-CAMX6OHF.js";
+import "./chunk-4KBWL7S4.js";
+import {
+  viewerFromKnowledge
+} from "./chunk-5HYSKH77.js";
+import "./chunk-KIGGMKAE.js";
+import "./chunk-LFGCOAB4.js";
+import "./chunk-DJPCTTUN.js";
+import "./chunk-BJEW3LST.js";
+import "./chunk-SSVZM3P6.js";
+import "./chunk-MAGSNHYB.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-I2DNBEV6.js";
+import {
+  apiPost
+} from "./chunk-MMOTJIV6.js";
+import "./chunk-2ZZR2SOF.js";
+import {
+  optionalChatId
+} from "./chunk-YPCVPDU7.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-D3RTGIT4.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/make.ts
+import { mkdtemp, readFile, rm, stat, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+import { defineCommand } from "citty";
+var FITS_TRIED = 6;
+var FITS_AT_ONCE = 3;
+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 in the idea's container: it searches on the idea's message for our viewer, then the container's strongest winners from any category, checks which fit us, 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>"
+  },
+  "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) {
+  return {
+    search: async (body) => (await apiPost("/api/ad-library/winners/search", body, {
+      timeoutMs: SEARCH_TIMEOUT_MS
+    }).catch(() => null))?.results ?? [],
+    fit: (platform, adId) => fitReference(root, platform, adId)
+  };
+}
+async function findCandidates(searches, deps) {
+  const results = await Promise.all(searches.map((search) => deps.search(search).catch(() => [])));
+  return pooledCandidates(
+    results.map((found) => found.flatMap(buildable)),
+    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();
+  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 kept = await Promise.race([firstFitting(candidates, asked), 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 });
+});
+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;
+    const layers = fit.fit.why_it_wins;
+    return {
+      picked: {
+        ...candidateOf(candidate),
+        why: [layers.disguise, layers.trigger, layers.logic].filter(Boolean).join("; "),
+        tried: index + 1,
+        fit: fit.fit
+      },
+      index
+    };
+  }
+  return { picked: noReference(candidates.length, checked, unchecked, lacking), index: -1 };
+}
+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 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 in this format wins on something this company has${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 --format-pattern <the idea's format>`). Do not stop the batch: build the other ideas."
+  };
+}
+function alreadyWritten(promptJson, slug) {
+  if (promptJson === null || promptJson === void 0) 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>.`
+  };
+}
+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);
+}
+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 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 = path.join(root, "src", "creatives", slug);
+  const fresh = !await stat(dir).catch(() => null);
+  const budget = AbortSignal.timeout(REFERENCE_MS);
+  const reference = await chooseReference(
+    args,
+    () => pickReference(
+      root,
+      referenceSearchesFor(idea, temperature).map(buildSearchBody),
+      void 0,
+      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);
+  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 = path.join(dir, "prompt.json");
+  const canvasPath = path.join(dir, `${slug}.canvas.json`);
+  let prompt;
+  try {
+    prompt = withFitConcept(await readFile(promptPath, "utf8"), seeded);
+    await writeFile(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 readFile(canvasPath, "utf8"));
+    if (projectStaticBriefs(canvas, JSON.parse(prompt)) > 0) {
+      await writeFile(canvasPath, `${JSON.stringify(canvas, null, 2)}
+`, "utf8");
+    }
+  } catch {
+  }
+  return null;
+}
+async function scaffoldFromIdea(idea, slug, viewerFlags) {
+  const dir = await mkdtemp(path.join(tmpdir(), "idea-spec-"));
+  const specPath = path.join(dir, "prompt.json");
+  await writeFile(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 });
+  }
+}
+async function recordIdea(root, slug, idea, evidence) {
+  const dir = path.join(root, "src", "creatives", slug);
+  const definitionPath = path.join(dir, "_definition.md");
+  const definition = await readFile(definitionPath, "utf8").catch(() => null);
+  if (definition !== null) {
+    await writeFile(definitionPath, setDefinitionFields(definition, { ...definitionFieldsOf(idea, evidence) }), "utf8");
+  }
+  const promptPath = path.join(dir, "prompt.json");
+  const prompt = isVideoIdea(idea) ? null : await readFile(promptPath, "utf8").catch(() => null);
+  if (prompt !== null) await writeFile(promptPath, setSpecMessage(prompt, idea.message), "utf8").catch(() => void 0);
+  const unsourcedCopy = prompt === null ? [] : await draftedClaims(root, prompt);
+  if (idea.status === "idea") {
+    const ideaPath = path.join(root, IDEAS_DIR, `${idea.id}.md`);
+    await writeFile(ideaPath, setDefinitionFields(await readFile(ideaPath, "utf8"), { status: "built" }), "utf8");
+  }
+  await runBaker(["canvas", "sync-definition", dir]);
+  return { dir, unsourcedCopy };
+}
+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"]) {
+    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}.` : "";
+  return `Built on proven ad ${reference.adId}: it carries ${carried}${why}.${won} 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 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 } : {}
+        }
+      } : {},
+      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).`
+      ] : [],
+      `Write the copy lines and the scene in src/creatives/${made.slug}/prompt.json${made.reference ? ": the drafted lines are the reference's, so keep one only if the Knowledge says it (badges, ratings and guarantees too)" : ""}. Say the message in the customer's words${quote ? ` ("${quote.slice(0, 80)}")` : ""}; keep \`message\` as it is.`,
+      ...!made.idea.format.startsWith("video_") ? [
+        "Before rendering: read .claude/skills/creative-canvas-ads/references/creative-intent.md and static-image-flow.md. Record the applicable intent, constraints and casting in _definition.md's body; carry them into prompt.json. Follow a direct brief without inventing a winner; for a reference adaptation, state its mechanism, transfer hypothesis and what must survive. 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."
+      ] : [],
+      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: path.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 readFile(path.join(root, "src", "creatives", slug, "prompt.json"), "utf8").then(
+      (text) => {
+        try {
+          return JSON.parse(text);
+        } catch {
+          return {};
+        }
+      },
+      (err) => err.code === "ENOENT" ? null : {}
+    );
+    const refused = alreadyWritten(written, slug);
+    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");
+    writeJson(
+      makeEnvelope({
+        slug,
+        idea,
+        check,
+        reference,
+        ...fromIdea ? { fromIdea } : {},
+        ...conceptUnseeded ? { conceptUnseeded } : {},
+        viewer: opts.adset ? { adset: opts.adset } : { temperature },
+        canvasPath: path.relative(root, String(scaffold.canvas_path ?? path.join(dir, `${slug}.canvas.json`))),
+        scaffoldHints: Array.isArray(scaffold.hints) ? scaffold.hints : [],
+        unsourcedCopy
+      })
+    );
+  }
+});
+export {
+  alreadyWritten,
+  handPickedReference,
+  makeCommand,
+  makeEnvelope,
+  noReference,
+  pickReference,
+  seedConcept,
+  unbuiltReference
+};
+//# sourceMappingURL=make-NZHJ7ICV.js.map