@koda-sl/baker-cli 0.393.0 → 0.394.0

package/dist/cli.js

@@ -34387,16 +34387,16 @@ async function runChatgptRead(reference, read, hintsFor4) {
   }
 }
 var TRUNCATED_HINT = "These rows are the first 2,000, not the whole account \u2014 narrow the read (--campaign-id, --ad-group-id) before counting them or concluding something is missing.";
-async function getChatgptList(path56, params) {
-  const { data, headers } = await apiGetWithHeaders(path56, params);
+async function getChatgptList(path57, params) {
+  const { data, headers } = await apiGetWithHeaders(path57, params);
   return { data, truncated: headers.get(CHATGPT_ADS_TRUNCATED_HEADER) === "true" };
 }
-async function runChatgptListRead(reference, path56, params, hintsFor4) {
+async function runChatgptListRead(reference, path57, params, hintsFor4) {
   let truncated = false;
   await runChatgptRead(
     reference,
     async () => {
-      const read = await getChatgptList(path56, params);
+      const read = await getChatgptList(path57, params);
       truncated = read.truncated;
       return read.data;
     },
@@ -35201,7 +35201,7 @@ var MEMBER_ARGS = {
   },
   country: { type: "string", description: "Country of phones written without a +code, e.g. ES" }
 };
-function membersFromArgs(args8, readFile42 = (path56) => readFileSync2(path56, "utf8")) {
+function membersFromArgs(args8, readFile42 = (path57) => readFileSync2(path57, "utf8")) {
   const fromFile = typeof args8.file === "string" && args8.file ? membersFromFile(readFile42(args8.file)) : { emails: [], phones: [] };
   const given = [...csvArg(args8.emails) ?? [], ...fromFile.emails];
   const givenPhones = [...csvArg(args8.phones) ?? [], ...fromFile.phones];
@@ -38576,9 +38576,9 @@ var COPY_LIST_FLAG = {
   descriptions: "--descriptions",
   longHeadlines: "--long-headlines"
 };
-function valueAt(root, path56) {
+function valueAt(root, path57) {
   let node = root;
-  for (const key of path56) {
+  for (const key of path57) {
     if (node === null || typeof node !== "object") return void 0;
     node = node[key];
   }
@@ -38811,11 +38811,11 @@ function parseKeywordEntry(raw, defaultMatch) {
 function rawTextEntries(value2, rawArgs) {
   return repeatedValues(rawArgs, "text", value2).flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
 }
-function rawFileEntries(path56) {
-  if (typeof path56 !== "string" || path56.length === 0) {
+function rawFileEntries(path57) {
+  if (typeof path57 !== "string" || path57.length === 0) {
     return [];
   }
-  return readFileSync4(path56, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return readFileSync4(path57, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function keywordEntries(args8, rawArgs) {
   const defaultMatch = typeof args8["match-type"] === "string" ? args8["match-type"].toUpperCase() : void 0;
@@ -38838,14 +38838,14 @@ function keywordEntries(args8, rawArgs) {
   }
   return entries;
 }
-function loadJsonFileArg(path56) {
-  if (typeof path56 !== "string" || path56.length === 0) {
+function loadJsonFileArg(path57) {
+  if (typeof path57 !== "string" || path57.length === 0) {
     return {};
   }
-  const inline = path56.trimStart().startsWith("{");
-  const source = inline ? "inline JSON" : path56;
+  const inline = path57.trimStart().startsWith("{");
+  const source = inline ? "inline JSON" : path57;
   try {
-    const parsed = JSON.parse(inline ? path56 : readFileSync4(path56, "utf8"));
+    const parsed = JSON.parse(inline ? path57 : readFileSync4(path57, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       failWriteValidation2(`${source} must contain a JSON object`);
     }
@@ -38982,10 +38982,10 @@ async function stageUpdate(kind, customerId, target2, payload, hints2) {
 async function stageTarget(kind, customerId, target2, hints2) {
   await stageGoogleOp({ kind, customerId, target: target2 }, hints2);
 }
-async function draftAction(path56, body, chat) {
+async function draftAction(path57, body, chat) {
   try {
     const chatId = resolveChatId(chat);
-    const response = await apiPost(path56, { chatId, ...body });
+    const response = await apiPost(path57, { chatId, ...body });
     writeJsonEnvelope(response);
   } catch (err) {
     handleGoogleError(err);
@@ -41403,14 +41403,14 @@ function mappingRowProblem(row) {
 
 // ../api/src/event-sources/template.ts
 var MENTION = /\{\{\s*([^{}]+?)\s*\}\}/g;
-function mentionOf(path56) {
-  return `{{${path56}}}`;
+function mentionOf(path57) {
+  return `{{${path57}}}`;
 }
 function templateMentions(template) {
   const seen = [];
   for (const match of template.matchAll(MENTION)) {
-    const path56 = (match[1] ?? "").trim();
-    if (path56 !== "" && !seen.includes(path56)) seen.push(path56);
+    const path57 = (match[1] ?? "").trim();
+    if (path57 !== "" && !seen.includes(path57)) seen.push(path57);
   }
   return seen;
 }
@@ -44765,17 +44765,17 @@ function ignoredColumnHints(columns) {
     `Ignored ${columns.length} column(s) that are not part of a conversion: ${columns.join(", ")}. A conversion carries an order id, a date, and something to match on: a click id (gclid / gbraid / wbraid), an email, a phone, or all four of givenName + familyName + country + postalCode. Optionally a value + currency, conversionCount, and eventSource (WEB / APP / IN_STORE / PHONE / OTHER). A column named just \`Name\` is ignored on purpose \u2014 Google needs the first and last name separately, so split it before re-running.`
   ];
 }
-function readRowsFile(path56) {
-  const inline = path56.trimStart().startsWith("[") || path56.trimStart().startsWith("{");
+function readRowsFile(path57) {
+  const inline = path57.trimStart().startsWith("[") || path57.trimStart().startsWith("{");
   let text2;
   try {
-    text2 = inline ? path56 : readFileSync6(path56, "utf8");
+    text2 = inline ? path57 : readFileSync6(path57, "utf8");
   } catch (err) {
-    failWriteValidation2(`could not read ${path56}: ${err instanceof Error ? err.message : String(err)}`);
+    failWriteValidation2(`could not read ${path57}: ${err instanceof Error ? err.message : String(err)}`);
   }
   const parsed = parseConversionRowsText(text2);
   if (!parsed.ok) {
-    failWriteValidation2(`${inline ? "the conversions passed inline" : path56}: ${parsed.error}`);
+    failWriteValidation2(`${inline ? "the conversions passed inline" : path57}: ${parsed.error}`);
   }
   return { rows: parsed.rows, ignoredColumns: parsed.ignoredColumns };
 }
@@ -46676,19 +46676,19 @@ function failWriteValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg2(path56) {
-  if (typeof path56 !== "string" || path56.length === 0) {
+function loadJsonFileArg2(path57) {
+  if (typeof path57 !== "string" || path57.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync7(path56, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path57, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation3(`${path56} must contain a JSON object`);
+      failWriteValidation3(`${path57} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation3(`${path56} is not valid JSON: ${err.message}`);
+      failWriteValidation3(`${path57} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -46773,15 +46773,15 @@ function parseLocaleFlag(value2) {
   }
   return { language: match[1], country: match[2].toUpperCase() };
 }
-function loadTargetingFileArg(path56) {
-  if (typeof path56 !== "string" || path56.length === 0) {
+function loadTargetingFileArg(path57) {
+  if (typeof path57 !== "string" || path57.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg2(path56);
+  const parsed = loadJsonFileArg2(path57);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
     failWriteValidation3(
-      `${path56} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+      `${path57} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
   return criteria;
@@ -46816,14 +46816,14 @@ function parseCsvLine(line) {
   cells.push(current);
   return cells.map((cell3) => cell3.trim());
 }
-function parseListFileArg(path56, maxRows) {
-  if (typeof path56 !== "string" || path56.length === 0) {
+function parseListFileArg(path57, maxRows) {
+  if (typeof path57 !== "string" || path57.length === 0) {
     return void 0;
   }
-  const raw = readFileSync7(path56, "utf8");
+  const raw = readFileSync7(path57, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation3(`${path56} needs a header row and at least one data row`);
+    failWriteValidation3(`${path57} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -46842,7 +46842,7 @@ function parseListFileArg(path56, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation3(`${path56} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation3(`${path57} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -46938,11 +46938,11 @@ function readPositionals(args8) {
 function splitIdList(raw) {
   return raw.split(",").map((id) => id.trim()).filter(Boolean);
 }
-function idsFileEntries(path56) {
-  if (typeof path56 !== "string" || path56.length === 0) {
+function idsFileEntries(path57) {
+  if (typeof path57 !== "string" || path57.length === 0) {
     return [];
   }
-  return readFileSync7(path56, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+  return readFileSync7(path57, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
 }
 function requireTargets2(args8, entity) {
   const positionals = readPositionals(args8);
@@ -49703,9 +49703,9 @@ import { defineCommand as defineCommand64 } from "citty";
 function asRecord(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2) ? value2 : void 0;
 }
-function readPath2(row, path56) {
+function readPath2(row, path57) {
   let current = row;
-  for (const segment of path56.split(".")) {
+  for (const segment of path57.split(".")) {
     const record = asRecord(current);
     if (!record) return void 0;
     current = record[segment];
@@ -49715,10 +49715,10 @@ function readPath2(row, path56) {
 function projectFields(rows, paths) {
   return rows.map((row) => {
     const projected = {};
-    for (const path56 of paths) {
-      const value2 = readPath2(row, path56);
+    for (const path57 of paths) {
+      const value2 = readPath2(row, path57);
       if (value2 !== void 0) {
-        projected[path56] = value2;
+        projected[path57] = value2;
       }
     }
     return projected;
@@ -49731,16 +49731,16 @@ function shapeListRows(rows, args8, compact5) {
     const paths = fields.split(",").map((field) => field.trim()).filter((field) => field.length > 0);
     if (paths.length > 0) {
       const projected = projectFields(raw, paths).map((row, i) => {
-        const missing = paths.filter((path56) => row[path56] === void 0);
+        const missing = paths.filter((path57) => row[path57] === void 0);
         const source = rows[i];
         if (missing.length === 0 || source === void 0) return row;
         const compactRow3 = compact5.row(source);
-        for (const path56 of missing) {
-          if (compactRow3[path56] !== void 0) row[path56] = compactRow3[path56];
+        for (const path57 of missing) {
+          if (compactRow3[path57] !== void 0) row[path57] = compactRow3[path57];
         }
         return row;
       });
-      const unmatched = paths.filter((path56) => projected.every((row) => row[path56] === void 0));
+      const unmatched = paths.filter((path57) => projected.every((row) => row[path57] === void 0));
       if (projected.length === 0 || unmatched.length === 0) return { rows: projected, fields: paths };
       const carried = /* @__PURE__ */ new Set([...compact5.columns, ...raw.flatMap((row) => Object.keys(row))]);
       return {
@@ -51100,54 +51100,54 @@ function ruleFields(node) {
     ([key, value2]) => (key === "and" || key === "or") && Array.isArray(value2) ? value2.flatMap(ruleFields) : [key]
   );
 }
-function branchRefusal(key, value2, path56) {
+function branchRefusal(key, value2, path57) {
   if (!Array.isArray(value2) || value2.length === 0) {
-    return `${path56}.${key} must be a non-empty array of conditions \u2014 an empty one counts every event the pixel sends`;
+    return `${path57}.${key} must be a non-empty array of conditions \u2014 an empty one counts every event the pixel sends`;
   }
   for (const [index, child] of value2.entries()) {
-    const refusal = ruleNodeRefusal(child, `${path56}.${key}[${index}]`);
+    const refusal = ruleNodeRefusal(child, `${path57}.${key}[${index}]`);
     if (refusal) {
       return refusal;
     }
   }
   return void 0;
 }
-function conditionRefusal(key, value2, path56) {
-  return key === "and" || key === "or" ? branchRefusal(key, value2, path56) : leafRefusal(key, value2, path56);
+function conditionRefusal(key, value2, path57) {
+  return key === "and" || key === "or" ? branchRefusal(key, value2, path57) : leafRefusal(key, value2, path57);
 }
-function ruleNodeRefusal(node, path56) {
+function ruleNodeRefusal(node, path57) {
   if (!isRecord2(node)) {
-    return `${path56} must be an object like {"URL":{"i_contains":"/thank-you"}}`;
+    return `${path57} must be an object like {"URL":{"i_contains":"/thank-you"}}`;
   }
   const entries = Object.entries(node);
   if (entries.length === 0) {
-    return `${path56} is empty \u2014 a rule with no condition counts every event the pixel sends`;
+    return `${path57} is empty \u2014 a rule with no condition counts every event the pixel sends`;
   }
   if (entries.length > 1) {
-    return `${path56} names ${entries.length} conditions side by side (${entries.map(([key]) => key).join(", ")}) \u2014 Meta reads one branch or one field test per object, so combine them with {"and":[\u2026]}`;
+    return `${path57} names ${entries.length} conditions side by side (${entries.map(([key]) => key).join(", ")}) \u2014 Meta reads one branch or one field test per object, so combine them with {"and":[\u2026]}`;
   }
   for (const [key, value2] of entries) {
-    const refusal = conditionRefusal(key, value2, path56);
+    const refusal = conditionRefusal(key, value2, path57);
     if (refusal) {
       return refusal;
     }
   }
   return void 0;
 }
-function leafRefusal(field, condition, path56) {
+function leafRefusal(field, condition, path57) {
   if (!isRecord2(condition)) {
-    return `${path56}.${field} must be a test like {"i_contains":"/thank-you"}, not a bare value`;
+    return `${path57}.${field} must be a test like {"i_contains":"/thank-you"}, not a bare value`;
   }
   const tests = Object.entries(condition);
   if (tests.length === 0) {
-    return `${path56}.${field} names no test \u2014 use one of ${Object.keys(RULE_OPERATORS).join(", ")}`;
+    return `${path57}.${field} names no test \u2014 use one of ${Object.keys(RULE_OPERATORS).join(", ")}`;
   }
   if (tests.length > 1) {
-    return `${path56}.${field} names ${tests.length} operators at once (${tests.map(([operator]) => operator).join(", ")}) \u2014 test a field once per condition and combine them with {"and":[\u2026]}`;
+    return `${path57}.${field} names ${tests.length} operators at once (${tests.map(([operator]) => operator).join(", ")}) \u2014 test a field once per condition and combine them with {"and":[\u2026]}`;
   }
   for (const [operator] of tests) {
     if (!RULE_OPERATORS[operator]) {
-      return `${path56}.${field} uses "${operator}", which is not a Meta rule operator \u2014 use one of ${Object.keys(RULE_OPERATORS).join(", ")} (URL matching is i_contains, not contains or includes)`;
+      return `${path57}.${field} uses "${operator}", which is not a Meta rule operator \u2014 use one of ${Object.keys(RULE_OPERATORS).join(", ")} (URL matching is i_contains, not contains or includes)`;
     }
   }
   return void 0;
@@ -51863,11 +51863,11 @@ var updateStatusSchema2 = z45.enum(UPDATE_STATUSES);
 function currencyMinimums2(currencyCode) {
   return CURRENCY_MINIMUMS2[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM2;
 }
-function validateDailyBudgetFloor(money, ctx, path56) {
+function validateDailyBudgetFloor(money, ctx, path57) {
   if (money?.currencyCode) {
     const min = currencyMinimums2(money.currencyCode).dailyBudgetMin;
     if (Number(money.amount) < min) {
-      ctx.addIssue({ code: "custom", path: path56, message: `below the ${min} ${money.currencyCode} daily minimum` });
+      ctx.addIssue({ code: "custom", path: path57, message: `below the ${min} ${money.currencyCode} daily minimum` });
     }
   }
 }
@@ -52785,19 +52785,19 @@ function refuseDeleteByUpdate(payload, group) {
     );
   }
 }
-function loadJsonFileArg3(path56) {
-  if (typeof path56 !== "string" || path56.length === 0) {
+function loadJsonFileArg3(path57) {
+  if (typeof path57 !== "string" || path57.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync11(path56, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path57, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation4(`${path56} must contain a JSON object`);
+      failWriteValidation4(`${path57} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation4(`${path56} is not valid JSON: ${err.message}`);
+      failWriteValidation4(`${path57} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -58568,12 +58568,12 @@ function flowExists(slug) {
   return existsSync3(join2(flowsDir(), slug, "_data.json"));
 }
 function readFlowTree(slug) {
-  const path56 = join2(flowsDir(), slug, "_data.json");
-  if (!existsSync3(path56)) {
+  const path57 = join2(flowsDir(), slug, "_data.json");
+  if (!existsSync3(path57)) {
     failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
   }
   try {
-    return JSON.parse(readFileSync13(path56, "utf-8"));
+    return JSON.parse(readFileSync13(path57, "utf-8"));
   } catch (error) {
     failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -59533,12 +59533,12 @@ function readPeopleFile(args8) {
 }
 function unreadablePeopleFile(args8) {
   if (!args8["people-file"]) return void 0;
-  const path56 = String(args8["people-file"]);
+  const path57 = String(args8["people-file"]);
   try {
-    readFileSync14(path56, "utf8");
+    readFileSync14(path57, "utf8");
     return void 0;
   } catch {
-    return `Couldn't read --people-file ${path56}. Check the path, or pass the people inline with --person.`;
+    return `Couldn't read --people-file ${path57}. Check the path, or pass the people inline with --person.`;
   }
 }
 function peopleLimitError(args8) {
@@ -60510,11 +60510,11 @@ function parseFieldArgs(argv) {
   for (const pair of parseRepeated(argv, "--field")) {
     const eq = pair.indexOf("=");
     const field = eq === -1 ? pair : pair.slice(0, eq);
-    const path56 = eq === -1 ? "" : pair.slice(eq + 1).trim();
+    const path57 = eq === -1 ? "" : pair.slice(eq + 1).trim();
     const problem = mappingRowProblem(field);
     if (problem !== null) throw new ConversionArgsError(problem);
-    if (path56 === "") throw new ConversionArgsError(`--field ${field} needs a path: --field ${field}=<dotted.path>.`);
-    mapping[field] = path56;
+    if (path57 === "") throw new ConversionArgsError(`--field ${field} needs a path: --field ${field}=<dotted.path>.`);
+    mapping[field] = path57;
   }
   return mapping;
 }
@@ -62116,11 +62116,11 @@ function unwrap(response) {
   }
   return response.data;
 }
-async function readAvatars(path56, params) {
-  return unwrap(await apiGet(path56, params));
+async function readAvatars(path57, params) {
+  return unwrap(await apiGet(path57, params));
 }
-async function writeAvatars(path56, body) {
-  return unwrap(await apiPost(path56, body));
+async function writeAvatars(path57, body) {
+  return unwrap(await apiPost(path57, body));
 }
 
 // src/commands/avatars/create.ts
@@ -63029,12 +63029,12 @@ function missingFontFiles(urls, available) {
 function planFontAdoption(sources, families) {
   const wanted = new Map(families.map((family) => [normalizeFamily(family), family]));
   const byFamily = /* @__PURE__ */ new Map();
-  for (const { path: path56, source } of sources) {
-    const dir = posix.dirname(path56);
+  for (const { path: path57, source } of sources) {
+    const dir = posix.dirname(path57);
     for (const face of declaredFontFaces(source)) {
       if (!wanted.has(face.family)) continue;
       const perFile = byFamily.get(face.family) ?? /* @__PURE__ */ new Map();
-      perFile.set(path56, [...perFile.get(path56) ?? [], rebaseFontFaceSrc(face.block, dir)]);
+      perFile.set(path57, [...perFile.get(path57) ?? [], rebaseFontFaceSrc(face.block, dir)]);
       byFamily.set(face.family, perFile);
     }
   }
@@ -69560,10 +69560,10 @@ function runDirsToPrune(entries, keep, currentRunId) {
   return runs.slice(0, Math.max(0, runs.length - keep));
 }
 async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
-  const { readdir: readdir18 } = await import("fs/promises");
+  const { readdir: readdir19 } = await import("fs/promises");
   let entries;
   try {
-    entries = await readdir18(outputsDir);
+    entries = await readdir19(outputsDir);
   } catch {
     return;
   }
@@ -71388,10 +71388,63 @@ var rerunCommand = defineCommand132({
 });
 
 // src/commands/canvas/scaffold-static-ad.ts
-import { mkdir as mkdir7, readFile as readFile23, writeFile as writeFile12 } from "fs/promises";
-import path29 from "path";
+import { mkdir as mkdir8, readFile as readFile23, writeFile as writeFile13 } from "fs/promises";
+import path30 from "path";
 import { defineCommand as defineCommand134 } from "citty";
 
+// src/commands/canvas/creative-limit.ts
+import { existsSync as existsSync7 } from "fs";
+import { mkdir as mkdir7, readdir as readdir10, writeFile as writeFile12 } from "fs/promises";
+import path25 from "path";
+var NEW_CREATIVES_PER_CHAT = 10;
+function claimNewCreative(made, slug) {
+  if (made.includes(slug)) return { allowed: true, count: made.length };
+  if (made.length >= NEW_CREATIVES_PER_CHAT) return { allowed: false, count: made.length };
+  return { allowed: true, count: made.length + 1 };
+}
+function chatDir(canvasRoot, chatId) {
+  return path25.join(canvasRoot, ".creative-limit", (chatId ?? "no-chat").replace(/[^A-Za-z0-9_-]/g, "_"));
+}
+async function madeInChat(dir) {
+  return readdir10(dir).catch(() => []);
+}
+async function claimNewCreativeInWorkspace(canvasRoot, slug, chatId, definitionPath, exists3 = existsSync7) {
+  const dir = chatDir(canvasRoot, chatId);
+  const made = await madeInChat(dir);
+  if (!made.includes(slug) && exists3(definitionPath)) return { allowed: true, count: made.length };
+  const claim = claimNewCreative(made, slug);
+  if (claim.allowed && !made.includes(slug)) {
+    try {
+      await mkdir7(dir, { recursive: true });
+      await writeFile12(path25.join(dir, slug), "", { flag: "wx" });
+    } catch {
+    }
+  }
+  return claim;
+}
+function creativeLimitRefusal(slug) {
+  return {
+    ok: false,
+    error: {
+      code: "CREATIVE_LIMIT",
+      message: `${slug} would be new creative number ${NEW_CREATIVES_PER_CHAT + 1} in this chat. A chat makes at most ${NEW_CREATIVES_PER_CHAT} new creatives.`,
+      fix: `Build nothing more. Finish and show the ${NEW_CREATIVES_PER_CHAT} you have, and tell the person in one line that a chat makes up to ${NEW_CREATIVES_PER_CHAT} new creatives, so the rest go in a new chat. Editing or resizing the ones already made still works here. Working as a subagent: return now and say the limit was reached.`
+    }
+  };
+}
+async function enforceNewCreativeLimit(slug, canvasPath) {
+  const claim = await claimNewCreativeInWorkspace(
+    canvasOutputsRoot(canvasPath),
+    slug,
+    optionalChatId() ?? null,
+    path25.join(path25.dirname(path25.resolve(canvasPath)), "_definition.md")
+  );
+  if (claim.allowed) return;
+  process.stderr.write(`${JSON.stringify(creativeLimitRefusal(slug), null, 2)}
+`);
+  process.exit(2);
+}
+
 // src/engine/scaffold/staticAd.ts
 import { z as z57 } from "zod";
 
@@ -71567,8 +71620,8 @@ function extensionPrompt(format, legend, hasElementRefs) {
     "{{plate_spec}}"
   ].join("\n");
 }
-function ingestNode(id, path56, expect) {
-  return { id, type: "ingest", params: { source: "path", path: path56, expect } };
+function ingestNode(id, path57, expect) {
+  return { id, type: "ingest", params: { source: "path", path: path57, expect } };
 }
 function annotateBlueprintWithLabels(blueprintInput, elementsInput) {
   if (!blueprintInput || typeof blueprintInput !== "object") return blueprintInput;
@@ -71968,19 +72021,19 @@ function staticAdReport(input, elementsInput, opts) {
 import { access, readFile as readFile22 } from "fs/promises";
 
 // src/commands/canvas/composition-path.ts
-import { existsSync as existsSync7 } from "fs";
-import path25 from "path";
-function resolveShippedCanvasDir(name, startDir, exists3 = existsSync7, maxDepth = 8) {
-  const rel = path25.join("canvas", name);
+import { existsSync as existsSync8 } from "fs";
+import path26 from "path";
+function resolveShippedCanvasDir(name, startDir, exists3 = existsSync8, maxDepth = 8) {
+  const rel = path26.join("canvas", name);
   let dir = startDir;
   for (let i = 0; i < maxDepth; i++) {
-    const candidate = path25.join(dir, rel);
-    if (exists3(path25.join(candidate, "meta.json"))) return candidate;
-    const parent = path25.dirname(dir);
+    const candidate = path26.join(dir, rel);
+    if (exists3(path26.join(candidate, "meta.json"))) return candidate;
+    const parent = path26.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path25.resolve(startDir, "../../../", rel);
+  return path26.resolve(startDir, "../../../", rel);
 }
 
 // src/commands/canvas/scaffold-common.ts
@@ -72027,7 +72080,7 @@ function fileExists(target2) {
 }
 
 // src/commands/canvas/creative-definition.ts
-import path26 from "path";
+import path27 from "path";
 var PLATFORM_VALUES = ["meta", "google", "linkedin", "tiktok", "youtube", "x", "other"];
 var FORMAT_VALUES = ["1:1", "4:5", "9:16", "16:9", "1.91:1"];
 function titleFromSlug(slug) {
@@ -72075,16 +72128,16 @@ function buildCreativeDefinition(input) {
 }
 
 // src/commands/canvas/scaffold-static-ad-paths.ts
-import path27 from "path";
+import path28 from "path";
 function resolveScaffoldStaticAdPaths(rawFile, out, cwd = process.cwd(), slug) {
   const file = rawFile.trim();
   const imageIsUrl = /^https?:\/\//i.test(file);
-  const imageSource = imageIsUrl ? file : path27.resolve(cwd, file);
-  const outPath = out ? path27.resolve(cwd, out) : slug ? path27.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path27.join(cwd, "static-ad.canvas.json") : path27.join(path27.dirname(imageSource), "static-ad.canvas.json");
-  const blueprintPath2 = path27.join(path27.dirname(outPath), "prompt.json");
-  const creativeDir = slug ? path27.dirname(outPath) : null;
-  const definitionPath = creativeDir ? path27.join(creativeDir, "_definition.md") : null;
-  const referencesDir = creativeDir ? path27.join(creativeDir, "references") : null;
+  const imageSource = imageIsUrl ? file : path28.resolve(cwd, file);
+  const outPath = out ? path28.resolve(cwd, out) : slug ? path28.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path28.join(cwd, "static-ad.canvas.json") : path28.join(path28.dirname(imageSource), "static-ad.canvas.json");
+  const blueprintPath2 = path28.join(path28.dirname(outPath), "prompt.json");
+  const creativeDir = slug ? path28.dirname(outPath) : null;
+  const definitionPath = creativeDir ? path28.join(creativeDir, "_definition.md") : null;
+  const referencesDir = creativeDir ? path28.join(creativeDir, "references") : null;
   return { imageIsUrl, imageSource, outPath, blueprintPath: blueprintPath2, creativeDir, definitionPath, referencesDir };
 }
 var SCAFFOLD_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
@@ -72094,8 +72147,8 @@ function isValidScaffoldSlug(slug) {
 }
 
 // src/commands/canvas/sync-definition.ts
-import { readdir as readdir10, stat as stat4 } from "fs/promises";
-import path28 from "path";
+import { readdir as readdir11, stat as stat4 } from "fs/promises";
+import path29 from "path";
 import { defineCommand as defineCommand133 } from "citty";
 
 // src/commands/canvas/definition-graph.ts
@@ -72169,26 +72222,26 @@ async function syncCreativeDefinitionBestEffort(input) {
   }
 }
 async function resolveCanvasPath(inputPath) {
-  const resolved = path28.resolve(inputPath);
+  const resolved = path29.resolve(inputPath);
   let dir = resolved;
   try {
     if ((await stat4(resolved)).isFile()) {
       if (resolved.endsWith(".canvas.json")) return resolved;
-      dir = path28.dirname(resolved);
+      dir = path29.dirname(resolved);
     }
   } catch {
-    dir = resolved.endsWith(".canvas.json") ? path28.dirname(resolved) : resolved;
+    dir = resolved.endsWith(".canvas.json") ? path29.dirname(resolved) : resolved;
   }
   let entries;
   try {
-    entries = await readdir10(dir);
+    entries = await readdir11(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 ? path28.join(dir, chosen) : null;
+  return chosen ? path29.join(dir, chosen) : null;
 }
 var syncDefinitionCommand = defineCommand133({
   meta: {
@@ -72253,19 +72306,19 @@ async function resolveCastAvatars(flag) {
 
 // src/commands/canvas/scaffold-static-ad.ts
 async function writeStaticComposition(dir, width, height) {
-  await mkdir7(dir, { recursive: true });
-  const html = await readFile23(path29.join(SHIPPED_STATIC_COMPOSITION_DIR, "index.html"), "utf8");
-  await writeFile12(
-    path29.join(dir, "index.html"),
+  await mkdir8(dir, { recursive: true });
+  const html = await readFile23(path30.join(SHIPPED_STATIC_COMPOSITION_DIR, "index.html"), "utf8");
+  await writeFile13(
+    path30.join(dir, "index.html"),
     html.replaceAll("__WIDTH__", String(width)).replaceAll("__HEIGHT__", String(height)),
     "utf8"
   );
-  const meta = JSON.parse(await readFile23(path29.join(SHIPPED_STATIC_COMPOSITION_DIR, "meta.json"), "utf8"));
-  await writeFile12(path29.join(dir, "meta.json"), `${JSON.stringify({ ...meta, width, height }, null, 2)}
+  const meta = JSON.parse(await readFile23(path30.join(SHIPPED_STATIC_COMPOSITION_DIR, "meta.json"), "utf8"));
+  await writeFile13(path30.join(dir, "meta.json"), `${JSON.stringify({ ...meta, width, height }, null, 2)}
 `, "utf8");
 }
 function toCanvasRelative2(canvasDir, file) {
-  const rel = path29.relative(canvasDir, file).split(path29.sep).join("/");
+  const rel = path30.relative(canvasDir, file).split(path30.sep).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
 async function uploadSourceAsReference(source, isUrl, client) {
@@ -72547,7 +72600,8 @@ var scaffoldStaticAdCommand = defineCommand134({
       process.cwd(),
       slug
     );
-    await mkdir7(path29.dirname(outPath), { recursive: true });
+    if (slug) await enforceNewCreativeLimit(slug, outPath);
+    await mkdir8(path30.dirname(outPath), { recursive: true });
     let models;
     try {
       models = resolveModels(args8);
@@ -72584,7 +72638,7 @@ var scaffoldStaticAdCommand = defineCommand134({
     if (layout && annotated && typeof annotated === "object") {
       annotated.layout = layout;
     }
-    await writeFile12(blueprintPath2, `${JSON.stringify(annotated, null, 2)}
+    await writeFile13(blueprintPath2, `${JSON.stringify(annotated, null, 2)}
 `, "utf8");
     let canvasImagePath = imageSource;
     let canvasImageIsUrl = imageIsUrl;
@@ -72603,7 +72657,7 @@ var scaffoldStaticAdCommand = defineCommand134({
     );
     if (!placementsResult.ok) return fail4("invalid_placements", placementsResult.message);
     const placements = placementsResult.placements;
-    const canvasDir = path29.dirname(outPath);
+    const canvasDir = path30.dirname(outPath);
     const workspaceRoot = await findBrandRoot(canvasDir) ?? process.cwd();
     const kit = await readStaticBrandKit(workspaceRoot);
     const relative = (file) => file ? toCanvasRelative2(canvasDir, file) : void 0;
@@ -72634,12 +72688,12 @@ var scaffoldStaticAdCommand = defineCommand134({
       return fail4("scaffold", e instanceof Error ? e.message : String(e));
     }
     for (const layout2 of staticAdCompositions(blueprint, opts)) {
-      await writeStaticComposition(path29.resolve(canvasDir, layout2.dir), layout2.width, layout2.height);
+      await writeStaticComposition(path30.resolve(canvasDir, layout2.dir), layout2.width, layout2.height);
     }
     const specOptions = composeOptionsFor(canvas, annotated);
-    await writeFile12(path29.resolve(canvasDir, PLATE_SPEC_PATH), renderPlateSpec(annotated, specOptions), "utf8");
-    await writeFile12(path29.resolve(canvasDir, COMPOSE_SPEC_PATH), renderComposeSpec(annotated, kit, specOptions), "utf8");
-    const validation = await validateScaffoldedStaticAd(canvas, path29.dirname(outPath));
+    await writeFile13(path30.resolve(canvasDir, PLATE_SPEC_PATH), renderPlateSpec(annotated, specOptions), "utf8");
+    await writeFile13(path30.resolve(canvasDir, COMPOSE_SPEC_PATH), renderComposeSpec(annotated, kit, specOptions), "utf8");
+    const validation = await validateScaffoldedStaticAd(canvas, path30.dirname(outPath));
     if (validation.blocking.length > 0) {
       process.stderr.write(
         `${JSON.stringify({ ok: false, error: { code: "validation", issues: validation.blocking } }, null, 2)}
@@ -72647,10 +72701,10 @@ var scaffoldStaticAdCommand = defineCommand134({
       );
       process.exit(2);
     }
-    await writeFile12(outPath, `${JSON.stringify(canvas, null, 2)}
+    await writeFile13(outPath, `${JSON.stringify(canvas, null, 2)}
 `, "utf8");
     if (definitionPath && !await fileExists(definitionPath)) {
-      await writeFile12(
+      await writeFile13(
         definitionPath,
         buildCreativeDefinition({
           title: args8.title ? String(args8.title) : titleFromSlug(slug ?? ""),
@@ -72706,7 +72760,7 @@ var scaffoldStaticAdCommand = defineCommand134({
             run_estimated_credits: validation.estimatedCredits
           },
           checklist: {
-            edit_prompt: `Edit ${path29.basename(blueprintPath2)} \u2014 it is the blueprint generated from your image; rewrite it into the ad you want (palette, copy, claims, subjects). It feeds the generator directly.`,
+            edit_prompt: `Edit ${path30.basename(blueprintPath2)} \u2014 it is the blueprint generated from your image; rewrite it into the ad you want (palette, copy, claims, subjects). It feeds the generator directly.`,
             winning_mechanisms: report.winning_mechanisms,
             rebuild_the_mechanism: "`winning_mechanisms` is WHY the source ad works. Rewrite each one for our brand in prompt.json (a rhyme stays a rhyme in our words, a before/after stays a before/after of our product); never copy the source's literal copy.",
             assets_to_supply: report.elements,
@@ -72768,8 +72822,8 @@ function clientLogoMissNote(decision, domain) {
 }
 
 // src/commands/canvas/scaffold-ad.ts
-import { copyFile, cp, mkdir as mkdir8, readFile as readFile25, stat as stat5, writeFile as writeFile14 } from "fs/promises";
-import path31 from "path";
+import { copyFile, cp, mkdir as mkdir9, readFile as readFile25, stat as stat5, writeFile as writeFile15 } from "fs/promises";
+import path32 from "path";
 import { defineCommand as defineCommand135 } from "citty";
 
 // src/engine/scaffold/ad-spec.ts
@@ -73483,8 +73537,8 @@ function injectAdBrandOverlay(indexHtml, overlayHtml, style = {}) {
 }
 
 // src/commands/canvas/composition-dims.ts
-import { readFile as readFile24, writeFile as writeFile13 } from "fs/promises";
-import path30 from "path";
+import { readFile as readFile24, writeFile as writeFile14 } from "fs/promises";
+import path31 from "path";
 function patchCompositionMeta(metaJson, dims) {
   try {
     const meta = JSON.parse(metaJson);
@@ -73499,12 +73553,12 @@ function patchCompositionHtml(html, dims) {
   return html.replace(/(<meta\s+name="viewport"\s+content="width=)\d+(,\s*height=)\d+(")/i, `$1${dims.w}$2${dims.h}$3`).replace(/(width:\s*)\d+(px;\s*height:\s*)\d+(px;)/i, `$1${dims.w}$2${dims.h}$3`).replace(/(data-width=")\d+(")/i, `$1${dims.w}$2`).replace(/(data-height=")\d+(")/i, `$1${dims.h}$2`);
 }
 async function stampCompositionDims(compositionDir, dims) {
-  const metaPath = path30.join(compositionDir, "meta.json");
+  const metaPath = path31.join(compositionDir, "meta.json");
   const rawMeta = await readFile24(metaPath, "utf8");
-  await writeFile13(metaPath, patchCompositionMeta(rawMeta, dims), "utf8");
-  const htmlPath = path30.join(compositionDir, "index.html");
+  await writeFile14(metaPath, patchCompositionMeta(rawMeta, dims), "utf8");
+  const htmlPath = path31.join(compositionDir, "index.html");
   const rawHtml = await readFile24(htmlPath, "utf8");
-  await writeFile13(htmlPath, patchCompositionHtml(rawHtml, dims), "utf8");
+  await writeFile14(htmlPath, patchCompositionHtml(rawHtml, dims), "utf8");
 }
 
 // src/commands/canvas/scaffold-ad.ts
@@ -73799,8 +73853,9 @@ var scaffoldAdCommand = defineCommand135({
       videoModel: chosenVideoModel,
       ...avatarVoice ? { avatarVoice } : {}
     });
-    const slug = args8.slug ?? path31.basename(specPath).replace(/\.[^.]+$/, "");
-    const outPath = args8.out ?? (args8.slug ? path31.join("src/creatives", slug, `${slug}.canvas.json`) : path31.join(path31.dirname(specPath), `${slug}.canvas.json`));
+    const slug = args8.slug ?? path32.basename(specPath).replace(/\.[^.]+$/, "");
+    const outPath = args8.out ?? (args8.slug ? path32.join("src/creatives", slug, `${slug}.canvas.json`) : path32.join(path32.dirname(specPath), `${slug}.canvas.json`));
+    if (args8.slug) await enforceNewCreativeLimit(slug, outPath);
     let outAr;
     try {
       outAr = resolveAspect(void 0, spec.data.format.aspect_ratio, genAspectsFor(chosenVideoModel)).outAr;
@@ -73817,30 +73872,30 @@ var scaffoldAdCommand = defineCommand135({
       return;
     }
     const outDims = canvasDims(outAr);
-    const outDir = path31.dirname(outPath);
-    await mkdir8(outDir, { recursive: true });
-    const compositionDest = path31.join(outDir, "video-overlay-composition");
-    const captionsDest = path31.join(outDir, "tiktok-captions-composition");
+    const outDir = path32.dirname(outPath);
+    await mkdir9(outDir, { recursive: true });
+    const compositionDest = path32.join(outDir, "video-overlay-composition");
+    const captionsDest = path32.join(outDir, "tiktok-captions-composition");
     await cp(SHIPPED_OVERLAY_COMPOSITION_DIR, compositionDest, { recursive: true });
     await cp(SHIPPED_CAPTIONS_DIR, captionsDest, { recursive: true });
     await stampCompositionDims(compositionDest, outDims);
     await stampCompositionDims(captionsDest, outDims);
-    const captionsIndex = path31.join(captionsDest, "index.html");
-    await writeFile14(captionsIndex, injectAdCaptionPlacement(await readFile25(captionsIndex, "utf-8"), outAr), "utf-8");
+    const captionsIndex = path32.join(captionsDest, "index.html");
+    await writeFile15(captionsIndex, injectAdCaptionPlacement(await readFile25(captionsIndex, "utf-8"), outAr), "utf-8");
     const face = await stageBrandDisplayFace(outDir, captionsDest);
     if (face) {
-      await writeFile14(captionsIndex, injectAdDisplayFace(await readFile25(captionsIndex, "utf-8"), face.file), "utf-8");
+      await writeFile15(captionsIndex, injectAdDisplayFace(await readFile25(captionsIndex, "utf-8"), face.file), "utf-8");
     }
-    const blueprintPath2 = path31.join(outDir, "prompt.json");
-    const blueprintStylePath = path31.join(outDir, "prompt.style.json");
+    const blueprintPath2 = path32.join(outDir, "prompt.json");
+    const blueprintStylePath = path32.join(outDir, "prompt.style.json");
     await writeSceneFiles(outDir, blueprint);
-    await writeFile14(blueprintStylePath, renderStyleProjectionFromValue(blueprint), "utf8");
-    await writeFile14(path31.join(outDir, AD_SPEC_FILE), `${JSON.stringify(specArtifact, null, 2)}
+    await writeFile15(blueprintStylePath, renderStyleProjectionFromValue(blueprint), "utf8");
+    await writeFile15(path32.join(outDir, AD_SPEC_FILE), `${JSON.stringify(specArtifact, null, 2)}
 `, "utf8");
     const logoPath = noBrand ? void 0 : spec.data.brand?.logo?.trim();
-    const transcriptPath = path31.join(outDir, "transcript.json");
+    const transcriptPath = path32.join(outDir, "transcript.json");
     if (spec.data.voiceover === false) {
-      await writeFile14(transcriptPath, `${JSON.stringify(staticTranscript(spec.data, chosenVideoModel), null, 2)}
+      await writeFile15(transcriptPath, `${JSON.stringify(staticTranscript(spec.data, chosenVideoModel), null, 2)}
 `, "utf-8");
     }
     const opts = {
@@ -73850,10 +73905,10 @@ var scaffoldAdCommand = defineCommand135({
       // that stops the whole canvas. The same sheet model every other scaffold uses.
       sheetModel: ACTOR_SHEET_MODEL,
       videoModel: chosenVideoModel,
-      overlayCompositionPath: path31.relative(outDir, compositionDest),
-      captionsCompositionPath: path31.relative(outDir, captionsDest),
-      blueprintPath: path31.relative(outDir, blueprintPath2),
-      blueprintStylePath: path31.relative(outDir, blueprintStylePath),
+      overlayCompositionPath: path32.relative(outDir, compositionDest),
+      captionsCompositionPath: path32.relative(outDir, captionsDest),
+      blueprintPath: path32.relative(outDir, blueprintPath2),
+      blueprintStylePath: path32.relative(outDir, blueprintStylePath),
       aspect: spec.data.format.aspect_ratio,
       resolution: spec.data.format.resolution,
       // A beat is one clause and one card, so the cap has to clear a whole clause.
@@ -73892,17 +73947,17 @@ var scaffoldAdCommand = defineCommand135({
       // the stock voice this exists to avoid. It is to convert the LATER extracts onto the
       // first beat of the same speaker, which keeps a voice the clip really produced.
       ...avatar ? { keepRenderedVoice: true } : {},
-      ...spec.data.voiceover === false ? { staticTranscriptPath: path31.relative(outDir, transcriptPath) } : {}
+      ...spec.data.voiceover === false ? { staticTranscriptPath: path32.relative(outDir, transcriptPath) } : {}
     };
     const canvas = scaffoldVideoCanvas(blueprint, adSpecCastElements(spec.data, avatar), opts);
     const renderNode5 = canvas.nodes.find((n) => n.type === "hyperframe_render");
-    const renderedDir = renderNode5 ? path31.join(outDir, String(renderNode5.params?.composition ?? "")) : null;
+    const renderedDir = renderNode5 ? path32.join(outDir, String(renderNode5.params?.composition ?? "")) : null;
     let staged = null;
     let markIsLight = false;
     if (logoPath && renderedDir) {
-      const ext = path31.extname(logoPath) || ".png";
+      const ext = path32.extname(logoPath) || ".png";
       try {
-        await copyFile(logoPath, path31.join(renderedDir, `brand-mark${ext}`));
+        await copyFile(logoPath, path32.join(renderedDir, `brand-mark${ext}`));
         staged = { file: `brand-mark${ext}`, alt: spec.data.brand?.name ?? "brand" };
         markIsLight = await markInkIsLight(logoPath);
       } catch {
@@ -73921,12 +73976,12 @@ var scaffoldAdCommand = defineCommand135({
       plateIsDark: plateIsDark(spec.data.brand?.palette)
     }) : "";
     if (overlayHtml && renderedDir) {
-      const indexPath = path31.join(renderedDir, "index.html");
+      const indexPath = path32.join(renderedDir, "index.html");
       const html = await readFile25(indexPath, "utf-8");
-      await writeFile14(indexPath, injectAdBrandOverlay(html, overlayHtml, { aspect: outAr, ...face ? { face: AD_DISPLAY_FAMILY } : {} }), "utf-8");
+      await writeFile15(indexPath, injectAdBrandOverlay(html, overlayHtml, { aspect: outAr, ...face ? { face: AD_DISPLAY_FAMILY } : {} }), "utf-8");
     }
-    await writeFile14(
-      path31.join(outDir, REBUILD_FILE),
+    await writeFile15(
+      path32.join(outDir, REBUILD_FILE),
       `${JSON.stringify({ elements: adSpecCastElements(spec.data, avatar), opts }, null, 2)}
 `,
       "utf8"
@@ -73936,7 +73991,7 @@ var scaffoldAdCommand = defineCommand135({
       const meta = canvas.metadata;
       meta.todo = { ...meta.todo ?? {}, blocking_validation_issues: validation.issues };
     }
-    await writeFile14(outPath, `${JSON.stringify(canvas, null, 2)}
+    await writeFile15(outPath, `${JSON.stringify(canvas, null, 2)}
 `, "utf-8");
     if (!validation.ok) {
       process.stderr.write(
@@ -73956,10 +74011,10 @@ var scaffoldAdCommand = defineCommand135({
       return;
     }
     if (args8.slug) {
-      const definitionPath = path31.join(outDir, "_definition.md");
+      const definitionPath = path32.join(outDir, "_definition.md");
       const definitionExists = await stat5(definitionPath).then(() => true, () => false);
       if (!definitionExists) {
-        await writeFile14(
+        await writeFile15(
           definitionPath,
           buildCreativeDefinition({
             title: titleFromSlug(slug),
@@ -74074,10 +74129,10 @@ async function fetchClientLogo() {
     if (!response.ok) return { ok: false, reason: clientLogoMissNote({ use: false, reason: "no_hits" }, domain) };
     const bytes = Buffer.from(await response.arrayBuffer());
     const extension = /\.(svg|png|jpg|jpeg|webp)(?:\?|$)/i.exec(decision.url)?.[1]?.toLowerCase() ?? "svg";
-    const dir = path31.join(BRAND_DIR, "logos");
-    await mkdir8(dir, { recursive: true });
-    const file = path31.join(dir, `brand-mark.${extension}`);
-    await writeFile14(file, bytes);
+    const dir = path32.join(BRAND_DIR, "logos");
+    await mkdir9(dir, { recursive: true });
+    const file = path32.join(dir, `brand-mark.${extension}`);
+    await writeFile15(file, bytes);
     return { ok: true, path: file };
   } catch {
     return { ok: false, reason: clientLogoMissNote({ use: false, reason: "no_hits" }, domain) };
@@ -74095,14 +74150,14 @@ async function stageBrandDisplayFace(outDir, compositionDir) {
   if (!face) return null;
   try {
     if ("path" in face.slot) {
-      const file2 = `brand-face${path31.extname(face.slot.path).toLowerCase()}`;
-      await copyFile(face.slot.path, path31.join(compositionDir, file2));
-      return { file: file2, label: `the font file \`${path31.relative(root, face.slot.path)}\`` };
+      const file2 = `brand-face${path32.extname(face.slot.path).toLowerCase()}`;
+      await copyFile(face.slot.path, path32.join(compositionDir, file2));
+      return { file: file2, label: `the font file \`${path32.relative(root, face.slot.path)}\`` };
     }
     const { buffer } = await fetchExternalBytes(face.slot.url, { maxBytes: MAX_FONT_BYTES });
     const extension = /\.(woff2|woff|ttf|otf)(?:\?|$)/i.exec(face.slot.url)?.[1]?.toLowerCase() ?? "woff2";
     const file = `brand-face.${extension}`;
-    await writeFile14(path31.join(compositionDir, file), buffer);
+    await writeFile15(path32.join(compositionDir, file), buffer);
     return { file, label: `${face.family ?? "the brand's typeface"}, loaded as a web font` };
   } catch {
     return null;
@@ -74110,9 +74165,9 @@ async function stageBrandDisplayFace(outDir, compositionDir) {
 }
 
 // src/commands/canvas/scaffold-video.ts
-import { cp as cp2, mkdir as mkdir9, readFile as readFile28, rm as rm8, writeFile as writeFile15 } from "fs/promises";
+import { cp as cp2, mkdir as mkdir10, readFile as readFile28, rm as rm8, writeFile as writeFile16 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import path33 from "path";
+import path34 from "path";
 import { defineCommand as defineCommand136 } from "citty";
 
 // src/engine/scaffold/lib/model-router.ts
@@ -74152,7 +74207,7 @@ function routeVideoModel(input) {
 
 // src/engine/nodes/local/lib/sceneDetect.ts
 import { execFile as execFile3 } from "child_process";
-import { mkdtemp as mkdtemp2, readdir as readdir11, readFile as readFile26, rm as rm7 } from "fs/promises";
+import { mkdtemp as mkdtemp2, readdir as readdir12, readFile as readFile26, rm as rm7 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join3 } from "path";
 import { promisify as promisify3 } from "util";
@@ -74226,7 +74281,7 @@ async function runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs)
       ],
       { encoding: "utf-8", maxBuffer: 32 * 1024 * 1024, timeout: timeoutMs }
     );
-    const csvName = (await readdir11(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
+    const csvName = (await readdir12(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
     if (!csvName) return [];
     return parsePySceneDetectCsvCuts(await readFile26(join3(outDir, csvName), "utf-8"));
   } finally {
@@ -74253,7 +74308,7 @@ async function detectSceneCutsPySceneDetect(filePath, opts = {}) {
 
 // src/commands/canvas/gitignore.ts
 import { appendFile, readFile as readFile27 } from "fs/promises";
-import path32 from "path";
+import path33 from "path";
 function missingGitignoreEntries(existing, entries) {
   const present2 = new Set(
     existing.split("\n").map((l) => l.trim().replace(/\/+$/, "")).filter((l) => l.length > 0 && !l.startsWith("#"))
@@ -74261,7 +74316,7 @@ function missingGitignoreEntries(existing, entries) {
   return entries.filter((e) => !present2.has(e.trim().replace(/\/+$/, "")));
 }
 async function ensureGitignore(dir, entries) {
-  const file = path32.join(dir, ".gitignore");
+  const file = path33.join(dir, ".gitignore");
   let existing;
   try {
     existing = await readFile27(file, "utf8");
@@ -74306,7 +74361,7 @@ async function loadTranscriptBestEffort(ref2) {
 async function stageCaptions(outDir, transcript) {
   const text2 = transcript?.trim();
   if (!text2 || text2 === "[]") return {};
-  const compositionPath = path33.join(outDir, "tiktok-captions-composition");
+  const compositionPath = path34.join(outDir, "tiktok-captions-composition");
   await cp2(SHIPPED_CAPTIONS_DIR, compositionPath, { recursive: true });
   return { compositionPath };
 }
@@ -74342,7 +74397,7 @@ var VIDEO_EXT_BY_MIME = {
   "video/x-matroska": ".mkv"
 };
 function referenceVideoExt(url, contentType) {
-  const fromPath = path33.extname(new URL(url).pathname).toLowerCase();
+  const fromPath = path34.extname(new URL(url).pathname).toLowerCase();
   if (fromPath && fromPath.length <= 5) return fromPath;
   const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase();
   return mime && VIDEO_EXT_BY_MIME[mime] || ".mp4";
@@ -74368,7 +74423,7 @@ function framesModeReport(canvas, requested) {
   return { frames_mode: mode, ...refused ? { frames_reuse_refused: refused } : {} };
 }
 async function materializeReferenceVideo(fileArg2) {
-  if (!/^https?:\/\//i.test(fileArg2)) return path33.resolve(fileArg2);
+  if (!/^https?:\/\//i.test(fileArg2)) return path34.resolve(fileArg2);
   let bytes;
   let contentType;
   try {
@@ -74380,11 +74435,11 @@ async function materializeReferenceVideo(fileArg2) {
     throw new Error(`failed to download reference video: ${e instanceof Error ? e.message : String(e)}`);
   }
   if (bytes.length === 0) throw new Error("reference video download was empty");
-  const dest = path33.join(
+  const dest = path34.join(
     tmpdir3(),
     `baker-ref-${sha256Hex(bytes).slice(0, 16)}${referenceVideoExt(fileArg2, contentType)}`
   );
-  await writeFile15(dest, bytes);
+  await writeFile16(dest, bytes);
   return dest;
 }
 function resolveSeamDedup(raw) {
@@ -74607,11 +74662,12 @@ var scaffoldVideoCommand = defineCommand136({
     } catch (e) {
       return fail4("download", e instanceof Error ? e.message : String(e));
     }
-    const base = path33.basename(videoPath, path33.extname(videoPath));
-    const outPath = args8.out ? path33.resolve(String(args8.out)) : slug ? path33.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path33.join(path33.dirname(videoPath), `${base}.video.canvas.json`);
-    const outDir = path33.dirname(outPath);
-    const blueprintPath2 = path33.join(outDir, "prompt.json");
-    const blueprintStylePath = path33.join(outDir, "prompt.style.json");
+    const base = path34.basename(videoPath, path34.extname(videoPath));
+    const outPath = args8.out ? path34.resolve(String(args8.out)) : slug ? path34.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path34.join(path34.dirname(videoPath), `${base}.video.canvas.json`);
+    if (slug) await enforceNewCreativeLimit(slug, outPath);
+    const outDir = path34.dirname(outPath);
+    const blueprintPath2 = path34.join(outDir, "prompt.json");
+    const blueprintStylePath = path34.join(outDir, "prompt.style.json");
     const frames = args8.frames === "reuse" ? "reuse" : "generate";
     const maxScenes = args8["max-scenes"] ? Number(args8["max-scenes"]) : void 0;
     if (Number.isFinite(maxScenes)) {
@@ -74659,10 +74715,10 @@ var scaffoldVideoCommand = defineCommand136({
       process.stderr.write(`\u{1F3AC} Photoreal on-camera cast detected \u2192 generating clips on ${videoModel} (dodges Seedance's real-person filter).
 `);
     }
-    await mkdir9(outDir, { recursive: true });
+    await mkdir10(outDir, { recursive: true });
     const annotated = annotateBlueprintWithElements(blueprint, elements);
     await writeSceneFiles(outDir, annotated);
-    await writeFile15(blueprintStylePath, renderStyleProjectionFromValue(annotated), "utf8");
+    await writeFile16(blueprintStylePath, renderStyleProjectionFromValue(annotated), "utf8");
     let aspect;
     try {
       aspect = resolveAspect(
@@ -74680,10 +74736,10 @@ var scaffoldVideoCommand = defineCommand136({
 `
       );
     }
-    const compositionDest = path33.join(outDir, "video-overlay-composition");
+    const compositionDest = path34.join(outDir, "video-overlay-composition");
     await cp2(SHIPPED_OVERLAY_COMPOSITION_DIR, compositionDest, { recursive: true });
     await stampCompositionDims(compositionDest, outDims);
-    const indexPath = path33.join(compositionDest, "index.html");
+    const indexPath = path34.join(compositionDest, "index.html");
     const overlayHtml = buildOverlayHtml(blueprint, { captionsActive: Boolean(transcript), videoModel });
     const indexHtml = await readFile28(indexPath, "utf8");
     const injected = indexHtml.replace("<!--OVERLAYS-->", () => overlayHtml);
@@ -74693,16 +74749,16 @@ var scaffoldVideoCommand = defineCommand136({
         `video-overlay-composition/index.html is missing the <!--OVERLAYS--> marker \u2014 cannot inject the overlay layer`
       );
     }
-    await writeFile15(indexPath, injected, "utf8");
+    await writeFile16(indexPath, injected, "utf8");
     const captions = await stageCaptions(outDir, transcript);
     if (captions.compositionPath) await stampCompositionDims(captions.compositionPath, outDims);
     const opts = {
       imageModel,
       videoModel,
-      overlayCompositionPath: path33.relative(outDir, compositionDest),
-      captionsCompositionPath: captions.compositionPath ? path33.relative(outDir, captions.compositionPath) : void 0,
-      blueprintPath: path33.relative(outDir, blueprintPath2),
-      blueprintStylePath: path33.relative(outDir, blueprintStylePath),
+      overlayCompositionPath: path34.relative(outDir, compositionDest),
+      captionsCompositionPath: captions.compositionPath ? path34.relative(outDir, captions.compositionPath) : void 0,
+      blueprintPath: path34.relative(outDir, blueprintPath2),
+      blueprintStylePath: path34.relative(outDir, blueprintStylePath),
       frames,
       ambient: Boolean(args8.ambient),
       seamDedup: resolveSeamDedup(args8["seam-dedup"]),
@@ -74727,10 +74783,10 @@ var scaffoldVideoCommand = defineCommand136({
       todo.blocking_validation_issues = validation.issues;
       meta.todo = todo;
     }
-    await writeFile15(outPath, `${JSON.stringify(canvas, null, 2)}
+    await writeFile16(outPath, `${JSON.stringify(canvas, null, 2)}
 `, "utf8");
-    await writeFile15(
-      path33.join(outDir, REBUILD_FILE),
+    await writeFile16(
+      path34.join(outDir, REBUILD_FILE),
       `${JSON.stringify({ elements, opts }, null, 2)}
 `,
       "utf8"
@@ -74757,9 +74813,9 @@ var scaffoldVideoCommand = defineCommand136({
     await ensureGitignore(process.cwd(), ["canvas/", ".context/"]);
     const sourceRef = videoSourceReference(blueprint, fileArg2);
     if (slug) {
-      const definitionPath = path33.join(outDir, "_definition.md");
+      const definitionPath = path34.join(outDir, "_definition.md");
       if (!await fileExists(definitionPath)) {
-        await writeFile15(
+        await writeFile16(
           definitionPath,
           buildCreativeDefinition({
             title: titleFromSlug(slug),
@@ -74813,7 +74869,7 @@ var scaffoldVideoCommand = defineCommand136({
             graph: canvas.metadata?.video?.graph_stats
           },
           checklist: {
-            edit_prompt: `The blueprint is split so you edit ONE small file at a time \u2014 never a giant one. Per-scene content (a scene's dialogue, action, frame prompts, overlays) lives in \`scenes/sNN.json\` \u2014 edit the single scene you want to change. Global cast/palette/brand/copy lives in \`${path33.basename(blueprintPath2)}\`. \`baker canvas validate\`/\`run\` re-assemble the blueprint and re-flow every edited scene back into the render (and regenerate ${path33.basename(blueprintStylePath)}, the projection each frame's target_blueprint reads) \u2014 so your scene edits reach the render automatically. Never hand-edit the inlined node prompts in the canvas or the derived ${path33.basename(blueprintStylePath)}; both are regenerated.`,
+            edit_prompt: `The blueprint is split so you edit ONE small file at a time \u2014 never a giant one. Per-scene content (a scene's dialogue, action, frame prompts, overlays) lives in \`scenes/sNN.json\` \u2014 edit the single scene you want to change. Global cast/palette/brand/copy lives in \`${path34.basename(blueprintPath2)}\`. \`baker canvas validate\`/\`run\` re-assemble the blueprint and re-flow every edited scene back into the render (and regenerate ${path34.basename(blueprintStylePath)}, the projection each frame's target_blueprint reads) \u2014 so your scene edits reach the render automatically. Never hand-edit the inlined node prompts in the canvas or the derived ${path34.basename(blueprintStylePath)}; both are regenerated.`,
             recurring_elements_to_supply: report.elements,
             voices_to_confirm: report.dialogue.map((d) => ({
               scene: d.scene,
@@ -74850,8 +74906,8 @@ var scaffoldVideoCommand = defineCommand136({
 });
 
 // src/commands/canvas/set-prompt.ts
-import { readFile as readFile29, writeFile as writeFile16 } from "fs/promises";
-import path34 from "path";
+import { readFile as readFile29, writeFile as writeFile17 } from "fs/promises";
+import path35 from "path";
 import { defineCommand as defineCommand137 } from "citty";
 function setNodePrompt(canvas, nodeId, text2) {
   const nodes = canvas?.nodes;
@@ -74880,7 +74936,7 @@ var SetPromptError = class extends Error {
   }
 };
 async function setPromptInCanvasFile(canvasPath, nodeId, text2) {
-  const filePath = path34.resolve(canvasPath);
+  const filePath = path35.resolve(canvasPath);
   const original = await readFile29(filePath, "utf8");
   let canvas;
   try {
@@ -74904,9 +74960,9 @@ async function setPromptInCanvasFile(canvasPath, nodeId, text2) {
   } catch (e) {
     throw new SetPromptError("node_not_found", e instanceof Error ? e.message : String(e));
   }
-  await writeFile16(filePath, `${JSON.stringify(updated, null, 2)}
+  await writeFile17(filePath, `${JSON.stringify(updated, null, 2)}
 `, "utf8");
-  const restore = () => writeFile16(filePath, original, "utf8");
+  const restore = () => writeFile17(filePath, original, "utf8");
   try {
     const prepared = await prepareCanvas(filePath);
     const validation = await validateCanvasDeep(prepared.canvas, defaultRegistry());
@@ -74948,7 +75004,7 @@ var setPromptCommand = defineCommand137({
   },
   async run({ args: args8 }) {
     let text2;
-    if (args8["text-file"]) text2 = await readFile29(path34.resolve(String(args8["text-file"])), "utf8");
+    if (args8["text-file"]) text2 = await readFile29(path35.resolve(String(args8["text-file"])), "utf8");
     else if (args8.text !== void 0) text2 = String(args8.text);
     else {
       process.stderr.write(
@@ -75005,7 +75061,7 @@ var staleCommand = defineCommand138({
 });
 
 // src/commands/canvas/validate.ts
-import path35 from "path";
+import path36 from "path";
 import { defineCommand as defineCommand139 } from "citty";
 var validateCommand = defineCommand139({
   meta: {
@@ -75014,7 +75070,7 @@ var validateCommand = defineCommand139({
   },
   args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
   async run({ args: args8 }) {
-    const filePath = path35.resolve(String(args8.file));
+    const filePath = path36.resolve(String(args8.file));
     let prepared;
     try {
       prepared = await prepareCanvas(filePath, { log: (line) => process.stderr.write(`${line}
@@ -75576,7 +75632,7 @@ var feedbackCommand = defineCommand144({
 
 // src/commands/creatives/performance.ts
 import { readFileSync as readFileSync16 } from "fs";
-import path36 from "path";
+import path37 from "path";
 import { defineCommand as defineCommand145 } from "citty";
 import { parse as parseYaml2 } from "yaml";
 var DESCRIPTION4 = `How each Baker creative is doing in the live Meta ads that show it: spend, impressions, CTR, CPC, results, cost per result, frequency and a fatigue verdict, next to the angle, hook, mechanism and dominant slot its definition set out to test. Video creatives add hookRate (percent of impressions that watched 3 seconds) and holdRate (percent of those that reached a ThruPlay). Use it before briefing new creatives, to learn which angle and mechanism to make next and which creatives to replace.
@@ -75629,7 +75685,7 @@ function definitionInsights(markdown) {
 }
 function readLocalDefinition(slug) {
   try {
-    return readFileSync16(path36.join(process.cwd(), "src", "creatives", slug, "_definition.md"), "utf8");
+    return readFileSync16(path37.join(process.cwd(), "src", "creatives", slug, "_definition.md"), "utf8");
   } catch {
     return null;
   }
@@ -76188,12 +76244,12 @@ Full guide: __tooling__/docs/tools/baker/creatives.md`
 import { defineCommand as defineCommand149 } from "citty";
 
 // src/commands/experiment/composition.ts
-import { readdir as readdir13, readFile as readFile33 } from "fs/promises";
-import path38 from "path";
+import { readdir as readdir14, readFile as readFile33 } from "fs/promises";
+import path39 from "path";
 
 // src/commands/landing/import-graph.ts
-import { readdir as readdir12, readFile as readFile32, stat as stat6 } from "fs/promises";
-import path37 from "path";
+import { readdir as readdir13, readFile as readFile32, stat as stat6 } from "fs/promises";
+import path38 from "path";
 var SOURCE_EXT = /\.(astro|ts|tsx|js|jsx|mjs|cjs|vue|svelte)$/;
 var RESOLVE_CANDIDATES = [
   "",
@@ -76220,13 +76276,13 @@ async function isFile(p) {
 async function walkFiles(dir) {
   let entries;
   try {
-    entries = await readdir12(dir, { withFileTypes: true });
+    entries = await readdir13(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const entry of entries) {
-    const full = path37.join(dir, entry.name);
+    const full = path38.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === "dist") continue;
       out.push(...await walkFiles(full));
@@ -76240,8 +76296,8 @@ async function resolveSpecifier(specifier, fromFile, root) {
   const bare = specifier.split("?")[0] ?? "";
   if (bare.includes("*")) return null;
   let base;
-  if (bare.startsWith("/")) base = path37.join(root, bare.slice(1));
-  else if (bare.startsWith(".")) base = path37.resolve(path37.dirname(fromFile), bare);
+  if (bare.startsWith("/")) base = path38.join(root, bare.slice(1));
+  else if (bare.startsWith(".")) base = path38.resolve(path38.dirname(fromFile), bare);
   else return null;
   for (const suffix of RESOLVE_CANDIDATES) {
     const candidate = base + suffix;
@@ -76263,7 +76319,7 @@ async function importedFiles(text2, file, root) {
 }
 async function landingGraphFiles(root, slug) {
   const seen = /* @__PURE__ */ new Set();
-  const queue = await walkFiles(path37.join(root, "src/pages", slug));
+  const queue = await walkFiles(path38.join(root, "src/pages", slug));
   while (queue.length > 0) {
     const file = queue.pop();
     if (file === void 0 || seen.has(file)) continue;
@@ -76278,7 +76334,7 @@ async function landingGraphFiles(root, slug) {
       if (!seen.has(target2)) queue.push(target2);
     }
   }
-  return new Set([...seen].map((abs) => path37.relative(root, abs).split(path37.sep).join("/")));
+  return new Set([...seen].map((abs) => path38.relative(root, abs).split(path38.sep).join("/")));
 }
 
 // src/commands/experiment/composition.ts
@@ -76323,7 +76379,7 @@ function formsOnlyIn(these, those) {
 }
 async function knownFlows(root) {
   try {
-    const entries = await readdir13(path38.join(root, "src/lib/flow-engine/flows"), { withFileTypes: true });
+    const entries = await readdir14(path39.join(root, "src/lib/flow-engine/flows"), { withFileTypes: true });
     return new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
   } catch {
     return /* @__PURE__ */ new Set();
@@ -76334,7 +76390,7 @@ async function readForms(root, slug) {
     const [files, flows] = await Promise.all([landingGraphFiles(root, slug), knownFlows(root)]);
     if (flows.size === 0) return [];
     const texts = await Promise.all(
-      [...files].filter((file) => /\.(astro|ts|tsx|js|mjs)$/.test(file)).map((file) => readFile33(path38.join(root, file), "utf8"))
+      [...files].filter((file) => /\.(astro|ts|tsx|js|mjs)$/.test(file)).map((file) => readFile33(path39.join(root, file), "utf8"))
     );
     return formsReferenced(texts, flows);
   } catch {
@@ -76344,8 +76400,8 @@ async function readForms(root, slug) {
 
 // src/commands/experiment/fold.ts
 import { statSync } from "fs";
-import { cp as cp3, mkdir as mkdir10, readdir as readdir14, readFile as readFile34, rm as rm9, stat as stat7, writeFile as writeFile17 } from "fs/promises";
-import path40 from "path";
+import { cp as cp3, mkdir as mkdir11, readdir as readdir15, readFile as readFile34, rm as rm9, stat as stat7, writeFile as writeFile18 } from "fs/promises";
+import path41 from "path";
 
 // ../api/src/experiments/variants.ts
 var VARIANT_SEPARATOR = "--";
@@ -76370,21 +76426,21 @@ function nextVariantNumber(page, existingSlugs, archived) {
 }
 
 // src/commands/landing/repoint.ts
-import path39 from "path";
+import path40 from "path";
 var QUOTED_RELATIVE = /(['"])(\.\.?\/[^'"]*)\1/g;
 function isInside3(abs, dir) {
-  return abs === dir || abs.startsWith(dir + path39.sep);
+  return abs === dir || abs.startsWith(dir + path40.sep);
 }
 function toSpecifier(from, to) {
-  const rel = path39.relative(from, to).split(path39.sep).join("/");
+  const rel = path40.relative(from, to).split(path40.sep).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
 function repointSpecifier(spec, opts) {
   if (!spec.startsWith(".")) return spec;
-  const abs = path39.resolve(opts.fromDir, spec);
+  const abs = path40.resolve(opts.fromDir, spec);
   if (opts.forkedTargets?.has(abs)) {
-    const withinControl = path39.relative(opts.controlDir, abs);
-    return toSpecifier(opts.toDir, path39.resolve(opts.variantDir, withinControl));
+    const withinControl = path40.relative(opts.controlDir, abs);
+    return toSpecifier(opts.toDir, path40.resolve(opts.variantDir, withinControl));
   }
   if (!isInside3(abs, opts.controlDir)) return spec;
   return toSpecifier(opts.toDir, abs);
@@ -76396,9 +76452,9 @@ function repointFile(text2, opts) {
 }
 function repointMoved(text2, opts) {
   return text2.replace(QUOTED_RELATIVE, (_match, quote, spec) => {
-    const abs = path39.resolve(opts.fromDir, spec);
-    const within = path39.relative(opts.movedFrom, abs);
-    const target2 = within.startsWith("..") || path39.isAbsolute(within) ? abs : path39.resolve(opts.movedTo, within);
+    const abs = path40.resolve(opts.fromDir, spec);
+    const within = path40.relative(opts.movedFrom, abs);
+    const target2 = within.startsWith("..") || path40.isAbsolute(within) ? abs : path40.resolve(opts.movedTo, within);
     return `${quote}${toSpecifier(opts.toDir, target2)}${quote}`;
   });
 }
@@ -76407,7 +76463,7 @@ function repointMoved(text2, opts) {
 var ARCHIVE_ROOT = "src/_variants";
 var QUOTED_RELATIVE2 = /(['"])(\.\.?\/[^'"]*)\1/g;
 function posix2(p) {
-  return p.split(path40.sep).join("/");
+  return p.split(path41.sep).join("/");
 }
 async function isDir(p) {
   try {
@@ -76419,46 +76475,46 @@ async function isDir(p) {
 async function filesUnder(dir, prefix = "") {
   let entries;
   try {
-    entries = await readdir14(dir, { withFileTypes: true });
+    entries = await readdir15(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const entry of entries) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) out.push(...await filesUnder(path40.join(dir, entry.name), rel));
+    if (entry.isDirectory()) out.push(...await filesUnder(path41.join(dir, entry.name), rel));
     else out.push(rel);
   }
   return out.sort();
 }
 var TEXT_EXT = /\.(astro|ts|tsx|js|jsx|mjs|cjs|vue|svelte|md|json|css)$/;
 function archiveRelPath(abs, base) {
-  if (!abs.startsWith(base + path40.sep)) return null;
-  return posix2(path40.relative(base, abs));
+  if (!abs.startsWith(base + path41.sep)) return null;
+  return posix2(path41.relative(base, abs));
 }
 async function archiveArm(opts) {
   const { root, armDir, pageDir, archiveDir, armSlug } = opts;
   const targets = await archiveContents({ root, armDir, pageDir, armSlug });
-  const archivedBySource = new Map([...targets].map(([rel, abs]) => [abs, path40.join(archiveDir, rel)]));
+  const archivedBySource = new Map([...targets].map(([rel, abs]) => [abs, path41.join(archiveDir, rel)]));
   const written = [];
   for (const [rel, abs] of [...targets].sort()) {
-    const dest = path40.join(archiveDir, rel);
-    await mkdir10(path40.dirname(dest), { recursive: true });
+    const dest = path41.join(archiveDir, rel);
+    await mkdir11(path41.dirname(dest), { recursive: true });
     if (!TEXT_EXT.test(rel)) {
       await cp3(abs, dest);
     } else {
       const text2 = await readFile34(abs, "utf8");
-      await writeFile17(dest, repointIntoArchive(text2, abs, dest, archivedBySource), "utf8");
+      await writeFile18(dest, repointIntoArchive(text2, abs, dest, archivedBySource), "utf8");
     }
-    written.push(posix2(path40.relative(root, dest)));
+    written.push(posix2(path41.relative(root, dest)));
   }
   return written;
 }
 async function archiveContents(opts) {
   const { root, armDir, pageDir, armSlug } = opts;
   const graph = await landingGraphFiles(root, armSlug);
-  const reachable = new Set([...graph].map((rel) => path40.resolve(root, rel)));
-  for (const rel of await filesUnder(armDir)) reachable.add(path40.join(armDir, rel));
+  const reachable = new Set([...graph].map((rel) => path41.resolve(root, rel)));
+  for (const rel of await filesUnder(armDir)) reachable.add(path41.join(armDir, rel));
   const sorted = [...reachable].sort();
   const targets = /* @__PURE__ */ new Map();
   for (const base of [pageDir, armDir]) {
@@ -76471,14 +76527,14 @@ async function archiveContents(opts) {
   return targets;
 }
 function repointIntoArchive(text2, sourceAbs, destAbs, archivedBySource) {
-  const fromDir = path40.dirname(sourceAbs);
-  const toDir = path40.dirname(destAbs);
+  const fromDir = path41.dirname(sourceAbs);
+  const toDir = path41.dirname(destAbs);
   return text2.replace(QUOTED_RELATIVE2, (match, quote, spec, offset) => {
     const [specPath, suffix] = splitSuffix(spec);
-    const target2 = path40.resolve(fromDir, specPath);
+    const target2 = path41.resolve(fromDir, specPath);
     const resolved = resolveInArchive(target2, archivedBySource) ?? resolveOnDisk(target2, isImportPosition(text2, offset));
     if (resolved === null) return match;
-    const rel = posix2(path40.relative(toDir, resolved));
+    const rel = posix2(path41.relative(toDir, resolved));
     return `${quote}${rel.startsWith(".") ? rel : `./${rel}`}${suffix}${quote}`;
   });
 }
@@ -76512,25 +76568,25 @@ async function promoteVariantFiles(opts) {
   const written = [];
   for (const rel of await filesUnder(variantDir)) {
     if (rel === "_definition.md") continue;
-    const from = path40.join(variantDir, rel);
-    const to = path40.join(pageDir, rel);
-    await mkdir10(path40.dirname(to), { recursive: true });
+    const from = path41.join(variantDir, rel);
+    const to = path41.join(pageDir, rel);
+    await mkdir11(path41.dirname(to), { recursive: true });
     if (!TEXT_EXT.test(rel)) {
       await cp3(from, to);
     } else {
       const text2 = await readFile34(from, "utf8");
-      await writeFile17(
+      await writeFile18(
         to,
         repointMoved(text2, {
-          fromDir: path40.dirname(from),
-          toDir: path40.dirname(to),
+          fromDir: path41.dirname(from),
+          toDir: path41.dirname(to),
           movedFrom: variantDir,
           movedTo: pageDir
         }),
         "utf8"
       );
     }
-    written.push(posix2(path40.relative(root, to)));
+    written.push(posix2(path41.relative(root, to)));
   }
   return written;
 }
@@ -76554,8 +76610,8 @@ function archiveRecord(target2, variantNumber) {
 `;
 }
 async function foldExperiment(root, target2) {
-  const pageDir = path40.resolve(root, "src/pages", target2.landingSlug);
-  const variantDir = path40.resolve(root, "src/pages", target2.variantSlug);
+  const pageDir = path41.resolve(root, "src/pages", target2.landingSlug);
+  const variantDir = path41.resolve(root, "src/pages", target2.variantSlug);
   const variantNumber = variantNumberOf(target2.variantSlug);
   if (variantNumber === null) {
     return {
@@ -76569,9 +76625,9 @@ async function foldExperiment(root, target2) {
     return { error: `src/pages/${target2.variantSlug}/ is already gone \u2014 this test looks folded in already` };
   }
   const archiveKey = target2.landingInternalId ?? target2.landingSlug;
-  const archiveDir = path40.resolve(root, ARCHIVE_ROOT, archiveKey, String(variantNumber));
+  const archiveDir = path41.resolve(root, ARCHIVE_ROOT, archiveKey, String(variantNumber));
   await rm9(archiveDir, { recursive: true, force: true });
-  await mkdir10(archiveDir, { recursive: true });
+  await mkdir11(archiveDir, { recursive: true });
   const written = await archiveArm({
     root,
     armDir: target2.survivor === "variant" ? pageDir : variantDir,
@@ -76579,8 +76635,8 @@ async function foldExperiment(root, target2) {
     archiveDir,
     armSlug: target2.survivor === "variant" ? target2.landingSlug : target2.variantSlug
   });
-  await writeFile17(path40.join(archiveDir, "_variant.json"), archiveRecord(target2, variantNumber), "utf8");
-  written.push(posix2(path40.join(ARCHIVE_ROOT, archiveKey, String(variantNumber), "_variant.json")));
+  await writeFile18(path41.join(archiveDir, "_variant.json"), archiveRecord(target2, variantNumber), "utf8");
+  written.push(posix2(path41.join(ARCHIVE_ROOT, archiveKey, String(variantNumber), "_variant.json")));
   if (target2.survivor === "variant") {
     written.push(...await promoteVariantFiles({ root, pageDir, variantDir }));
   }
@@ -76588,7 +76644,7 @@ async function foldExperiment(root, target2) {
   return {
     experimentId: target2.experimentId,
     page: target2.landingSlug,
-    archivedTo: posix2(path40.join(ARCHIVE_ROOT, archiveKey, String(variantNumber))),
+    archivedTo: posix2(path41.join(ARCHIVE_ROOT, archiveKey, String(variantNumber))),
     written,
     removed: [`src/pages/${target2.variantSlug}`]
   };
@@ -77361,10 +77417,10 @@ function parseEvidence(raw, rawArgs) {
 
 // src/commands/experiment/identity.ts
 import { readFile as readFile35 } from "fs/promises";
-import path41 from "path";
+import path42 from "path";
 async function readPageInternalId(root, slug) {
   try {
-    const text2 = await readFile35(path41.resolve(root, "src", "pages", slug, "_definition.md"), "utf8");
+    const text2 = await readFile35(path42.resolve(root, "src", "pages", slug, "_definition.md"), "utf8");
     return /^internalId:\s*"?([^"\s]+)"?\s*$/m.exec(text2)?.[1];
   } catch {
     return void 0;
@@ -77373,7 +77429,7 @@ async function readPageInternalId(root, slug) {
 
 // src/commands/experiment/measurement.ts
 import { readFile as readFile36 } from "fs/promises";
-import path42 from "path";
+import path43 from "path";
 function eventDeclarationsIn(source) {
   const found = [];
   const pattern = /\b(data-baker-(?:view|event))\s*=\s*["']([^"']+)["']/g;
@@ -77433,7 +77489,7 @@ function sectionsOf(files, slug) {
   return files.filter((file) => file.startsWith(prefix) && !file.slice(prefix.length).startsWith("index."));
 }
 async function declarationsOf(root, files) {
-  const sources = await Promise.all(files.map((file) => readFile36(path42.join(root, file), "utf8").catch(() => "")));
+  const sources = await Promise.all(files.map((file) => readFile36(path43.join(root, file), "utf8").catch(() => "")));
   return sources.flatMap(eventDeclarationsIn);
 }
 
@@ -78401,7 +78457,7 @@ import { readFileSync as readFileSync18 } from "fs";
 import { defineCommand as defineCommand151 } from "citty";
 
 // src/commands/flows/value-expression.ts
-import { existsSync as existsSync8, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync17 } from "fs";
 import { join as join4 } from "path";
 var PREFIXES2 = ["field", "tracking", "global", "code"];
 function splitParts(raw) {
@@ -78485,10 +78541,10 @@ function parseValueExpression(raw) {
   return parts.map(parsePart);
 }
 function trackingFieldIds() {
-  const path56 = join4(flowsDir(), "..", "tracking.ts");
-  if (!existsSync8(path56)) return null;
+  const path57 = join4(flowsDir(), "..", "tracking.ts");
+  if (!existsSync9(path57)) return null;
   try {
-    const source = readFileSync17(path56, "utf-8");
+    const source = readFileSync17(path57, "utf-8");
     const block2 = source.match(/TRACKING_FIELD_IDS\s*=\s*\[([\s\S]*?)\]\s*as const/)?.[1];
     if (!block2) return null;
     const ids2 = [...block2.matchAll(/"(tracking\.[a-z0-9_]+)"/g)].map((match) => match[1]);
@@ -79062,13 +79118,13 @@ function specsFromFile(parsed) {
     return `${destField}${type}=${entry?.value ?? ""}`;
   });
 }
-function readSpecFile(path56) {
+function readSpecFile(path57) {
   let raw;
   try {
-    raw = path56 === "-" ? readFileSync18(0, "utf-8") : readFileSync18(path56, "utf-8");
+    raw = path57 === "-" ? readFileSync18(0, "utf-8") : readFileSync18(path57, "utf-8");
   } catch (error) {
     refuse(
-      `Could not read ${path56 === "-" ? "the mapping from stdin" : `"${path56}"`}: ${error instanceof Error ? error.message : String(error)}`
+      `Could not read ${path57 === "-" ? "the mapping from stdin" : `"${path57}"`}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   let parsed;
@@ -79076,7 +79132,7 @@ function readSpecFile(path56) {
     parsed = JSON.parse(raw);
   } catch (error) {
     refuse(
-      `${path56 === "-" ? "stdin" : `"${path56}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      `${path57 === "-" ? "stdin" : `"${path57}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
       'Expected { "map": { "<destField>": "<value>", \u2026 } }'
     );
   }
@@ -79375,21 +79431,21 @@ var ARRAY_FIELDS = [
   "tagIds"
 ];
 var ARRAY_OWNERS = ["", "body"];
-function dropUnsetOptionals(sideEffect, path56) {
+function dropUnsetOptionals(sideEffect, path57) {
   return OPTIONAL_STRINGS.flatMap((key) => {
     if (!(key in sideEffect) || sideEffect[key] !== null && sideEffect[key] !== "") return [];
     delete sideEffect[key];
-    return [{ path: path56, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
+    return [{ path: path57, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
   });
 }
-function fillNulledArrays(target2, prefix, path56) {
+function fillNulledArrays(target2, prefix, path57) {
   return ARRAY_FIELDS.flatMap((key) => {
     if (!(key in target2) || target2[key] !== null) return [];
     target2[key] = [];
-    return [{ path: path56, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
+    return [{ path: path57, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
   });
 }
-function tidyEmailRecipients(sideEffect, path56) {
+function tidyEmailRecipients(sideEffect, path57) {
   if (sideEffect.type !== "email") return [];
   const config = sideEffect.encryptedConfig;
   if (!config || typeof config !== "object" || Array.isArray(config)) return [];
@@ -79400,7 +79456,7 @@ function tidyEmailRecipients(sideEffect, path56) {
   const tidied = to.join(", ");
   if (tidied === raw) return [];
   config.email = tidied;
-  return [{ path: path56, change: "tidied the recipient list's spacing and separators" }];
+  return [{ path: path57, change: "tidied the recipient list's spacing and separators" }];
 }
 function sideEffectsOf(node) {
   if (!Array.isArray(node.sideEffects)) return [];
@@ -79409,13 +79465,13 @@ function sideEffectsOf(node) {
   );
 }
 function normalizeSideEffect(sideEffect, where) {
-  const path56 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
+  const path57 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
   const arrays = ARRAY_OWNERS.flatMap((owner) => {
     const target2 = owner ? sideEffect[owner] : sideEffect;
     if (!target2 || typeof target2 !== "object") return [];
-    return fillNulledArrays(target2, owner ? `${owner}.` : "", path56);
+    return fillNulledArrays(target2, owner ? `${owner}.` : "", path57);
   });
-  return [...dropUnsetOptionals(sideEffect, path56), ...arrays, ...tidyEmailRecipients(sideEffect, path56)];
+  return [...dropUnsetOptionals(sideEffect, path57), ...arrays, ...tidyEmailRecipients(sideEffect, path57)];
 }
 function normalizeFlowTree(tree) {
   const changes = [];
@@ -80807,10 +80863,10 @@ async function stageOps(ops) {
     handleError5(err);
   }
 }
-async function draftAction2(path56, body, chat) {
+async function draftAction2(path57, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const { data, hints: hints2 } = splitHints(await apiPost(path56, { chatId, ...body }));
+    const { data, hints: hints2 } = splitHints(await apiPost(path57, { chatId, ...body }));
     writeJsonEnvelope({ ok: true, data, ...hints2.length > 0 ? { hints: hints2 } : {} });
     return data;
   } catch (err) {
@@ -81065,7 +81121,7 @@ Examples:
 });
 
 // src/commands/ga4/query.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync9, readFileSync as readFileSync21, writeFileSync as writeFileSync4 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, readFileSync as readFileSync21, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve2 } from "path";
 import { defineCommand as defineCommand160 } from "citty";
 
@@ -81139,7 +81195,7 @@ function writeRowsToFile2(filePath, rows, append) {
   const fields = extractFields2(rows);
   const ext = filePath.split(".").pop()?.toLowerCase();
   if (ext === "csv") {
-    if (!append || !existsSync9(filePath)) {
+    if (!append || !existsSync10(filePath)) {
       writeFileSync4(filePath, `${toCsvRow(fields)}
 `, "utf-8");
     }
@@ -81150,12 +81206,12 @@ function writeRowsToFile2(filePath, rows, append) {
     const lines = rows.map((row) => JSON.stringify(row));
     const content = `${lines.join("\n")}
 `;
-    if (append && existsSync9(filePath)) {
+    if (append && existsSync10(filePath)) {
       appendFileSync2(filePath, content, "utf-8");
     } else {
       writeFileSync4(filePath, content, "utf-8");
     }
-  } else if (append && existsSync9(filePath)) {
+  } else if (append && existsSync10(filePath)) {
     const existing = JSON.parse(readFileSync21(filePath, "utf-8"));
     writeFileSync4(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
@@ -82008,7 +82064,7 @@ Full guide: __tooling__/docs/tools/baker/ga4.md`
 import { defineCommand as defineCommand166 } from "citty";
 
 // src/commands/gsc/query.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync10, readFileSync as readFileSync22, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync5 } from "fs";
 import { resolve as resolve3 } from "path";
 import { defineCommand as defineCommand163 } from "citty";
 
@@ -82140,7 +82196,7 @@ function writeRowsToFile3(filePath, rows, append) {
   const fields = extractFields3(rows);
   const ext = filePath.split(".").pop()?.toLowerCase();
   if (ext === "csv") {
-    if (!append || !existsSync10(filePath)) {
+    if (!append || !existsSync11(filePath)) {
       writeFileSync5(filePath, `${toCsvRow(fields)}
 `, "utf-8");
     }
@@ -82150,12 +82206,12 @@ function writeRowsToFile3(filePath, rows, append) {
   } else if (ext === "jsonl") {
     const content = `${rows.map((row) => JSON.stringify(row)).join("\n")}
 `;
-    if (append && existsSync10(filePath)) {
+    if (append && existsSync11(filePath)) {
       appendFileSync3(filePath, content, "utf-8");
     } else {
       writeFileSync5(filePath, content, "utf-8");
     }
-  } else if (append && existsSync10(filePath)) {
+  } else if (append && existsSync11(filePath)) {
     const existing = JSON.parse(readFileSync22(filePath, "utf-8"));
     writeFileSync5(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
@@ -83305,7 +83361,7 @@ function cropSprite(input, region) {
 
 // src/lib/image/io.ts
 import { randomBytes } from "crypto";
-import { glob as fsGlob, readFile as readFile37, rename, stat as stat8, writeFile as writeFile18 } from "fs/promises";
+import { glob as fsGlob, readFile as readFile37, rename, stat as stat8, writeFile as writeFile19 } from "fs/promises";
 import { dirname as dirname2, extname as extname3, join as join5, resolve as resolve4 } from "path";
 var REMOTE_RE = /^https?:\/\//i;
 var GLOB_RE = /[*?[\]{}]/;
@@ -83340,9 +83396,9 @@ async function readImageBuffer(pathOrUrl) {
   }
   return readFile37(pathOrUrl);
 }
-async function isDirectory(path56) {
+async function isDirectory(path57) {
   try {
-    const s = await stat8(path56);
+    const s = await stat8(path57);
     return s.isDirectory();
   } catch {
     return false;
@@ -83361,7 +83417,7 @@ async function atomicWrite(targetPath, data) {
   const absolute = resolve4(targetPath);
   const dir = dirname2(absolute);
   const tmp = join5(dir, `.baker-image-${randomBytes(8).toString("hex")}.tmp`);
-  await writeFile18(tmp, data);
+  await writeFile19(tmp, data);
   await rename(tmp, absolute);
 }
 
@@ -83770,13 +83826,13 @@ function resolveDownloadPath({ baseName, extension, out, outIsDirectory: outIsDi
 }
 function disambiguate(paths) {
   const taken = /* @__PURE__ */ new Set();
-  return paths.map((path56) => {
-    if (!taken.has(path56)) {
-      taken.add(path56);
-      return path56;
+  return paths.map((path57) => {
+    if (!taken.has(path57)) {
+      taken.add(path57);
+      return path57;
     }
-    const ext = extname4(path56);
-    const stem = path56.slice(0, path56.length - ext.length);
+    const ext = extname4(path57);
+    const stem = path57.slice(0, path57.length - ext.length);
     let n = 2;
     while (taken.has(`${stem}-${n}${ext}`)) n += 1;
     const unique = `${stem}-${n}${ext}`;
@@ -83902,10 +83958,10 @@ async function runDownloads(plan) {
   const paths = disambiguate(fetched.map((item) => item.path));
   const downloaded = [];
   for (const [index, item] of fetched.entries()) {
-    const path56 = paths[index] ?? item.path;
+    const path57 = paths[index] ?? item.path;
     try {
-      await atomicWrite(path56, item.buffer);
-      downloaded.push({ input: item.input, output: path56, bytes: item.buffer.length, contentType: item.contentType });
+      await atomicWrite(path57, item.buffer);
+      downloaded.push({ input: item.input, output: path57, bytes: item.buffer.length, contentType: item.contentType });
     } catch (err) {
       failed.push({ input: item.input, error: failureMessage(err, "Write failed") });
     }
@@ -86887,8 +86943,8 @@ Full guide: __tooling__/docs/tools/baker/images.md`
 import { defineCommand as defineCommand207 } from "citty";
 
 // src/commands/landing/critique.ts
-import { readdir as readdir16, readFile as readFile39, stat as stat10 } from "fs/promises";
-import path45 from "path";
+import { readdir as readdir17, readFile as readFile39, stat as stat10 } from "fs/promises";
+import path46 from "path";
 import { defineCommand as defineCommand196 } from "citty";
 
 // src/engine/landing/lib/constants.ts
@@ -88079,27 +88135,27 @@ function describeCounts(findings) {
 }
 
 // src/commands/landing/snapshot.ts
-import { mkdir as mkdir11, rename as rename2, writeFile as writeFile19 } from "fs/promises";
-import path43 from "path";
+import { mkdir as mkdir12, rename as rename2, writeFile as writeFile20 } from "fs/promises";
+import path44 from "path";
 var CRITIC_VERSION = "4";
 function critiqueCacheDir(projectRoot) {
-  return path43.join(projectRoot, ".cache", "landing-critique");
+  return path44.join(projectRoot, ".cache", "landing-critique");
 }
 function snapshotPath(projectRoot, slug) {
-  return path43.join(critiqueCacheDir(projectRoot), `${slug}.json`);
+  return path44.join(critiqueCacheDir(projectRoot), `${slug}.json`);
 }
 async function writeCritiqueSnapshot(projectRoot, snapshot) {
-  await mkdir11(critiqueCacheDir(projectRoot), { recursive: true });
+  await mkdir12(critiqueCacheDir(projectRoot), { recursive: true });
   const dest = snapshotPath(projectRoot, snapshot.slug);
   const tmp = `${dest}.tmp`;
-  await writeFile19(tmp, `${JSON.stringify(snapshot, null, 2)}
+  await writeFile20(tmp, `${JSON.stringify(snapshot, null, 2)}
 `, "utf8");
   await rename2(tmp, dest);
 }
 
 // src/commands/landing/source-version.ts
-import { readdir as readdir15, readFile as readFile38, stat as stat9 } from "fs/promises";
-import path44 from "path";
+import { readdir as readdir16, readFile as readFile38, stat as stat9 } from "fs/promises";
+import path45 from "path";
 var CRITIQUED_ROOTS = ["src/pages/", "src/components/"];
 async function landingSourceRelPaths(root, slug) {
   const files = await landingGraphFiles(root, slug);
@@ -88108,7 +88164,7 @@ async function landingSourceRelPaths(root, slug) {
 async function readLandingSources(root, slug) {
   const rel = await landingSourceRelPaths(root, slug);
   const out = [];
-  for (const r of rel) out.push({ path: r, text: await readFile38(path44.join(root, r), "utf8") });
+  for (const r of rel) out.push({ path: r, text: await readFile38(path45.join(root, r), "utf8") });
   return out;
 }
 async function computeLandingSourceSha(root, slug) {
@@ -88117,7 +88173,7 @@ async function computeLandingSourceSha(root, slug) {
   for (const r of rel) {
     let bytes;
     try {
-      bytes = await readFile38(path44.join(root, r));
+      bytes = await readFile38(path45.join(root, r));
     } catch {
       bytes = Buffer.alloc(0);
     }
@@ -88127,16 +88183,16 @@ async function computeLandingSourceSha(root, slug) {
 }
 async function computeLegacyLandingSourceSha(landingDir) {
   const rel = [];
-  if (await isFile2(path44.join(landingDir, "index.astro"))) rel.push("index.astro");
-  for (const abs of await walkAstro(path44.join(landingDir, "_components"))) {
-    rel.push(path44.relative(landingDir, abs).split(path44.sep).join("/"));
+  if (await isFile2(path45.join(landingDir, "index.astro"))) rel.push("index.astro");
+  for (const abs of await walkAstro(path45.join(landingDir, "_components"))) {
+    rel.push(path45.relative(landingDir, abs).split(path45.sep).join("/"));
   }
   rel.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   const parts = [];
   for (const r of rel) {
     let bytes;
     try {
-      bytes = await readFile38(path44.join(landingDir, r));
+      bytes = await readFile38(path45.join(landingDir, r));
     } catch {
       bytes = Buffer.alloc(0);
     }
@@ -88154,13 +88210,13 @@ async function isFile2(p) {
 async function walkAstro(dir) {
   let entries;
   try {
-    entries = await readdir15(dir, { withFileTypes: true });
+    entries = await readdir16(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const entry of entries) {
-    const abs = path44.join(dir, entry.name);
+    const abs = path45.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkAstro(abs));
     else if (entry.isFile() && entry.name.endsWith(".astro")) out.push(abs);
   }
@@ -88221,7 +88277,7 @@ var critiqueCommand2 = defineCommand196({
           { availableSlugs: await listLandingSlugs(projectRoot) }
         );
       }
-      if (!await isDir2(path45.resolve(projectRoot, "src", "pages", slug))) {
+      if (!await isDir2(path46.resolve(projectRoot, "src", "pages", slug))) {
         fail8("NOT_FOUND", `No landing at src/pages/${slug}/`, {
           availableSlugs: await listLandingSlugs(projectRoot)
         });
@@ -88264,7 +88320,7 @@ async function critiqueOne(projectRoot, slug, brand, competitors) {
   const [sources, compositionSha, sourceSha] = await Promise.all([
     readLandingSources(projectRoot, slug),
     computeLandingSourceSha(projectRoot, slug),
-    computeLegacyLandingSourceSha(path45.resolve(projectRoot, "src", "pages", slug))
+    computeLegacyLandingSourceSha(path46.resolve(projectRoot, "src", "pages", slug))
   ]);
   const report = critiqueLanding({ slug, sources, brand, competitors });
   let snapshotFailed = false;
@@ -88284,18 +88340,18 @@ async function critiqueOne(projectRoot, slug, brand, competitors) {
   return { slug, report, snapshotFailed };
 }
 async function readCompetitorNames(projectRoot) {
-  const dir = path45.join(projectRoot, "src", "content", "competitors");
+  const dir = path46.join(projectRoot, "src", "content", "competitors");
   let entries;
   try {
-    entries = (await readdir16(dir)).filter((f) => f.endsWith(".md"));
+    entries = (await readdir17(dir)).filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
   const names = [];
   for (const entry of entries) {
-    names.push(path45.basename(entry, ".md").replace(/[-_]+/g, " "));
+    names.push(path46.basename(entry, ".md").replace(/[-_]+/g, " "));
     try {
-      const head = (await readFile39(path45.join(dir, entry), "utf8")).slice(0, 2e3);
+      const head = (await readFile39(path46.join(dir, entry), "utf8")).slice(0, 2e3);
       const titled = /^\s*(?:title|name)\s*:\s*["']?([^"'\n]+)["']?\s*$/im.exec(head);
       if (titled?.[1]) names.push(titled[1].trim());
     } catch {
@@ -88305,7 +88361,7 @@ async function readCompetitorNames(projectRoot) {
 }
 async function listLandingSlugs(projectRoot) {
   try {
-    const entries = await readdir16(path45.join(projectRoot, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir17(path46.join(projectRoot, "src", "pages"), { withFileTypes: true });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
   } catch {
     return [];
@@ -88456,8 +88512,8 @@ var addCommand = defineCommand197({
 });
 
 // src/commands/landing/inspiration/code.ts
-import { mkdir as mkdir12, writeFile as writeFile20 } from "fs/promises";
-import path46 from "path";
+import { mkdir as mkdir13, writeFile as writeFile21 } from "fs/promises";
+import path47 from "path";
 import { defineCommand as defineCommand198 } from "citty";
 registerSchema({
   command: "landing.inspiration.code",
@@ -88480,10 +88536,10 @@ var codeCommand = defineCommand198({
     try {
       const id = args8.id;
       const data = await apiGet("/api/landing-inspiration/section-code", { id });
-      const dir = path46.join(process.cwd(), ".baker", "inspiration", id);
-      await mkdir12(dir, { recursive: true });
-      const file = path46.join(dir, "section.html");
-      await writeFile20(file, data.html);
+      const dir = path47.join(process.cwd(), ".baker", "inspiration", id);
+      await mkdir13(dir, { recursive: true });
+      const file = path47.join(dir, "section.html");
+      await writeFile21(file, data.html);
       const hints2 = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
       const fidelity = fidelityHint(data.fidelity);
       if (fidelity) hints2.push(fidelity);
@@ -88492,7 +88548,7 @@ var codeCommand = defineCommand198({
         ok: true,
         data: {
           id,
-          file: path46.relative(process.cwd(), file),
+          file: path47.relative(process.cwd(), file),
           bytes: data.html.length,
           fidelity: data.fidelity,
           reproduction_notes: data.reproductionNotes,
@@ -88923,8 +88979,8 @@ function classifyCaptureFailure(error) {
 }
 
 // src/engine/landing-library/run.ts
-import { mkdir as mkdir13, writeFile as writeFile22 } from "fs/promises";
-import path48 from "path";
+import { mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
+import path49 from "path";
 
 // ../proxy/src/preflight.ts
 import http from "http";
@@ -90339,11 +90395,11 @@ async function renderBundleToPng(browser, html, viewportWidth, options = {}) {
 }
 
 // src/engine/landing-library/report.ts
-import { writeFile as writeFile21 } from "fs/promises";
-import path47 from "path";
+import { writeFile as writeFile22 } from "fs/promises";
+import path48 from "path";
 async function writeCaptureReport(manifest, outDir) {
-  const file = path47.join(outDir, "report.html");
-  await writeFile21(file, renderReport(manifest));
+  const file = path48.join(outDir, "report.html");
+  await writeFile22(file, renderReport(manifest));
   return file;
 }
 function escapeHtml3(value2) {
@@ -90521,32 +90577,32 @@ async function reproducePage(args8) {
   const { browser, page, outDir, pageUrl, livePageShot } = args8;
   const built = await buildSectionBundle(page, "body", pageUrl).catch(() => null);
   if (!built) return { bundle: null, fidelity: null };
-  await writeFile22(path48.join(outDir, "page.html"), built.html);
+  await writeFile23(path49.join(outDir, "page.html"), built.html);
   const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width, {
     wholePage: true,
     timeoutMs: 6e4
   });
   if (!rendered || !livePageShot) return { bundle: "page.html", fidelity: null };
-  await writeFile22(path48.join(outDir, "page-rendered.png"), rendered);
+  await writeFile23(path49.join(outDir, "page-rendered.png"), rendered);
   const { score, note } = await scoreFidelity(livePageShot, rendered);
   return { bundle: "page.html", fidelity: score, ...note ? { fidelityNote: note } : {} };
 }
 async function captureOneSection(args8) {
   const { browser, page, candidate, sectionsDir, outDir, pageUrl, withCode } = args8;
-  const dir = path48.join(sectionsDir, String(candidate.index).padStart(2, "0"));
-  await mkdir13(dir, { recursive: true });
+  const dir = path49.join(sectionsDir, String(candidate.index).padStart(2, "0"));
+  await mkdir14(dir, { recursive: true });
   const desktop = await captureSection(page, candidate);
-  if (desktop) await writeFile22(path48.join(dir, "desktop.png"), desktop);
+  if (desktop) await writeFile23(path49.join(dir, "desktop.png"), desktop);
   const visualHash = desktop ? await perceptualHash(desktop) : null;
   const motion = await collectMotion(page, candidate.selector);
   const built = withCode ? await buildSectionBundle(page, candidate.selector, pageUrl) : null;
   let fidelity = null;
   let fidelityNote;
   if (built) {
-    await writeFile22(path48.join(dir, "section.html"), built.html);
+    await writeFile23(path49.join(dir, "section.html"), built.html);
     const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width);
     if (rendered && desktop) {
-      await writeFile22(path48.join(dir, "section-rendered.png"), rendered);
+      await writeFile23(path49.join(dir, "section-rendered.png"), rendered);
       const result = await scoreFidelity(desktop, rendered);
       fidelity = result.score;
       fidelityNote = result.note;
@@ -90554,9 +90610,9 @@ async function captureOneSection(args8) {
   }
   return {
     ...candidate,
-    desktopShot: desktop ? path48.relative(outDir, path48.join(dir, "desktop.png")) : null,
+    desktopShot: desktop ? path49.relative(outDir, path49.join(dir, "desktop.png")) : null,
     mobileShot: null,
-    bundle: built ? path48.relative(outDir, path48.join(dir, "section.html")) : null,
+    bundle: built ? path49.relative(outDir, path49.join(dir, "section.html")) : null,
     fidelity,
     ...fidelityNote ? { fidelityNote } : {},
     ...built ? { cssStats: built.stats } : {},
@@ -90575,9 +90631,9 @@ async function captureMobileShots(args8) {
     for (const section of sections) {
       const shot = await captureSectionOnMobile(mobile.page, section);
       if (!shot) continue;
-      const file = path48.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
-      await writeFile22(file, shot);
-      section.mobileShot = path48.relative(outDir, file);
+      const file = path49.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
+      await writeFile23(file, shot);
+      section.mobileShot = path49.relative(outDir, file);
     }
   } finally {
     await mobile.context.close();
@@ -90592,10 +90648,10 @@ async function captureMotionTakes(args8) {
   const filmOne = async (section) => {
     const take = await captureMotionTake(browser, pageUrl, section.selector).catch(() => null);
     if (!take) return;
-    const dir = path48.join(sectionsDir, String(section.index).padStart(2, "0"));
-    const file = path48.join(dir, "motion-filmstrip.png");
-    await writeFile22(file, take.filmstrip);
-    section.motionFilmstrip = path48.relative(outDir, file);
+    const dir = path49.join(sectionsDir, String(section.index).padStart(2, "0"));
+    const file = path49.join(dir, "motion-filmstrip.png");
+    await writeFile23(file, take.filmstrip);
+    section.motionFilmstrip = path49.relative(outDir, file);
     log(`  [${section.index}] ${section.motion.summary}`);
   };
   const queue = [...moving];
@@ -90652,7 +90708,7 @@ async function captureAlternateViews(args8) {
 async function reproduceWholePage(args8) {
   const { browser, page, outDir, pageUrl, withCode, log } = args8;
   const fullPage = await page.screenshot({ type: "png", fullPage: true }).catch(() => null);
-  if (fullPage) await writeFile22(path48.join(outDir, "full-page.png"), fullPage);
+  if (fullPage) await writeFile23(path49.join(outDir, "full-page.png"), fullPage);
   if (!withCode) return { bundle: null, fidelity: null };
   const reproduction = await reproducePage({ browser, page, outDir, pageUrl, livePageShot: fullPage });
   log(`page reproduction: ${reproduction.fidelity === null ? "unavailable" : reproduction.fidelity.toFixed(2)}`);
@@ -90723,7 +90779,7 @@ async function openViaLadder(args8) {
 async function scrapeLanding(options) {
   const timeoutMs = options.timeoutMs ?? 45e3;
   const log = options.onProgress ?? (() => void 0);
-  const sectionsDir = path48.join(options.outDir, "sections");
+  const sectionsDir = path49.join(options.outDir, "sections");
   const nonPublic = refuseNonPublicUrl(options.url);
   if (nonPublic) {
     throw new BlockedPageError({
@@ -90743,7 +90799,7 @@ async function scrapeLanding(options) {
   const withMotion = options.motion !== false && !escalated;
   const renderBrowser = options.code === false ? null : await launchBrowser();
   try {
-    await mkdir13(sectionsDir, { recursive: true });
+    await mkdir14(sectionsDir, { recursive: true });
     const sections = await captureSections({
       browser: renderBrowser ?? browser,
       page,
@@ -90785,7 +90841,7 @@ async function scrapeLanding(options) {
       security: prepared.security,
       captureTier: tier
     };
-    await writeFile22(path48.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile23(path49.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
     if (options.report !== false) {
       const reportPath = await writeCaptureReport(manifest, options.outDir);
@@ -90799,29 +90855,29 @@ async function scrapeLanding(options) {
 }
 
 // src/commands/landing/inspiration/captureOut.ts
-import { existsSync as existsSync11 } from "fs";
-import path49 from "path";
+import { existsSync as existsSync12 } from "fs";
+import path50 from "path";
 var SCRATCH_DIR = ".baker";
 function isWithin(parent, target2) {
-  const relative = path49.relative(parent, target2);
-  return relative === "" || !relative.startsWith("..") && !path49.isAbsolute(relative);
+  const relative = path50.relative(parent, target2);
+  return relative === "" || !relative.startsWith("..") && !path50.isAbsolute(relative);
 }
 function findRepoRoot(from) {
-  let dir = path49.resolve(from);
+  let dir = path50.resolve(from);
   for (; ; ) {
-    if (existsSync11(path49.join(dir, ".git"))) return dir;
-    const parent = path49.dirname(dir);
+    if (existsSync12(path50.join(dir, ".git"))) return dir;
+    const parent = path50.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function checkCaptureOut(out, options) {
   const { cwd, repoRoot } = options;
-  const resolved = path49.resolve(cwd, out);
+  const resolved = path50.resolve(cwd, out);
   if (repoRoot === null || !isWithin(repoRoot, resolved)) return { ok: true };
-  const scratch = path49.join(repoRoot, SCRATCH_DIR);
+  const scratch = path50.join(repoRoot, SCRATCH_DIR);
   if (isWithin(scratch, resolved)) return { ok: true };
-  const suggestion = path49.posix.join(SCRATCH_DIR, "teardowns", path49.basename(resolved) || "capture");
+  const suggestion = path50.posix.join(SCRATCH_DIR, "teardowns", path50.basename(resolved) || "capture");
   return {
     ok: false,
     error: {
@@ -90995,12 +91051,12 @@ var scrapeCommand = defineCommand201({
 });
 
 // src/commands/landing/inspiration/search.ts
-import path51 from "path";
+import path52 from "path";
 import { defineCommand as defineCommand202 } from "citty";
 
 // src/commands/landing/inspiration/shot.ts
-import { mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
-import path50 from "path";
+import { mkdir as mkdir15, writeFile as writeFile24 } from "fs/promises";
+import path51 from "path";
 import sharp8 from "sharp";
 var READABLE_SHOT = {
   maxWidth: 1440,
@@ -91026,9 +91082,9 @@ async function downloadReadableShot(url, file) {
     const response = await fetch(url);
     if (!response.ok) return null;
     const shot = await toReadableShot(Buffer.from(await response.arrayBuffer()));
-    await mkdir14(path50.dirname(file), { recursive: true });
-    await writeFile23(file, shot);
-    return path50.relative(process.cwd(), file);
+    await mkdir15(path51.dirname(file), { recursive: true });
+    await writeFile24(file, shot);
+    return path51.relative(process.cwd(), file);
   } catch {
     return null;
   }
@@ -91120,13 +91176,13 @@ function buildSearchBody(args8) {
   return body;
 }
 async function downloadShots(results) {
-  const dir = path51.join(process.cwd(), ".baker", "inspiration");
+  const dir = path52.join(process.cwd(), ".baker", "inspiration");
   const saved = /* @__PURE__ */ new Map();
   await Promise.all(
     results.map(async (result) => {
       const file = await downloadReadableShot(
         result.desktopShotUrl,
-        path51.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
+        path52.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
       );
       if (file) saved.set(result.id, file);
     })
@@ -91354,7 +91410,7 @@ var sequencesCommand = defineCommand203({
 });
 
 // src/commands/landing/inspiration/view.ts
-import path52 from "path";
+import path53 from "path";
 import { defineCommand as defineCommand204 } from "citty";
 registerSchema({
   command: "landing.inspiration.view",
@@ -91387,12 +91443,12 @@ var viewCommand2 = defineCommand204({
       const id = args8.id;
       const data = await apiGet("/api/landing-inspiration/section", { id });
       const section = data.section;
-      const dir = path52.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path53.join(process.cwd(), ".baker", "inspiration", id);
       const ext = READABLE_SHOT.extension;
       const [desktop, mobile, filmstrip] = await Promise.all([
-        downloadReadableShot(section.desktopShotUrl, path52.join(dir, `desktop.${ext}`)),
-        downloadReadableShot(section.mobileShotUrl, path52.join(dir, `mobile.${ext}`)),
-        downloadReadableShot(section.motionFilmstripUrl, path52.join(dir, `motion-filmstrip.${ext}`))
+        downloadReadableShot(section.desktopShotUrl, path53.join(dir, `desktop.${ext}`)),
+        downloadReadableShot(section.mobileShotUrl, path53.join(dir, `mobile.${ext}`)),
+        downloadReadableShot(section.motionFilmstripUrl, path53.join(dir, `motion-filmstrip.${ext}`))
       ]);
       const full = args8.full;
       const hints2 = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
@@ -91498,8 +91554,8 @@ Full guide: __tooling__/docs/tools/baker/landing.md`
 
 // src/commands/landing/variant.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir15, readdir as readdir17, readFile as readFile40, stat as stat11, writeFile as writeFile24 } from "fs/promises";
-import path53 from "path";
+import { mkdir as mkdir16, readdir as readdir18, readFile as readFile40, stat as stat11, writeFile as writeFile25 } from "fs/promises";
+import path54 from "path";
 import { defineCommand as defineCommand206 } from "citty";
 registerSchema({
   command: "landing.variant",
@@ -91535,7 +91591,7 @@ async function readInternalId(definitionPath) {
 async function archivedVariantNumbers(root, internalId) {
   if (!internalId) return [];
   try {
-    const entries = await readdir17(path53.resolve(root, "src/_variants", internalId), { withFileTypes: true });
+    const entries = await readdir18(path54.resolve(root, "src/_variants", internalId), { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => Number(entry.name)).filter((n) => Number.isInteger(n) && n > 0);
   } catch {
     return [];
@@ -91565,7 +91621,7 @@ async function exists2(p) {
 }
 async function listLandingSlugs2(root) {
   try {
-    const entries = await readdir17(path53.resolve(root, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir18(path54.resolve(root, "src", "pages"), { withFileTypes: true });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
   } catch {
     return [];
@@ -91574,14 +91630,14 @@ async function listLandingSlugs2(root) {
 async function listComponents(componentsDir, prefix = "") {
   let entries;
   try {
-    entries = await readdir17(componentsDir, { withFileTypes: true });
+    entries = await readdir18(componentsDir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const entry of entries) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) out.push(...await listComponents(path53.join(componentsDir, entry.name), rel));
+    if (entry.isDirectory()) out.push(...await listComponents(path54.join(componentsDir, entry.name), rel));
     else if (entry.name.endsWith(".astro")) out.push(rel);
   }
   return out.sort();
@@ -91648,16 +91704,16 @@ async function resolveTargets(projectRoot, opts) {
       `"${controlSlug}" is already a variant of "${variantOfSlug(controlSlug)}". Make the next variant of the page itself: \`baker landing variant ${variantOfSlug(controlSlug)}\`.`
     );
   }
-  const controlDir = path53.resolve(projectRoot, "src", "pages", controlSlug);
+  const controlDir = path54.resolve(projectRoot, "src", "pages", controlSlug);
   if (!await isDir3(controlDir)) {
     fail9("NOT_FOUND", `No page at src/pages/${controlSlug}/`, {
       availableSlugs: await listLandingSlugs2(projectRoot)
     });
   }
-  if (!await exists2(path53.join(controlDir, "index.astro"))) {
+  if (!await exists2(path54.join(controlDir, "index.astro"))) {
     fail9("NOT_FOUND", `src/pages/${controlSlug}/index.astro is missing, so there is no page to make a variant of.`);
   }
-  const internalId = await readInternalId(path53.join(controlDir, "_definition.md"));
+  const internalId = await readInternalId(path54.join(controlDir, "_definition.md"));
   const variantSlugValue = variantSlug(
     controlSlug,
     nextVariantNumber(
@@ -91666,8 +91722,8 @@ async function resolveTargets(projectRoot, opts) {
       await archivedVariantNumbers(projectRoot, internalId)
     )
   );
-  const variantDir = path53.resolve(projectRoot, "src", "pages", variantSlugValue);
-  const available = await listComponents(path53.join(controlDir, "_components"));
+  const variantDir = path54.resolve(projectRoot, "src", "pages", variantSlugValue);
+  const available = await listComponents(path54.join(controlDir, "_components"));
   const forks = [];
   for (const name of parseForks(opts.fork, opts.rawArgs)) {
     const resolved = resolveForkName(name, available);
@@ -91683,26 +91739,26 @@ async function resolveTargets(projectRoot, opts) {
 }
 async function writeVariant(opts) {
   const { controlDir, variantDir, controlSlug, variantSlug: variantSlug2, forks } = opts;
-  const forkedTargets = new Set(forks.map((f) => path53.join(controlDir, "_components", f)));
+  const forkedTargets = new Set(forks.map((f) => path54.join(controlDir, "_components", f)));
   const written = [];
-  const indexText = await readFile40(path53.join(controlDir, "index.astro"), "utf8");
-  await mkdir15(variantDir, { recursive: true });
-  await writeFile24(
-    path53.join(variantDir, "index.astro"),
+  const indexText = await readFile40(path54.join(controlDir, "index.astro"), "utf8");
+  await mkdir16(variantDir, { recursive: true });
+  await writeFile25(
+    path54.join(variantDir, "index.astro"),
     repointFile(indexText, { fromDir: controlDir, toDir: variantDir, controlDir, variantDir, forkedTargets }),
     "utf8"
   );
   written.push(`src/pages/${variantSlug2}/index.astro`);
   for (const fork of forks) {
-    const fromFile = path53.join(controlDir, "_components", fork);
-    const toFile = path53.join(variantDir, "_components", fork);
+    const fromFile = path54.join(controlDir, "_components", fork);
+    const toFile = path54.join(variantDir, "_components", fork);
     const text2 = await readFile40(fromFile, "utf8");
-    await mkdir15(path53.dirname(toFile), { recursive: true });
-    await writeFile24(
+    await mkdir16(path54.dirname(toFile), { recursive: true });
+    await writeFile25(
       toFile,
       repointFile(text2, {
-        fromDir: path53.dirname(fromFile),
-        toDir: path53.dirname(toFile),
+        fromDir: path54.dirname(fromFile),
+        toDir: path54.dirname(toFile),
         controlDir,
         variantDir,
         forkedTargets
@@ -91711,7 +91767,7 @@ async function writeVariant(opts) {
     );
     written.push(`src/pages/${variantSlug2}/_components/${fork}`);
   }
-  const controlDefinitionPath = path53.join(controlDir, "_definition.md");
+  const controlDefinitionPath = path54.join(controlDir, "_definition.md");
   if (await exists2(controlDefinitionPath)) {
     const definition = buildVariantDefinition(await readFile40(controlDefinitionPath, "utf8"), {
       internalId: randomUUID3().replace(/-/g, "").slice(0, 8),
@@ -91721,11 +91777,11 @@ async function writeVariant(opts) {
       ...opts.because ? { because: opts.because } : {},
       ...opts.change ? { change: opts.change } : {}
     });
-    await writeFile24(path53.join(variantDir, "_definition.md"), definition, "utf8");
+    await writeFile25(path54.join(variantDir, "_definition.md"), definition, "utf8");
     written.push(`src/pages/${variantSlug2}/_definition.md`);
   }
-  await mkdir15(path53.join(variantDir, "_images"), { recursive: true });
-  await writeFile24(path53.join(variantDir, "_images", ".gitkeep"), "", "utf8");
+  await mkdir16(path54.join(variantDir, "_images"), { recursive: true });
+  await writeFile25(path54.join(variantDir, "_images", ".gitkeep"), "", "utf8");
   return written;
 }
 var variantCommand = defineCommand206({
@@ -94077,7 +94133,7 @@ Full guide: __tooling__/docs/tools/baker/scheduled-agents.md`
 
 // src/commands/scheduled-agents/templates.ts
 import { readFile as readFile41 } from "fs/promises";
-import path54 from "path";
+import path55 from "path";
 import { defineCommand as defineCommand228 } from "citty";
 registerSchema({
   command: "scheduled-agents.templates",
@@ -94184,7 +94240,7 @@ Full guide: __tooling__/docs/tools/baker/scheduled-agents.md`
       }
       if (save.length > 0) {
         const briefFile = flag("brief-file");
-        const brief2 = briefFile.length > 0 ? await readFile41(path54.resolve(briefFile), "utf8") : flag("brief");
+        const brief2 = briefFile.length > 0 ? await readFile41(path55.resolve(briefFile), "utf8") : flag("brief");
         if (brief2.trim().length === 0) {
           failValidation4("--brief-file (preferred) or --brief is required: the brief is the recipe.");
         }
@@ -94824,7 +94880,7 @@ function parseImageRefs(spec) {
 }
 var defaultDeps = {
   ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
-  upload: (path56) => uploadLocalImage({ file: path56, contentType: detectImageContentType(path56), source: "uploaded" })
+  upload: (path57) => uploadLocalImage({ file: path57, contentType: detectImageContentType(path57), source: "uploaded" })
 };
 async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   const refs = parseImageRefs(spec);
@@ -94844,10 +94900,10 @@ async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   }
   return { imageIds, added };
 }
-function uploadFailure(path56) {
+function uploadFailure(path57) {
   return (error) => {
     if (error instanceof ApiError) throw error;
-    throw new ApiError("VALIDATION_ERROR", `Could not read "${path56}" as an image.`);
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path57}" as an image.`);
   };
 }
 
@@ -95947,10 +96003,10 @@ async function stageOp4(op) {
     handleError8(err);
   }
 }
-async function draftAction3(path56, body, chat) {
+async function draftAction3(path57, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const { data, hints: hints2 } = splitHints(await apiPost(path56, { chatId, ...body }));
+    const { data, hints: hints2 } = splitHints(await apiPost(path57, { chatId, ...body }));
     writeJsonEnvelope({ ok: true, data, ...hints2.length > 0 ? { hints: hints2 } : {} });
     return data;
   } catch (err) {
@@ -97181,7 +97237,7 @@ var groupCommand2 = defineCommand255({
 // src/commands/videos/ingest.ts
 import { mkdtemp as mkdtemp3, rm as rm10, stat as stat12 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import path55 from "path";
+import path56 from "path";
 import { defineCommand as defineCommand256 } from "citty";
 
 // src/lib/streamUpload.ts
@@ -97532,7 +97588,7 @@ function ingestUrl(args8) {
 }
 async function downloadThenIngest(args8, country) {
   const vimeoCookie = captureVimeoCookie();
-  const workDir = await mkdtemp3(path55.join(tmpdir4(), "videos-ingest-"));
+  const workDir = await mkdtemp3(path56.join(tmpdir4(), "videos-ingest-"));
   try {
     const probe = await probeYtDlp({ url: args8.url, country, vimeoCookie, cookieDir: workDir });
     if (isAudioOnly(probe.info)) {