@koda-sl/baker-cli 0.524.0 → 0.525.0

package/dist/check-65K6NOU4.js

@@ -0,0 +1,107 @@
+import {
+  readAdWords,
+  ruleRefusal
+} from "./chunk-QNWDGKGN.js";
+import "./chunk-ED3OAFEO.js";
+import "./chunk-XZLGG2AT.js";
+import {
+  readAllRules
+} from "./chunk-N727QO5G.js";
+import {
+  ruleTells
+} from "./chunk-IGG52H7X.js";
+import "./chunk-KL4H62CA.js";
+import "./chunk-TMVNSRSX.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-ER3V3FVG.js";
+import "./chunk-AEUKCVG6.js";
+import {
+  selectRules
+} from "./chunk-SGEHQTEJ.js";
+import "./chunk-MCJ5I5LR.js";
+import {
+  marketFromCompanyDoc
+} from "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import "./chunk-DGWSMAKI.js";
+import "./chunk-TCYK35RZ.js";
+import "./chunk-G2NUIZ74.js";
+import "./chunk-OMORXBRN.js";
+import "./chunk-HVJJEQDQ.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-46YLDIQG.js";
+import "./chunk-DPPV45D5.js";
+import "./chunk-DERQLVKB.js";
+import "./chunk-ABXVFHTG.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-UCI6ZGUF.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/check.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+var DESCRIPTION = `Read every creative already made against the company's rules as they stand now: which ads say words a rule bans, or leave out words a rule requires. Run it after adding a rule (\`baker creatives rules add\`); nothing is re-rendered or marked stale, so ask the person which ads to correct.
+Start here: baker creatives check
+  baker creatives check --slug mba-ia-online   # one creative`;
+var ARGS = {
+  slug: { type: "string", description: "One creative (src/creatives/<slug>/); left out, every one", required: false }
+};
+registerSchema({ command: "creatives.check", description: DESCRIPTION, args: ARGS });
+function checkCreatives(ads, rules, companyLanguage) {
+  const breaking = ads.flatMap(({ slug, ad }) => {
+    const held = selectRules(
+      rules,
+      {
+        kind: ad.kind,
+        ...ad.product ? { product: ad.product } : {},
+        ...ad.platform ? { platform: ad.platform } : {},
+        ...ad.platforms ? { platforms: ad.platforms } : {}
+      },
+      ad.waived
+    );
+    const refusal = ruleRefusal(ruleTells(ad.lines, held, ad.language ?? companyLanguage));
+    return refusal ? [{ creative: slug, broken: refusal.problems }] : [];
+  });
+  return { checked: ads.length, breaking };
+}
+async function readAds(root, slug) {
+  const dir = path.join(root, "src", "creatives");
+  const slugs = slug ? [slug] : (await readdir(dir, { withFileTypes: true }).catch(() => [])).filter((e) => e.isDirectory() && !e.name.startsWith("_")).map((e) => e.name).sort();
+  const ads = await Promise.all(slugs.map(async (s) => ({ slug: s, ad: await readAdWords(path.join(dir, s)) })));
+  return ads.flatMap(({ slug: s, ad }) => ad ? [{ slug: s, ad }] : []);
+}
+var checkCommand = defineCommand({
+  meta: { name: "check", description: DESCRIPTION },
+  args: ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const slug = typeof args.slug === "string" && args.slug ? args.slug : void 0;
+    const [ads, rules, companyDoc] = await Promise.all([
+      readAds(root, slug),
+      readAllRules(root),
+      readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => null)
+    ]);
+    const report = checkCreatives(ads, rules, marketFromCompanyDoc(companyDoc)?.language);
+    writeJson({
+      ok: true,
+      data: report,
+      hints: report.breaking.length > 0 ? [
+        `${report.breaking.length} of ${report.checked} ads break a rule now in force. Tell the person which, and correct only the ones they want: edit the words in that ad's prompt.json and run it again, or waive the rule there if the person asked for those words.`
+      ] : [`None of the ${report.checked} ads breaks a wording rule now in force.`]
+    });
+  }
+});
+export {
+  checkCommand,
+  checkCreatives
+};
+//# sourceMappingURL=check-65K6NOU4.js.map

package/dist/chunk-2AI7CZGS.js

@@ -0,0 +1,100 @@
+import {
+  writeOutput
+} from "./chunk-UCI6ZGUF.js";
+
+// src/commands/images/providerHits.ts
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function compactHit(hit) {
+  const inLibrary = hit.source === "library";
+  return {
+    source: str(hit.source) ?? "",
+    url: str(hit.url) ?? "",
+    imageId: str(hit.imageId) ?? (inLibrary ? str(hit._id) : void 0),
+    imageUrl: str(hit.imageUrl) ?? (inLibrary ? str(hit.url) : void 0),
+    name: str(hit.name),
+    width: num(hit.width),
+    height: num(hit.height)
+  };
+}
+function providerHitNormalizer(record, full) {
+  const compact = compactHit(record);
+  if (!full) {
+    return compact;
+  }
+  const group = asRecord(record.group);
+  return {
+    ...compact,
+    externalUrl: str(record.externalUrl),
+    externalId: str(record.externalId),
+    description: str(record.description),
+    tags: Array.isArray(record.tags) ? record.tags : [],
+    aspectRatio: num(record.aspectRatio),
+    dominantColor: str(record.dominantColor),
+    score: num(record.score),
+    deduped: typeof record.deduped === "boolean" ? record.deduped : void 0,
+    alsoInLibrary: str(record.alsoInLibrary),
+    groupKey: str(group.key)
+  };
+}
+var FIND_DESCRIPTION_CHARS = 160;
+function clip(text, max) {
+  if (text === void 0 || text.length <= max) return text;
+  return `${text.slice(0, max).trimEnd()}\u2026`;
+}
+function compactFindHit(hit) {
+  const score = num(hit.score);
+  return {
+    ...compactHit(hit),
+    description: clip(str(hit.description), FIND_DESCRIPTION_CHARS),
+    score: score === void 0 ? void 0 : Math.round(score * 100) / 100
+  };
+}
+function compactFindResponse(data) {
+  return {
+    groups: {
+      library: data.groups.library.map((hit) => compactFindHit(hit)),
+      external: data.groups.external.map((hit) => compactFindHit(hit))
+    },
+    meta: data.meta,
+    ingested: data.ingested
+  };
+}
+function readOutputFlags(args) {
+  const format = typeof args.output === "string" && args.output.length > 0 ? args.output : "json";
+  const rawFields = typeof args.fields === "string" && args.fields.length > 0 ? args.fields : void 0;
+  return {
+    format,
+    fields: rawFields ? rawFields.split(",").filter(Boolean) : void 0,
+    full: args.full === true
+  };
+}
+function writeProviderHits(data, hits, args, hints) {
+  const { format, fields, full } = readOutputFlags(args);
+  const envelope = {
+    ok: true,
+    data: format === "json" ? data : hits,
+    ...hints.length > 0 ? { hints } : {}
+  };
+  writeOutput(envelope, format, fields, full, providerHitNormalizer);
+}
+var OUTPUT_ARGS = {
+  output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+  fields: { type: "string", description: "Comma-separated field names to include", required: false },
+  full: { type: "boolean", description: "Include full metadata", required: false, default: false }
+};
+
+export {
+  compactFindResponse,
+  readOutputFlags,
+  writeProviderHits,
+  OUTPUT_ARGS
+};
+//# sourceMappingURL=chunk-2AI7CZGS.js.map

package/dist/chunk-2AI7CZGS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/images/providerHits.ts"],"sourcesContent":["/**\n * Table projection for the provider-search commands (`logo`, `icon`, `find`).\n *\n * These returned `{ hits, ingested }` as raw JSON with no `--output`/`--fields`\n * /`--full`, so the only way to pull one field out of a result was\n * `grep -oE '\"imageUrl\": \"[^\"]+\"'`. The library commands already had the flag\n * trio; the provider commands just needed a projection to hand it, because the\n * shared image normalizer expects a library row and would flatten a provider\n * hit into an empty record.\n */\n\nimport type { ImagesFindResponse } from \"@baker/api\";\nimport { type OutputFormat, writeOutput } from \"../../output.ts\";\n\nfunction asRecord(value: unknown): Record<string, unknown> {\n  return value && typeof value === \"object\" ? (value as Record<string, unknown>) : {};\n}\n\nfunction str(value: unknown): string | undefined {\n  return typeof value === \"string\" && value.length > 0 ? value : undefined;\n}\n\nfunction num(value: unknown): number | undefined {\n  return typeof value === \"number\" ? value : undefined;\n}\n\n/**\n * What decides whether a hit is usable and how to keep it: which provider it\n * came from, where the pixels are, and — once auto-ingest ran — the library id\n * and Baker-owned URL that make it durable.\n */\nfunction compactHit(hit: Record<string, unknown>): Record<string, unknown> {\n  // A library hit (`find`'s library group) is already in the library: its id\n  // is `_id` and its `url` is the Baker-owned one. Spelled like an ingested\n  // external hit, the two groups read alike and the library id is not lost.\n  const inLibrary = hit.source === \"library\";\n  return {\n    source: str(hit.source) ?? \"\",\n    url: str(hit.url) ?? \"\",\n    imageId: str(hit.imageId) ?? (inLibrary ? str(hit._id) : undefined),\n    imageUrl: str(hit.imageUrl) ?? (inLibrary ? str(hit.url) : undefined),\n    name: str(hit.name),\n    width: num(hit.width),\n    height: num(hit.height),\n  };\n}\n\nexport function providerHitNormalizer(record: Record<string, unknown>, full: boolean): Record<string, unknown> {\n  const compact = compactHit(record);\n  if (!full) {\n    return compact;\n  }\n  const group = asRecord(record.group);\n  return {\n    ...compact,\n    externalUrl: str(record.externalUrl),\n    externalId: str(record.externalId),\n    description: str(record.description),\n    tags: Array.isArray(record.tags) ? record.tags : [],\n    aspectRatio: num(record.aspectRatio),\n    dominantColor: str(record.dominantColor),\n    score: num(record.score),\n    deduped: typeof record.deduped === \"boolean\" ? record.deduped : undefined,\n    alsoInLibrary: str(record.alsoInLibrary),\n    groupKey: str(group.key),\n  };\n}\n\nconst FIND_DESCRIPTION_CHARS = 160;\n\nfunction clip(text: string | undefined, max: number): string | undefined {\n  if (text === undefined || text.length <= max) return text;\n  return `${text.slice(0, max).trimEnd()}…`;\n}\n\n/** A `find` hit as the JSON default prints it: the pick row plus a line of description and the score. */\nfunction compactFindHit(hit: Record<string, unknown>): Record<string, unknown> {\n  const score = num(hit.score);\n  return {\n    ...compactHit(hit),\n    description: clip(str(hit.description), FIND_DESCRIPTION_CHARS),\n    score: score === undefined ? undefined : Math.round(score * 100) / 100,\n  };\n}\n\n/**\n * `find`'s response with every hit compacted and everything around them —\n * `meta` (counts, provider errors) and `ingested` — kept as sent. The JSON\n * default used to be the whole response: twenty library hits per group with\n * their full descriptions and tags, ~22 KB a call (BAKER-1831). `--full` prints\n * it unchanged.\n */\nexport function compactFindResponse(data: ImagesFindResponse): {\n  groups: { library: Record<string, unknown>[]; external: Record<string, unknown>[] };\n  meta: ImagesFindResponse[\"meta\"];\n  ingested: ImagesFindResponse[\"ingested\"];\n} {\n  return {\n    groups: {\n      library: data.groups.library.map((hit) => compactFindHit(hit)),\n      external: data.groups.external.map((hit) => compactFindHit(hit)),\n    },\n    meta: data.meta,\n    ingested: data.ingested,\n  };\n}\n\n/** The standard `--output`/`--fields`/`--full` trio, parsed the same way in every provider command. */\nexport interface OutputFlags {\n  format: OutputFormat;\n  fields: string[] | undefined;\n  full: boolean;\n}\n\nexport function readOutputFlags(args: Record<string, unknown>): OutputFlags {\n  const format = typeof args.output === \"string\" && args.output.length > 0 ? (args.output as OutputFormat) : \"json\";\n  const rawFields = typeof args.fields === \"string\" && args.fields.length > 0 ? args.fields : undefined;\n  return {\n    format,\n    fields: rawFields ? rawFields.split(\",\").filter(Boolean) : undefined,\n    full: args.full === true,\n  };\n}\n\n/**\n * Emit a provider search result.\n *\n * `json` (the default) emits the `data` it is handed — the backend's response,\n * or `find`'s compact one unless `--full`. The table formats tabulate `hits`,\n * which the caller passes separately because `find` groups its results and has\n * no top-level `hits` key to read.\n */\nexport function writeProviderHits<T>(data: T, hits: unknown[], args: Record<string, unknown>, hints: string[]): void {\n  const { format, fields, full } = readOutputFlags(args);\n  const envelope = {\n    ok: true as const,\n    data: format === \"json\" ? data : (hits as Record<string, unknown>[]),\n    ...(hints.length > 0 ? { hints } : {}),\n  };\n  writeOutput(envelope, format, fields, full, providerHitNormalizer);\n}\n\n/** The flag trio, declared identically on every command that emits provider hits. */\nexport const OUTPUT_ARGS = {\n  output: { type: \"string\", description: \"Output format: json|files|md\", required: false, default: \"json\" },\n  fields: { type: \"string\", description: \"Comma-separated field names to include\", required: false },\n  full: { type: \"boolean\", description: \"Include full metadata\", required: false, default: false },\n} as const;\n"],"mappings":"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","names":[]}

package/dist/chunk-2II2GUFL.js

@@ -0,0 +1,225 @@
+import {
+  ApiError
+} from "./chunk-DPPV45D5.js";
+import {
+  optionalChatId
+} from "./chunk-ABXVFHTG.js";
+import {
+  writeJson
+} from "./chunk-UCI6ZGUF.js";
+
+// src/commands/avatars/casting.ts
+var CAST_FLAG_RULE = "Cast with `--avatar <handle>` on `baker studio generate`, `baker studio animate`, `baker canvas scaffold-ad`, `baker canvas scaffold-static-ad` and `baker canvas scaffold-video`. Don't hand-roll it by pasting `subjectDescription` into the prompt or by passing the sheet through `--reference` \u2014 both render something that merely resembles them. `--avatar` is also the only thing that carries their accent and delivery into a clip. An avatar has no pinned voice by design (ADR 0005): the video model renders the voice, and the region on their profile is the only thing steering it \u2014 without the flag the clip is performed flat, in whatever accent the model picks on its own. `baker canvas scaffold-video` casts only their face: a reproduced video keeps the source ad's accent direction, so never tell the user it speaks in theirs.";
+var VERBATIM_RULE = "When you do write the description yourself \u2014 a hand-built canvas node, a landing image, anywhere `--avatar` does not exist \u2014 copy `subjectDescription` verbatim, word for word. Re-phrasing it per generation is the other reason a face drifts across a set.";
+var VIDEO_ROUTING = "In video, a photoreal presenter renders on `google/veo-3.1` (or `google/veo-3.1-fast`), never `bytedance/seedance-2.0` \u2014 it refuses photoreal human faces, AI-generated ones included. Reproducing a video the user gave you: `baker canvas scaffold-video \u2026 --avatar <handle> --real-face`.";
+function castingHints(avatar) {
+  if (avatar.status === "generating" && avatar.needsFace) {
+    return [
+      `The user is picking @${avatar.handle}'s face right now \u2014 portraits are on their screen and nothing renders until they answer. There is NOTHING to wait for and nothing to check: do not poll, do not block on it, do not ask about the face in a question of your own, and do not delete or recreate this avatar. Whatever you do next simply runs after they have chosen.`
+    ];
+  }
+  if (avatar.status === "generating") {
+    return [
+      `Still building \u2014 a ~30s render that settles on its own, and this avatar is castable only once it reads \`ready\`. If the next thing you do needs it (a clip, a still, anything with --avatar), block on it: \`baker avatars get ${avatar.handle} --wait\` returns the moment it is ready. Otherwise do other work first and read it back with \`baker avatars get ${avatar.handle}\`. Never write your own sleep or poll loop, and never end the turn waiting \u2014 the user would have to come back and tell you it is ready.`
+    ];
+  }
+  if (avatar.status === "error") {
+    return [
+      `The identity sheet could not be built${avatar.errorMessage ? `: ${avatar.errorMessage}` : ""}. This avatar cannot be cast. Sharpen the subject description (one person, plain description, no scene) and rebuild: \`baker avatars update ${avatar.handle} --subject "\u2026" --regenerate-sheet\`.`
+    ];
+  }
+  if (avatar.status === "archived") {
+    return [
+      `Retired. Work that already used it still resolves, but do not cast it into anything new \u2014 \`baker avatars list\` shows the roster you can cast from.`
+    ];
+  }
+  if (!avatar.sheetUrl) {
+    return [
+      `No identity sheet on this avatar yet, so there is nothing to ground a render on. Re-read it with \`baker avatars get ${avatar.handle}\`; if it stays this way, rebuild the sheet with \`baker avatars update ${avatar.handle} --regenerate-sheet\`.`
+    ];
+  }
+  return [
+    `Ready to cast: \`baker studio generate "<your scene>" --avatar ${avatar.handle}\` for a still, \`baker studio animate "<the motion, and the line they say>" --avatar ${avatar.handle}\` for a clip.`,
+    CAST_FLAG_RULE,
+    VERBATIM_RULE,
+    VIDEO_ROUTING
+  ];
+}
+function rosterRow(avatar) {
+  return {
+    handle: avatar.handle,
+    name: avatar.name,
+    status: avatar.status,
+    likeness: avatar.likeness,
+    sheetUrl: avatar.sheetUrl ?? null,
+    avatarId: avatar.avatarId,
+    ...avatar.errorMessage ? { errorMessage: avatar.errorMessage } : {}
+  };
+}
+function chatIdFromEnv() {
+  return optionalChatId();
+}
+function rosterHints(roster, statusFilter) {
+  if (roster.length === 0) {
+    return [
+      statusFilter ? `No avatars with status "${statusFilter}". Drop \`--status\` to see the whole roster.` : `No avatars yet \u2014 and retired ones are hidden unless you pass \`--status archived\`. Cast a new presenter with \`baker avatars create --name "\u2026" --subject "\u2026"\`.`
+    ];
+  }
+  const mine = roster.filter((avatar) => avatar.fromThisChat).map((avatar) => avatar.handle);
+  const hints = mine.length ? [
+    `@${mine[0]} was made in this conversation${mine.length > 1 ? ` (with ${mine.slice(1).map((h) => `@${h}`).join(", ")})` : ""} \u2014 that is the avatar this chat is about, and the user chose its face. Use it. The others belong to earlier conversations: only reach for one if the user names it, and never ask which to use when the answer is the one you just cast.`
+  ] : [];
+  hints.push(
+    "Casting one of these? Cast them with `--avatar <handle>` on `baker studio generate` / `baker studio animate` \u2014 that flag carries their face AND their accent. `baker avatars get <handle>` returns the written profile behind it; the roster leaves the description out on purpose, because it must never be read half-way."
+  );
+  const building = roster.filter((avatar) => avatar.status === "generating").map((avatar) => avatar.handle);
+  if (building.length > 0) {
+    hints.push(
+      `Still building, not castable yet: ${building.join(", ")}. Check with \`baker avatars get ${building[0]}\` after your next piece of work.`
+    );
+  }
+  const failed = roster.filter((avatar) => avatar.status === "error").map((avatar) => avatar.handle);
+  if (failed.length > 0) {
+    hints.push(
+      `Could not be built: ${failed.join(", ")}. Read why with \`baker avatars get ${failed[0]}\`, then rebuild with \`baker avatars update ${failed[0]} --subject "\u2026" --regenerate-sheet\`.`
+    );
+  }
+  return hints;
+}
+function thinProfileHint(profile, handle) {
+  const missing = ["motion", "persona", "speech", "accent", "wardrobe", "setting"].filter(
+    (field) => !profile?.[field]?.trim()
+  );
+  if (missing.length === 0) return null;
+  return `MISSING ${missing.map((field) => `--${field}`).join(" ")}. A bare subject description holds the face still and nothing else, so clips of @${handle} come out stiff and generic \u2014 measured, filling these in nearly doubled the movement in the same brief. --accent is the one nobody guesses and the only one that fails silently: it decides the LANGUAGE and accent the avatar speaks in, in every clip. Name the region whose language the USER is writing to you in ("Spanish from Spain, Madrid accent") \u2014 "Spanish" on its own renders as no accent at all, and a region taken from how the person LOOKS ("European", "Nordic") renders as that region's language: an ad for a Spanish client shipped with --accent "German" and came back spoken in German. The user almost certainly told you how this person talks and carries themselves; put it in: \`baker avatars update ${handle} ${missing.map((field) => `--${field} "\u2026"`).join(" ")}\`.`;
+}
+function parseFaceChoice(raw) {
+  if (raw === void 0) return "ask";
+  const value = raw.trim().toLowerCase();
+  if (value === "ask" || value === "auto") return value;
+  return null;
+}
+function creationHints(created, profile) {
+  const thin = thinProfileHint(profile, created.handle);
+  const casting = created.likeness === "synthetic" && created.faceChoice === "auto" ? [
+    `No one was asked about this face \u2014 \`--face auto\` cast it and it is kept. Do not tell the user they chose it, and do not offer them a pick you are not going to run. If this should have been theirs, say so and create it again with \`--face ask\`.`
+  ] : created.likeness === "synthetic" ? [
+    `The user is being shown real portraits of @${created.handle} right now, and the turn waits for them to pick \u2014 this happens on its own, triggered by the command you just ran. The picker is already showing, so don't call request_avatar_casting, don't ask about the face in a question of your own, and don't wait or poll: whatever you do next simply runs after they have chosen \u2014 or, if they have not picked within 30 seconds of the faces appearing, after the first face is kept for them (then never say they chose it). Say what you created, then carry on with what the user asked for: when that was only the avatar, or they said to stop after it, stop there and render nothing.`
+  ] : [];
+  const hints = [
+    ...casting,
+    ...thin ? [thin] : [],
+    ...castingHints({ handle: created.handle, status: created.status }),
+    `Once it is ready, cast it with \`--avatar ${created.handle}\` on \`baker studio generate\` / \`baker studio animate\` \u2014 that flag is what grounds the render on its identity sheet and, for a clip, what carries their accent and delivery into the read.`
+  ];
+  if (created.likeness === "licensed") {
+    hints.push(
+      "This avatar carries a real person's likeness, used on the company's confirmation that it may appear in their advertising. Keep it out of any creative that would misrepresent them, and out of claims they did not make."
+    );
+  }
+  return hints;
+}
+function updateHints(update) {
+  const hints = [];
+  if (update.previousHandle !== update.avatar.handle) {
+    hints.push(
+      `Renamed to @${update.avatar.handle}. @${update.previousHandle} no longer resolves \u2014 update anything that mentioned it.`
+    );
+  }
+  if (update.regeneratedSheet) {
+    hints.push(
+      `Rebuilding the identity sheet (~30s). The avatar is back to building and cannot be cast until \`baker avatars get ${update.avatar.handle}\` shows \`ready\` \u2014 and the sheet URL changes, so drop any \`--reference\` you were reusing and read the new one.`
+    );
+    return hints;
+  }
+  if (update.subjectChanged) {
+    hints.push(
+      `MISSING --regenerate-sheet. You changed the subject description but the identity sheet still shows the person you described before, so the words and the face no longer match and every new render will drift. Re-run: \`baker avatars update ${update.avatar.handle} --regenerate-sheet\` (a ~30s rebuild, billed).`
+    );
+    return hints;
+  }
+  hints.push(...castingHints(update.avatar));
+  return hints;
+}
+function removalHints(removal) {
+  if (removal.archived) {
+    return [
+      `Retired @${removal.handle}. Work that already used it still resolves and its images stay as they are; it no longer shows in \`baker avatars list\` and must not be cast into anything new.`
+    ];
+  }
+  return [
+    `Deleted @${removal.handle} for good. The mention no longer resolves anywhere \u2014 creatives that already rendered keep their images, but nothing new can be grounded on this identity. \`--archive\` is the reversible option next time.`
+  ];
+}
+function avatarRowNormalizer(record) {
+  const flat = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (Array.isArray(value)) {
+      flat[key] = value.join("; ");
+      continue;
+    }
+    if (value !== null && typeof value === "object") {
+      for (const [nested, nestedValue] of Object.entries(value)) {
+        flat[nested] = Array.isArray(nestedValue) ? nestedValue.join("; ") : nestedValue;
+      }
+      continue;
+    }
+    flat[key] = value;
+  }
+  return flat;
+}
+
+// src/commands/avatars/failures.ts
+function failValidation(message, fix) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message, ...fix ? { fix } : {} } });
+  process.exit(1);
+}
+function avatarFailureFix(err, handle, context = {}) {
+  if (err.code === "NOT_FOUND") {
+    return {
+      action: "list_avatars",
+      explanation: `Run \`baker avatars list\` to see which avatars this company has${handle ? ` \u2014 "${handle}" is not one of them` : ""}. Handles are lowercase letters, numbers and dashes ("maria-founder", not "Maria Founder"). If the roster is empty, create the avatar first with \`baker avatars create\`. Do not abandon the wider job over this \u2014 carry on without the avatar and say so.`
+    };
+  }
+  if (err.code === "CONFLICT" && context.operation === "remove") {
+    return {
+      action: "wait_for_the_user",
+      explanation: `Do not remove or recreate${handle ? ` @${handle}` : " this avatar"} \u2014 wait. The portraits are on the user's screen and the turn continues once they answer. If you think the faces are wrong, say so in your reply and let them turn all four down; that recasts the same avatar from what they tell you was missing, and keeps everything already pointing at it.`
+    };
+  }
+  if (err.code === "CONFLICT" && handle) {
+    return {
+      action: "use_the_existing_avatar",
+      explanation: `@${handle} already exists in this company \u2014 avatars belong to the company, not to a chat, so one made in an earlier conversation is still here and still castable. If it is the person you want, use it as it is: \`--avatar ${handle}\`. Read it first with \`baker avatars get ${handle} --full\` and say who they already are. Do not create the same person under a second name: the user would be told about one avatar and handed another, and the company ends up with duplicates nobody chose a face for. If you genuinely need a different person, ask the user what to call them.`
+    };
+  }
+  return void 0;
+}
+function failAvatarApi(err, handle, context = {}) {
+  if (err instanceof ApiError) {
+    const fix = avatarFailureFix(err, handle, context);
+    writeJson({ ok: false, error: { code: err.code, message: err.message, ...fix ? { fix } : {} } });
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: err.message } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+
+export {
+  castingHints,
+  rosterRow,
+  chatIdFromEnv,
+  rosterHints,
+  parseFaceChoice,
+  creationHints,
+  updateHints,
+  removalHints,
+  avatarRowNormalizer,
+  failValidation,
+  failAvatarApi
+};
+//# sourceMappingURL=chunk-2II2GUFL.js.map

package/dist/chunk-2XYUFXF2.js

@@ -0,0 +1,224 @@
+import {
+  nodeParamsPreview
+} from "./chunk-LYWPC6JW.js";
+import {
+  creativeSlugFromCanvasPath
+} from "./chunk-I2LRPRO6.js";
+import {
+  parseDefinitionDelivery,
+  parseDefinitionSeriesPlace,
+  parseDefinitionSourceFields,
+  parseDefinitionStrategyFields,
+  prepareCanvas
+} from "./chunk-QT2W5VGG.js";
+import {
+  BackendClient
+} from "./chunk-XUMMEZBE.js";
+import {
+  nodeDependencies
+} from "./chunk-EBMIK6PP.js";
+import {
+  requireCredentialsFromEnv
+} from "./chunk-TCYK35RZ.js";
+
+// src/commands/canvas/sync-definition.ts
+import { readdir, readFile, stat } from "fs/promises";
+import path from "path";
+import { parseDocument } from "yaml";
+import { defineCommand } from "citty";
+
+// src/commands/canvas/definition-graph.ts
+var MAX_NODES = 300;
+var PREVIEWABLE_INGEST_EXPECTS = /* @__PURE__ */ new Set(["image"]);
+function nodeInputPreviewUrl(type, params) {
+  if (type !== "ingest" || !params || typeof params !== "object") return void 0;
+  const p = params;
+  if (p.source !== "url" || typeof p.url !== "string") return void 0;
+  if (!/^https?:\/\//i.test(p.url)) return void 0;
+  if (typeof p.expect === "string" && !PREVIEWABLE_INGEST_EXPECTS.has(p.expect)) return void 0;
+  return p.url;
+}
+function canvasToDefinitionGraph(canvas) {
+  const rawNodes = canvas?.nodes;
+  if (!Array.isArray(rawNodes)) return null;
+  const parsed = [];
+  for (const raw of rawNodes) {
+    const id = raw?.id;
+    const type = raw?.type;
+    if (typeof id !== "string" || typeof type !== "string") continue;
+    parsed.push({ id, type, inputs: raw.inputs, params: raw.params });
+    if (parsed.length >= MAX_NODES) break;
+  }
+  if (parsed.length === 0) return null;
+  const ids = new Set(parsed.map((n) => n.id));
+  const nodes = parsed.map(({ id, type, inputs, params }) => {
+    const deps = nodeDependencies({ id, inputs, params }, ids);
+    deps.delete(id);
+    const depList = [...deps];
+    const paramsPreview = nodeParamsPreview(params, depList);
+    const base = { id, type };
+    if (depList.length > 0) base.deps = depList;
+    if (paramsPreview) base.paramsPreview = paramsPreview;
+    const inputPreviewUrl = nodeInputPreviewUrl(type, params);
+    if (inputPreviewUrl) base.inputPreviewUrl = inputPreviewUrl;
+    return base;
+  });
+  const rawOutput = canvas?.output;
+  const outNode = rawOutput?.node;
+  const outSlot = rawOutput?.output;
+  const output = typeof outNode === "string" && typeof outSlot === "string" ? { node: outNode, output: outSlot } : void 0;
+  return { nodes, output };
+}
+
+// src/commands/canvas/sync-definition.ts
+function buildDefinitionSyncPayload(input, graph, chatId) {
+  const { canvas: _canvas, ...fields } = input;
+  return Object.fromEntries([
+    ...Object.entries(fields).filter(([, v]) => v !== void 0),
+    ["graph", graph],
+    ["chatId", chatId]
+  ]);
+}
+async function readDefinitionSourceFields(canvasPath) {
+  try {
+    return parseDefinitionSourceFields(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionPlatforms(canvasPath) {
+  const raw = await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8").catch(() => null);
+  const delivery = raw === null ? null : parseDefinitionDelivery(raw);
+  return delivery ? { platforms: delivery.platforms ?? null } : {};
+}
+async function readDefinitionBody(canvasPath) {
+  try {
+    return { definition: await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8") };
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionTitle(canvasPath) {
+  try {
+    const raw = await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8");
+    const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+    const doc = match ? parseDocument(match[1] ?? "") : null;
+    const title = doc && doc.errors.length === 0 ? doc.get("title") : void 0;
+    return typeof title === "string" && title.trim() ? title.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readDefinitionStrategyFields(canvasPath) {
+  try {
+    return parseDefinitionStrategyFields(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionSeriesPlace(canvasPath) {
+  try {
+    return parseDefinitionSeriesPlace(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8")) ?? {};
+  } catch {
+    return {};
+  }
+}
+async function syncCreativeDefinitionBestEffort(input) {
+  const chatId = process.env.BAKER_CHAT_ID;
+  if (!chatId) return;
+  const graph = canvasToDefinitionGraph(input.canvas);
+  if (!graph || graph.nodes.length === 0) return;
+  try {
+    const creds = requireCredentialsFromEnv();
+    const client = new BackendClient({ baseUrl: creds.url, apiKey: creds.apiKey });
+    await client.syncCreativeDefinition(buildDefinitionSyncPayload(input, graph, chatId));
+    process.stdout.write(`[definition] synced workflow graph (${graph.nodes.length} nodes) \u2014 view it in the dashboard
+`);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(`[warn] workflow graph not synced (${msg})
+`);
+  }
+}
+async function resolveCanvasPath(inputPath) {
+  const resolved = path.resolve(inputPath);
+  let dir = resolved;
+  try {
+    if ((await stat(resolved)).isFile()) {
+      if (resolved.endsWith(".canvas.json")) return resolved;
+      dir = path.dirname(resolved);
+    }
+  } catch {
+    dir = resolved.endsWith(".canvas.json") ? path.dirname(resolved) : resolved;
+  }
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return null;
+  }
+  const canvases = entries.filter((name) => name.endsWith(".canvas.json"));
+  const slug = creativeSlugFromCanvasPath(`${dir}/x/`);
+  const chosen = (slug ? canvases.find((name) => name === `${slug}.canvas.json`) : void 0) ?? canvases[0];
+  return chosen ? path.join(dir, chosen) : null;
+}
+var syncDefinitionCommand = defineCommand({
+  meta: {
+    name: "sync-definition",
+    description: "Push a creative's current node-graph + input thumbnails to the dashboard without rendering. The graph has the creative's blueprint applied (prompt.json and scenes/*.json edits), exactly as `run` would render it, without changing any file. Runs automatically when you edit a creative's canvas.json or prompt.json."
+  },
+  args: {
+    file: {
+      type: "positional",
+      required: true,
+      description: "A path under src/creatives/<slug>/ (the .canvas.json, its prompt.json, or the folder)"
+    },
+    title: {
+      type: "boolean",
+      description: "Also record the title its _definition.md gives. Only for a creative just made from another (a series ad, a translation), never on an edit re-sync."
+    }
+  },
+  async run({ args }) {
+    const canvasPath = await resolveCanvasPath(String(args.file));
+    if (!canvasPath) {
+      return;
+    }
+    const slug = creativeSlugFromCanvasPath(canvasPath);
+    if (!slug) return;
+    let canvas;
+    let sourceSha;
+    try {
+      const prepared = await prepareCanvas(canvasPath, { write: false });
+      canvas = prepared.fileGraph;
+      sourceSha = prepared.sourceSha;
+    } catch {
+      return;
+    }
+    const title = args.title ? await readDefinitionTitle(canvasPath) : void 0;
+    await syncCreativeDefinitionBestEffort({
+      slug,
+      canvas,
+      sourceSha,
+      ...title ? { title } : {},
+      ...await readDefinitionSourceFields(canvasPath),
+      ...await readDefinitionStrategyFields(canvasPath),
+      ...await readDefinitionSeriesPlace(canvasPath),
+      ...await readDefinitionPlatforms(canvasPath),
+      ...await readDefinitionBody(canvasPath)
+    });
+  }
+});
+
+export {
+  buildDefinitionSyncPayload,
+  readDefinitionSourceFields,
+  readDefinitionPlatforms,
+  readDefinitionBody,
+  readDefinitionTitle,
+  readDefinitionStrategyFields,
+  readDefinitionSeriesPlace,
+  syncCreativeDefinitionBestEffort,
+  resolveCanvasPath,
+  syncDefinitionCommand
+};
+//# sourceMappingURL=chunk-2XYUFXF2.js.map