@koda-sl/baker-cli 0.534.0-dev.911a80433 → 0.535.0

package/dist/chunk-C2MBBIZ4.js

@@ -0,0 +1,604 @@
+import {
+  avatarsOf,
+  castCompany
+} from "./chunk-4O3FECSO.js";
+import {
+  readAvatars
+} from "./chunk-V3YJ3BTV.js";
+import {
+  memeRegister,
+  readCompanyReading,
+  readCreativeContext
+} from "./chunk-2MRK75I3.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-RJ675DP3.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-V6F2QWUZ.js";
+import {
+  bytesOf
+} from "./chunk-OQ4PTNNH.js";
+import {
+  CONCEPT_CARRY_LEVELS,
+  LOAD_BEARING_FIELDS,
+  decisionOf,
+  unfitReasons,
+  withDerivedHave
+} from "./chunk-7BJZF77Q.js";
+import {
+  askAboutImages,
+  rulesBlock
+} from "./chunk-ZN22VDFS.js";
+import {
+  AD_DESCRIBE_MODEL
+} from "./chunk-MCJ5I5LR.js";
+import {
+  apiGet
+} from "./chunk-X6AHLUC7.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-S6WPMD3V.js";
+
+// src/commands/winning-ads/fit.ts
+import { createHash } from "crypto";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+import sharp from "sharp";
+import { z } from "zod";
+
+// src/commands/canvas/library-reference.ts
+var LIBRARY_PLATFORMS = ["meta", "linkedin", "tiktok", "google"];
+function resolveSourcePlatform(flag) {
+  const value = flag?.trim();
+  if (!value) return { ok: true, platform: "meta" };
+  if (LIBRARY_PLATFORMS.includes(value)) return { ok: true, platform: value };
+  return {
+    ok: false,
+    message: `--source-platform "${value}" is not a library platform. Use one of: ${LIBRARY_PLATFORMS.join(", ")}.`
+  };
+}
+var PICK_A_DESIGN = "To build a static on a proven design, pick a Google display ad or a static from another platform (`baker winning-ads search --format static`); a YouTube ad is a video reference, read with `baker winning-ads content`.";
+function notADesignReference(platform, adId, ad) {
+  if (platform !== "google") return null;
+  if (ad.format === "text" || ad.google_ad_type === "search") {
+    return {
+      code: "NOT_A_DESIGN_REFERENCE",
+      message: `Google ad ${adId} is a search text ad: a reference for wording, not a design.`,
+      fix: `Read it with \`baker winning-ads content ${adId} --platform google\` and write our own copy. ${PICK_A_DESIGN}`
+    };
+  }
+  const assembled = ad.google_ad_type === "shopping" ? "a Shopping product listing, which Google builds from a product feed" : ad.google_ad_type === "app" ? "an app-install ad, which Google builds from the app's store page" : null;
+  if (assembled) {
+    return {
+      code: "NOT_A_DESIGN_REFERENCE",
+      message: `Google ad ${adId} is ${assembled}: there is no design of the advertiser's to build on.`,
+      fix: PICK_A_DESIGN
+    };
+  }
+  return null;
+}
+async function fetchLibraryReference(adId, platform) {
+  const data = await apiGet("/api/ad-library/ad-content", { id: adId, platform });
+  if (!data?.ad) throw new Error(`the library returned no ad for ${adId} on ${platform}`);
+  return data.ad;
+}
+function filled(entries) {
+  return Object.fromEntries(
+    Object.entries(entries).filter(([, v]) => v !== null && v !== void 0 && !(Array.isArray(v) && v.length === 0))
+  );
+}
+function libraryReferenceBlock(ad, ids) {
+  const textBlocks = ad.on_screen_text.flatMap(
+    (o) => o.text ? [{ text: o.text, ...o.role ? { role: o.role } : {}, ...o.position ? { position: o.position } : {} }] : []
+  );
+  const advertiser = ad.advertiser ?? void 0;
+  const advertiserId = ids.advertiserId ?? ad.advertiser_id ?? void 0;
+  return {
+    ad_id: ids.adId,
+    platform: ids.platform,
+    ...advertiser ? { advertiser } : {},
+    ...advertiserId ? { advertiser_id: advertiserId } : {},
+    ...ad.layout.format_pattern ? { format_pattern: ad.layout.format_pattern } : {},
+    layout: filled({
+      composition: ad.layout.composition,
+      focal_subject: ad.layout.focal_subject,
+      aspect_ratio: ad.layout.aspect_ratio,
+      background: ad.layout.background,
+      palette_mood: ad.layout.palette_mood,
+      colors: ad.layout.colors,
+      production: ad.layout.production,
+      aesthetic: ad.layout.aesthetic,
+      cta_in_image: ad.layout.cta_in_image,
+      markers: ad.layout.markers
+    }),
+    message: filled({
+      mechanism: ad.message.mechanism,
+      awareness: ad.message.awareness_stage,
+      sophistication: ad.message.sophistication,
+      angle: ad.angle,
+      hook_archetype: ad.hook_archetype,
+      pain_points: ad.message.pain_points,
+      desires: ad.message.desires,
+      value_props: ad.message.value_props,
+      objections_handled: ad.message.objections_handled,
+      proof: ad.message.proof,
+      risk_reversal: ad.message.risk_reversal
+    }),
+    offer: filled({
+      offer_type: ad.offer.offer_type,
+      pricing_model: ad.offer.pricing_model,
+      entry_price: ad.offer.entry_price,
+      no_credit_card: ad.offer.no_credit_card,
+      guarantee: ad.offer.guarantee,
+      guarantee_days: ad.offer.guarantee_days,
+      urgency: ad.offer.urgency,
+      bonus: ad.offer.bonus
+    }),
+    text_blocks: textBlocks,
+    copy: filled({ primary_text: ad.primary_text, headline: ad.headline, cta: ad.cta })
+  };
+}
+function referenceDescribeContext(reference, agentContext) {
+  const own = agentContext?.trim() || void 0;
+  if (!reference) return own;
+  const facts = [];
+  if (reference.advertiser) facts.push(`advertiser: ${reference.advertiser}`);
+  if (reference.format_pattern) facts.push(`container (format_pattern): ${reference.format_pattern}`);
+  if (typeof reference.layout.composition === "string") facts.push(`composition: ${reference.layout.composition}`);
+  if (typeof reference.message.mechanism === "string") facts.push(`persuasion mechanism: ${reference.message.mechanism}`);
+  if (typeof reference.message.awareness === "string") facts.push(`awareness stage: ${reference.message.awareness}`);
+  if (typeof reference.offer.offer_type === "string") facts.push(`offer: ${reference.offer.offer_type}`);
+  if (reference.text_blocks.length > 0) {
+    facts.push(
+      `text blocks: ${reference.text_blocks.map((b) => `"${b.text}"${b.role ? ` (${b.role})` : ""}`).join("; ")}`
+    );
+  }
+  const library = `The ads library has already read this ad: ${facts.join(". ")}. Your blueprint must agree with it on the container and the mechanism; refine and detail them, never contradict them, and transcribe the text blocks exactly.`;
+  return own ? `${own}. ${library}` : library;
+}
+function mergeReferenceIntoBlueprint(blueprint, reference) {
+  if (!reference || !blueprint || typeof blueprint !== "object" || Array.isArray(blueprint)) return blueprint;
+  return { ...blueprint, reference };
+}
+
+// src/commands/winning-ads/fit.ts
+var Layers = z.object({
+  disguise: z.string().optional(),
+  voice: z.string().optional(),
+  trigger: z.string().optional(),
+  attention: z.string().optional(),
+  logic: z.string().optional()
+}).strip();
+var FitAnswerSchema = z.object({
+  why_it_wins: Layers.default({}),
+  load_bearing: z.array(z.preprocess(withDerivedHave, z.object(LOAD_BEARING_FIELDS).strip())).default([]),
+  verdict: z.enum(["use", "adapt", "reject"]),
+  transfer_note: z.string().optional(),
+  brand_presence: z.enum(["native", "standard"]).optional(),
+  recognition: z.string().optional(),
+  carry: z.enum(CONCEPT_CARRY_LEVELS).optional(),
+  carry_why: z.string().optional(),
+  /** Asked only with a bet: would the viewer of the ad we are making stop for this one. */
+  our_viewer: z.object({ stops: z.enum(["yes", "maybe", "no"]), why: z.string().default("") }).strip().optional().catch(void 0)
+}).refine((fit) => fit.load_bearing.some((l) => l.job === "stop") && fit.load_bearing.some((l) => l.job === "proof"), {
+  message: "name what stops the scroll (job: stop) and the proof (job: proof) among load_bearing"
+}).transform(
+  (fit) => fit.verdict !== "reject" && fit.load_bearing.some((l) => decisionOf(l) === "impossible") ? { ...fit, verdict: "reject" } : fit
+);
+function audienceLines(audience) {
+  return audience?.memes === "off_brand" ? [
+    `Our brand's voice does not run memes${audience.why ? ` (${audience.why})` : ""}: a meme or a reaction face that does the stop job is impossible for us (decision impossible, rule: our brand's voice does not run memes), and the verdict is reject.`
+  ] : [];
+}
+function rejectForAudience(fit, audience) {
+  const reasons = unfitReasons(fit, audience).filter((r) => r.includes("does not run memes"));
+  if (reasons.length === 0) return fit;
+  return { ...fit, verdict: "reject", transfer_note: reasons.join("; ") };
+}
+function fitKeyOf(bet, audience) {
+  const parts = [bet ? JSON.stringify(bet) : "", audience ? `memes:${audience.memes}:${audience.why ?? ""}` : ""];
+  return parts.some(Boolean) ? parts.join("|") : void 0;
+}
+function castLines(cast) {
+  const ours = cast.filter((a) => a.castable).map((a) => `@${a.handle} (${a.real ? "a real person" : "made for a role"}: ${a.who})`);
+  const theirs = cast.filter((a) => !a.castable).map(
+    (a) => `@${a.handle}: a ${a.relation === "unknown" ? "customer" : a.relation} (${a.who}); only in an ad quoting their own published words, never a reaction face or a model`
+  );
+  return [
+    `The people OUR ads may show: our team's, founder's or a made-for-a-role Avatar${ours.length > 0 ? ` (${ours.join("; ")})` : " (none made yet)"}, unless our rules forbid made-up people.`,
+    ...theirs.length > 0 ? [
+      `Avatars of people who are not ours to cast: ${theirs.join("; ")}. A customer's face appears only in a testimonial ad that quotes them.`
+    ] : ["A customer's face appears only in a testimonial ad that quotes them."]
+  ];
+}
+function buildFitPrompt(input) {
+  const facts = libraryFacts(input.library);
+  return [
+    "The image is a winning ad by another advertiser. We want to build an ad for OUR company on its concept: keep why it wins, change everything else to ours.",
+    ...facts.length > 0 ? [`The ads library read it as: ${facts.join(". ")}.`] : [],
+    "",
+    "What OUR company has (its own documents):",
+    input.knowledge.trim() || "(nothing written down yet)",
+    ...input.cast ? castLines(input.cast) : [],
+    ...audienceLines(input.audience),
+    "",
+    ...input.bet ? [...betLines(input.bet), ""] : [],
+    "Answer in English:",
+    "why_it_wins, in layers, one short phrase each, empty when a layer does nothing: disguise (what the ad pretends to be: a note, a tweet, a newspaper, a chat, a plain ad), voice (who speaks and how: a peer, a founder, a brand), trigger (the emotion or need it pulls: a free gift, fear of a hidden loss, status, curiosity), attention (what stops the scroll), logic (why it convinces: reciprocity, social proof, a comparison, a price anchor).",
+    'load_bearing: the 2-5 elements the ad stops working without (never decoration), always these two: what stops the scroll (job "stop": the face or reaction, the joke, the meme people know, the odd photo; when attention names a face, that face is it) and the proof that makes it believed (job "proof": the \u2717/\u2713 checklist, the before and after, the rating, the result shown), then any other its why_it_wins rests on (job "other"). Name each as it shows in the picture ("the two reaction faces of a famous sitcom boss", "the red \u2717 and green \u2713 marks before each line"), never as an idea ("a contrast", "relatable fatigue").',
+    "Each with: element, job, needs (what it takes to carry it), have (have: we have it as it is; adapt: something of ours can do its job; missing: we have nothing that does), decision (keep: as it is; replace: with something of ours that does the same job, named in ours; impossible: nothing of ours may do its job; a person is never kept as theirs: the advertiser's own people, or a celebrity who is not a meme template, are replaced with one of ours; a famous meme's job is done by a meme our buyer persona knows and relates to, from `baker images meme`, our words on it, whenever our brand's voice runs memes: the proven ad's own template only when it is also the one our persona knows best; a two-panel reaction meme becomes two real templates, top and bottom; never a customer's face: a customer appears only in an ad quoting their own words), ours (what of ours does its job, concretely, one thing of ours, never a choice between two: a meme our buyer persona knows and relates to, from `baker images meme` with our words, our team's, founder's or a made-for-a-role Avatar, the \u2713/\u2717 marks in our colours; never invent an offer, a gift, a price, a review or a customer we do not have), rule (only when one of the company's rules forbids it as it is: that rule, quoted word for word).",
+    `A rule forbids only what it names: "no stock photography" forbids stock photos, never a meme's reaction face, the company's own people or its Avatars; a rule on logos, buttons or colours says nothing about faces.`,
+    "verdict: use (it transfers as it is), adapt (it transfers with ours in place of theirs), reject (what stops the scroll, the proof or another load-bearing element is impossible for us: without it our version loses why it wins).",
+    "transfer_note: one sentence on how the idea becomes ours, or why it cannot.",
+    "brand_presence: native when the disguise only works without looking like an ad (the logo as the sender's picture, no big button), else standard.",
+    'recognition: what kind of product a stranger must take OUR version for in one second, never its format ("a trade course", "a social media API for developers", "a payroll app").',
+    "carry: what made it a winner, so what OUR ad takes from it: whole_ad (it wins as one piece: its disguise, layout and hook together; ours keeps all three with our words, brand and pictures), layout (its composition or container does the work: ours keeps that arrangement), hook (its opening line or first visual stops the scroll: ours opens on the same pattern in our words), angle (the argument or need it pulls wins, its look is ordinary: ours keeps the argument and looks like ours). carry_why: one sentence on why that level.",
+    ...input.bet ? [
+      "our_viewer: would the viewer of the ad we are making stop on THIS ad's move, made ours? stops: yes, maybe or no; why: one sentence naming what in it would or would not reach them (their age, life, market, what they care about). An ad that wins with another audience is no reference for ours."
+    ] : [],
+    "",
+    `Reply with only this JSON: {"why_it_wins":{"disguise":"","voice":"","trigger":"","attention":"","logic":""},"load_bearing":[{"element":"","job":"stop|proof|other","needs":"","have":"have|adapt|missing","decision":"keep|replace|impossible","ours":"","rule":""}],"verdict":"use|adapt|reject","transfer_note":"","brand_presence":"native|standard","recognition":"","carry":"whole_ad|layout|hook|angle","carry_why":""${input.bet ? ',"our_viewer":{"stops":"yes|maybe|no","why":""}' : ""}}`
+  ].join("\n");
+}
+function libraryFacts(lib) {
+  return [
+    lib.advertiser ? `advertiser: ${lib.advertiser}` : "",
+    lib.format_pattern ? `container: ${lib.format_pattern}` : "",
+    lib.mechanism ? `persuasion mechanism: ${lib.mechanism}` : "",
+    lib.awareness ? `awareness stage: ${lib.awareness}` : "",
+    lib.offer ? `offer: ${lib.offer}` : "",
+    lib.winner_category ? `evidence it won: ${lib.winner_category}` : "",
+    lib.angle ? `angle: ${lib.angle}` : "",
+    lib.hook_archetype ? `hook: ${lib.hook_archetype}` : "",
+    lib.composition ? `composition: ${lib.composition}` : "",
+    lib.text && lib.text.length > 0 ? `its words: ${lib.text.map((t) => `"${t}"`).join("; ")}` : ""
+  ].filter(Boolean);
+}
+function betLines(bet) {
+  return [
+    "The ad we are making with it:",
+    `- For: ${bet.who}${bet.market ? `, ${bet.market}` : ""}${bet.awareness ? `; awareness: ${bet.awareness}` : ""}`,
+    `- It says: ${bet.message}${bet.angle ? ` (angle: ${bet.angle})` : ""}`,
+    ...bet.shows ? [
+      `- What it shows first: ${bet.shows}. A reference whose picture cannot be remade to show this does not fit (verdict reject), however good its buyer match.`
+    ] : [],
+    ...bet.quotes && bet.quotes.length > 0 ? [`- In our customers' own words: ${bet.quotes.map((q) => `"${q}"`).join("; ")}`] : []
+  ];
+}
+function fitHints(fit, adId, platform = "meta", audience) {
+  const reasons = unfitReasons(fit, audience);
+  if (fit.verdict === "reject" || reasons.length > 0) {
+    return [
+      `Pick another reference: ${reasons.length > 0 ? reasons.join("; ") : "this one wins on something we cannot supply"}, and our version would lose why it won.${fit.transfer_note ? ` ${fit.transfer_note}` : ""} Do not stop or ask the person: check the next candidates (\`baker winning-ads fit <adId> --platform ${platform}\`, about three) and scaffold the first that fits.`
+    ];
+  }
+  const keeps = fit.load_bearing.map((l) => {
+    const job = l.job === "stop" ? "what stops the scroll" : l.job === "proof" ? "the proof" : `"${l.element}"`;
+    return decisionOf(l) === "replace" && l.ours?.trim() ? `${job} as "${l.ours.trim()}"` : `"${l.element}"`;
+  });
+  return [
+    `It fits (${fit.verdict}). Scaffold it: \`baker canvas scaffold-static-ad --source-ad-id ${adId} --source-platform ${platform} --slug <slug>\`: prompt.json's \`concept\` is seeded from this fit, and every render keeps ${keeps.join(", ") || "its idea"}.`,
+    ...fit.brand_presence === "native" ? [
+      "The concept is a native disguise: the brand shows as the sender (the logo small, as its picture or signature) and there is no big button; prompt.json says `brand_presence: native`."
+    ] : []
+  ];
+}
+var NO_FIT_HINT = "No fit was made of this reference";
+function conceptFromFit(fit, adId) {
+  return {
+    concept: {
+      reference_ad_id: adId,
+      why_it_wins: fit.why_it_wins,
+      load_bearing: fit.load_bearing,
+      verdict: fit.verdict,
+      ...fit.transfer_note ? { transfer_note: fit.transfer_note } : {},
+      // A fit that names no level (cached before `carry`) is read as the whole ad, and says so.
+      carry: fit.carry ?? "whole_ad",
+      ...fit.carry_why ? { carry_why: fit.carry_why } : {}
+    },
+    ...fit.brand_presence ? { brand_presence: fit.brand_presence } : {},
+    ...fit.recognition ? { recognition: fit.recognition } : {}
+  };
+}
+var MAX_DOC_CHARS = 6e3;
+var MAX_ENTRY_CHARS = 1200;
+var KNOWLEDGE_COLLECTIONS = ["offers", "products", "personas", "positioning"];
+function readText(file) {
+  return readFile(file, "utf8").catch(() => null);
+}
+function brandLines(brand) {
+  const lines = [
+    ...brand?.voice ? [`Voice: ${brand.voice}`] : [],
+    ...brand?.imagery ? [`Pictures: ${brand.imagery}`] : [],
+    ...brand?.logoUsage ? [`Logo: ${brand.logoUsage}`] : []
+  ];
+  return lines.length > 0 ? `The brand:
+${lines.join("\n")}` : "";
+}
+async function readKnowledge(root, readers) {
+  const parts = [];
+  const company = await readText(path.join(root, "COMPANY.md"));
+  if (company) parts.push(`COMPANY.md:
+${company.slice(0, MAX_DOC_CHARS)}`);
+  const context = await readCreativeContext(root, { kind: "static" }, readers ? { readers } : {});
+  const brand = brandLines(context.brand);
+  if (brand) parts.push(brand);
+  const rules = rulesBlock(context.rules);
+  if (rules) parts.push(rules);
+  for (const collection of KNOWLEDGE_COLLECTIONS) {
+    const dir = path.join(root, "src", "content", collection);
+    const files = (await readdir(dir, { recursive: true }).catch(() => [])).filter(
+      (f) => f.endsWith(".md")
+    );
+    for (const file of files.sort().slice(0, 12)) {
+      const text = await readText(path.join(dir, file));
+      if (text) parts.push(`${collection}/${file}:
+${text.slice(0, MAX_ENTRY_CHARS)}`);
+    }
+  }
+  return parts.join("\n\n");
+}
+var ReviewSchema = z.object({
+  reviewText: z.string(),
+  sourceType: z.string().optional(),
+  rating: z.number().optional()
+});
+function reviewsForFit(data) {
+  const list = Array.isArray(data) ? data : [];
+  const lines = list.slice(0, 15).flatMap((item) => {
+    const review = ReviewSchema.safeParse(item);
+    if (!review.success || !review.data.reviewText.trim()) return [];
+    const { reviewText, sourceType, rating } = review.data;
+    const label = [sourceType, rating !== void 0 ? `${rating}\u2605` : ""].filter(Boolean).join(" ");
+    return [`- ${label ? `${label} ` : ""}"${reviewText.slice(0, 160)}"`];
+  });
+  return lines.length > 0 ? `Reviews we have (${lines.length}):
+${lines.join("\n")}` : "Reviews we have: none on file.";
+}
+async function readReviews() {
+  try {
+    return reviewsForFit(await apiGet("/api/testimonials", { limit: "15" }));
+  } catch {
+    return "";
+  }
+}
+function fitCachePath(root, platform, adId) {
+  return path.join(root, "canvas", ".cache", "fit", `${platform}-${adId.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`);
+}
+function readCachedFit(root, platform, adId) {
+  return readFitFile(fitCachePath(root, platform, adId));
+}
+async function readFitFile(file) {
+  const raw = await readText(file);
+  if (!raw) return null;
+  try {
+    const parsed = FitAnswerSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+var DESCRIPTION = "Does a winning ad fit this company? One vision call reads the reference beside what the company has (COMPANY.md, the brand's rules, the offers, products and personas in the Knowledge, its reviews, its Avatars) and says why the ad wins (disguise, voice, trigger, attention, logic), the elements it stops working without (always what stops the scroll, `job: stop`, and its proof, `job: proof`), what our ad does with each (`decision`: keep, replace with `ours`, or impossible, quoting the `rule` that forbids it), and a verdict: use, adapt or reject (a stop or proof that is impossible for us is a reject). Start here before scaffolding a static ad from the library: check about three candidates, scaffold only one that fits. `baker canvas scaffold-static-ad --source-ad-id <adId>` then seeds prompt.json's `concept` from this verdict, and a run refuses a rejected concept. Example: baker winning-ads fit 1310524137919413 --platform meta. Output is compact; --full adds the whole read.";
+var ARGS = {
+  "ad-id": { type: "positional", required: true, description: "The library ad id (from search/winners/feed)." },
+  platform: {
+    type: "string",
+    required: false,
+    description: `Which platform the ad id is on: ${LIBRARY_PLATFORMS.join("|")} (default meta). The fit reads a still picture: a static ad (on google, a display ad). A video ad, YouTube included, is read with \`content\`; a Google search, Shopping or app ad is refused.`
+  },
+  full: {
+    type: "boolean",
+    required: false,
+    default: false,
+    description: "Add the whole read: every layer, need and note."
+  }
+};
+registerSchema({ command: "winning-ads.fit", description: DESCRIPTION, args: ARGS });
+async function pictureOf(url) {
+  if (!url) return null;
+  try {
+    const bytes = await bytesOf(url);
+    return (await sharp(bytes).resize(1024, 1024, { fit: "inside" }).jpeg({ quality: 85 }).toBuffer()).toString(
+      "base64"
+    );
+  } catch {
+    return null;
+  }
+}
+function libraryRead(ad) {
+  return {
+    ...ad.advertiser ? { advertiser: ad.advertiser } : {},
+    ...ad.layout.format_pattern ? { format_pattern: ad.layout.format_pattern } : {},
+    ...ad.message.mechanism ? { mechanism: ad.message.mechanism } : {},
+    ...ad.message.awareness_stage ? { awareness: ad.message.awareness_stage } : {},
+    ...ad.offer.offer_type ? { offer: ad.offer.offer_type } : {},
+    ...ad.winner_category ? { winner_category: ad.winner_category } : {},
+    ...ad.angle ? { angle: ad.angle } : {},
+    ...ad.hook_archetype ? { hook_archetype: ad.hook_archetype } : {},
+    ...ad.layout.composition ? { composition: ad.layout.composition } : {},
+    text: ad.on_screen_text.flatMap((o) => o.text ? [o.text] : []).slice(0, 10)
+  };
+}
+async function fitOnce(root, platform, adId, ask, bet) {
+  const betFile = bet ? fitCachePath(root, platform, `${adId}--${betKey(bet)}`) : null;
+  const cached = betFile ? await readFitFile(betFile) : await readCachedFit(root, platform, adId);
+  if (cached) return cached;
+  const fit = await ask();
+  if (!fit) return null;
+  const text = `${JSON.stringify(fit, null, 2)}
+`;
+  for (const file of [betFile, fitCachePath(root, platform, adId)]) {
+    if (!file) continue;
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, text, "utf8");
+  }
+  return fit;
+}
+function betKey(bet) {
+  return createHash("sha256").update(bet).digest("hex").slice(0, 16);
+}
+var FIT_REQUEST = { temperature: 0, seed: 0 };
+async function askFit(jpeg, prompt, onSpend) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const reply = await askAboutImages(
+      AD_DESCRIBE_MODEL,
+      [jpeg],
+      prompt,
+      onSpend,
+      void 0,
+      void 0,
+      void 0,
+      attempt === 0 ? FIT_REQUEST : {}
+    );
+    const parsed = FitAnswerSchema.safeParse(reply);
+    if (parsed.success) return parsed.data;
+  }
+  return null;
+}
+async function readFitReference(adId, platform) {
+  let ad;
+  try {
+    ad = await fetchLibraryReference(adId, platform);
+  } catch (e) {
+    return {
+      ok: false,
+      failure: {
+        code: "NOT_FOUND",
+        message: `The library could not return ad ${adId} on ${platform} (${e instanceof Error ? e.message : String(e)}).`,
+        fix: "Check the ad id and --platform against `baker winning-ads search`."
+      }
+    };
+  }
+  const refusal = notADesignReference(platform, adId, ad);
+  if (refusal) return { ok: false, failure: refusal };
+  if (ad.format === "video") {
+    return {
+      ok: false,
+      failure: {
+        code: "VIDEO_REFERENCE",
+        message: `Ad ${adId} is a video: the fit reads still pictures.`,
+        fix: `Read it with \`baker winning-ads content ${adId} --platform ${platform}\` (transcript, on-screen text, pacing) and build the video with \`baker canvas scaffold-ad\`. For a static, pick a static ad.`
+      }
+    };
+  }
+  const jpeg = await pictureOf(ad.media_url);
+  if (!jpeg) {
+    return {
+      ok: false,
+      failure: {
+        code: "NOT_FOUND",
+        message: `Ad ${adId} has no picture the fit can read.`,
+        fix: "Pick a static ad with a picture."
+      }
+    };
+  }
+  return { ok: true, ad, jpeg };
+}
+async function fitReference(root, platform, adId, bet) {
+  let failure = null;
+  const audience = memeRegister(await readCompanyReading(root).catch(() => null));
+  const askFor = async () => {
+    const read = await readFitReference(adId, platform);
+    if (!read.ok) {
+      failure = read.failure;
+      return null;
+    }
+    const { ad, jpeg } = read;
+    const knowledge = [await readKnowledge(root), await readReviews()].filter(Boolean).join("\n\n");
+    const company = await castCompany(root);
+    const cast = await readAvatars("/api/avatars", { status: "ready" }).then(
+      (response) => avatarsOf(response, company),
+      () => void 0
+    );
+    const prompt = buildFitPrompt({
+      library: libraryRead(ad),
+      knowledge,
+      ...bet ? { bet } : {},
+      ...cast ? { cast } : {},
+      ...audience ? { audience } : {}
+    });
+    const spent = [];
+    const answer = await askFit(jpeg, prompt, (u) => spent.push(u));
+    await holdUnbilledSpend(path.join(root, "canvas", ".cache"), spent);
+    return answer && rejectForAudience(answer, audience);
+  };
+  const fit = await fitOnce(root, platform, adId, askFor, bet ? fitKeyOf(bet, audience) : void 0);
+  if (fit) return { ok: true, fit };
+  return {
+    ok: false,
+    error: failure ?? {
+      code: "UNAVAILABLE",
+      message: "The fit model did not answer (no gateway key here, or it failed twice).",
+      fix: "Run it again, or read the reference yourself with `baker winning-ads content <adId> --full` and write prompt.json's `concept` by hand."
+    }
+  };
+}
+var fitCommand = defineCommand({
+  meta: { name: "fit", description: DESCRIPTION },
+  args: ARGS,
+  async run({ args }) {
+    const adId = String(args["ad-id"]);
+    const platformResult = resolveSourcePlatform(args.platform ? String(args.platform) : void 0);
+    if (!platformResult.ok) {
+      writeJson({ ok: false, error: { code: "INVALID_ARGUMENT", message: platformResult.message } });
+      process.exit(1);
+    }
+    const platform = platformResult.platform;
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const result = await fitReference(root, platform, adId);
+    if (!result.ok) {
+      writeJson({ ok: false, error: result.error });
+      process.exit(1);
+    }
+    const fit = result.fit;
+    const why = [fit.why_it_wins.disguise, fit.why_it_wins.trigger, fit.why_it_wins.logic].filter(Boolean).join("; ");
+    writeJson({
+      ok: true,
+      data: {
+        ad_id: adId,
+        verdict: fit.verdict,
+        why_it_wins: why,
+        load_bearing: fit.load_bearing.map((l) => ({
+          element: l.element,
+          ...l.job ? { job: l.job } : {},
+          decision: decisionOf(l),
+          ...l.ours ? { ours: l.ours } : {},
+          ...l.rule ? { rule: l.rule } : {}
+        })),
+        ...fit.brand_presence ? { brand_presence: fit.brand_presence } : {},
+        ...fit.carry ? { carry: fit.carry } : {},
+        ...args.full ? { read: fit } : {}
+      },
+      hints: fitHints(fit, adId, platform, memeRegister(await readCompanyReading(root).catch(() => null)))
+    });
+  }
+});
+
+export {
+  LIBRARY_PLATFORMS,
+  resolveSourcePlatform,
+  notADesignReference,
+  fetchLibraryReference,
+  libraryReferenceBlock,
+  referenceDescribeContext,
+  mergeReferenceIntoBlueprint,
+  FitAnswerSchema,
+  rejectForAudience,
+  fitKeyOf,
+  buildFitPrompt,
+  fitHints,
+  NO_FIT_HINT,
+  conceptFromFit,
+  readKnowledge,
+  reviewsForFit,
+  fitCachePath,
+  readCachedFit,
+  pictureOf,
+  fitOnce,
+  fitReference,
+  fitCommand
+};
+//# sourceMappingURL=chunk-C2MBBIZ4.js.map

package/dist/chunk-C4PD5NES.js

@@ -0,0 +1,26 @@
+import {
+  writeJsonEnvelope
+} from "./chunk-SBFNGJ4C.js";
+import {
+  apiGet
+} from "./chunk-X6AHLUC7.js";
+
+// src/available-accounts.ts
+var AVAILABLE_ARG = {
+  type: "boolean",
+  description: "List everything the connected login reaches, each marked selected: true|false. Use it when the account, property, site or container the user means is not in the plain list.",
+  required: false
+};
+async function writeAvailableAccounts(platform, onError) {
+  try {
+    writeJsonEnvelope(await apiGet("/api/connections/available", { platform }));
+  } catch (err) {
+    onError(err);
+  }
+}
+
+export {
+  AVAILABLE_ARG,
+  writeAvailableAccounts
+};
+//# sourceMappingURL=chunk-C4PD5NES.js.map