@koda-sl/baker-cli 0.248.0 → 0.249.0-dev.94b6a6a7e

package/dist/cli.js

@@ -58,7 +58,7 @@ import {
   ulid,
   validateCanvasDeep,
   ytDlpBlockSignal
-} from "./chunk-SJPRTSGY.js";
+} from "./chunk-HBDGUVUH.js";
 import {
   csvOrJson,
   daysAgoIso,
@@ -108,7 +108,7 @@ import {
 } from "./chunk-DZUVUGEP.js";
 
 // src/cli.ts
-import { defineCommand as defineCommand227, runMain } from "citty";
+import { defineCommand as defineCommand229, runMain } from "citty";
 
 // src/cache-flag.ts
 var NO_CACHE_ARG = {
@@ -3936,10 +3936,35 @@ var capabilitySurfaceReportSchema = z9.object({
   /** Where to look next: `baker ads google`, `baker ga4`, … */
   commands: z9.string()
 });
+var capabilityToolSchema = z9.object({
+  /** `microsoft_clarity`, `hubspot`, or the name the user gave a custom server. */
+  key: z9.string(),
+  label: z9.string(),
+  /** `mcp` — tools in the agent's own list. `platform` — signed in, read through the CLI. */
+  kind: z9.enum(["mcp", "platform"]),
+  /** How to actually reach it, in one phrase the agent can act on. */
+  reach: z9.string(),
+  /**
+   * Whether it can be used right now.
+   *
+   * A connection that exists and is expired is worse than one that is absent:
+   * it reads as available and fails at the moment it is needed, which on an
+   * unattended run is a report with a hole in it and no explanation.
+   */
+  ready: z9.boolean(),
+  /** Why it is not ready, or what it is for. Absent when neither needs saying. */
+  note: z9.string().optional()
+});
 var capabilitiesResponseSchema = z9.object({
   ok: z9.literal(true),
   data: z9.object({
-    surfaces: z9.array(capabilitySurfaceReportSchema)
+    surfaces: z9.array(capabilitySurfaceReportSchema),
+    /**
+     * Everything else this company can reach. Shared connections only —
+     * a teammate's private per-user connection belongs to whoever started the
+     * session and is visible in the agent's own tool list, not here.
+     */
+    tools: z9.array(capabilityToolSchema)
   })
 });
 
@@ -3986,6 +4011,8 @@ var chatChangeTypeSchema = z10.enum([
   // what the edge captures and one held until Publish would not measure the
   // campaign it was written for.
   "analytics-mapping",
+  // An A/B test between a landing and its alternative. Staged, not immediate.
+  "experiment",
   "briefs"
 ]);
 var chatChangeActionSchema = z10.enum(["created", "updated", "deleted"]);
@@ -9780,11 +9807,11 @@ function rawTextEntries(value) {
   const values = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
   return values.filter((v) => typeof v === "string").flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
 }
-function rawFileEntries(path38) {
-  if (typeof path38 !== "string" || path38.length === 0) {
+function rawFileEntries(path41) {
+  if (typeof path41 !== "string" || path41.length === 0) {
     return [];
   }
-  return readFileSync2(path38, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return readFileSync2(path41, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function keywordEntries(args) {
   const defaultMatch = typeof args["match-type"] === "string" ? args["match-type"].toUpperCase() : void 0;
@@ -9807,19 +9834,19 @@ function keywordEntries(args) {
   }
   return entries;
 }
-function loadJsonFileArg(path38) {
-  if (typeof path38 !== "string" || path38.length === 0) {
+function loadJsonFileArg(path41) {
+  if (typeof path41 !== "string" || path41.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync2(path38, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path41, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation(`${path38} must contain a JSON object`);
+      failWriteValidation(`${path41} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation(`${path38} is not valid JSON: ${err.message}`);
+      failWriteValidation(`${path41} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -9949,10 +9976,10 @@ async function stageUpdate(kind, customerId, target, payload, hints) {
 async function stageTarget(kind, customerId, target, hints) {
   await stageGoogleOp({ kind, customerId, target }, hints);
 }
-async function draftAction(path38, body, chat) {
+async function draftAction(path41, body, chat) {
   try {
     const chatId = resolveChatId(chat);
-    const response = await apiPost(path38, { chatId, ...body });
+    const response = await apiPost(path41, { chatId, ...body });
     writeJsonEnvelope(response);
   } catch (err) {
     handleGoogleError(err);
@@ -15166,19 +15193,19 @@ function failWriteValidation2(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg2(path38) {
-  if (typeof path38 !== "string" || path38.length === 0) {
+function loadJsonFileArg2(path41) {
+  if (typeof path41 !== "string" || path41.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync4(path38, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path41, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation2(`${path38} must contain a JSON object`);
+      failWriteValidation2(`${path41} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation2(`${path38} is not valid JSON: ${err.message}`);
+      failWriteValidation2(`${path41} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -15263,15 +15290,15 @@ function parseLocaleFlag(value) {
   }
   return { language: match[1], country: match[2].toUpperCase() };
 }
-function loadTargetingFileArg(path38) {
-  if (typeof path38 !== "string" || path38.length === 0) {
+function loadTargetingFileArg(path41) {
+  if (typeof path41 !== "string" || path41.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg2(path38);
+  const parsed = loadJsonFileArg2(path41);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
     failWriteValidation2(
-      `${path38} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+      `${path41} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
   return criteria;
@@ -15306,14 +15333,14 @@ function parseCsvLine(line) {
   cells.push(current);
   return cells.map((cell2) => cell2.trim());
 }
-function parseListFileArg(path38, maxRows) {
-  if (typeof path38 !== "string" || path38.length === 0) {
+function parseListFileArg(path41, maxRows) {
+  if (typeof path41 !== "string" || path41.length === 0) {
     return void 0;
   }
-  const raw = readFileSync4(path38, "utf8");
+  const raw = readFileSync4(path41, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation2(`${path38} needs a header row and at least one data row`);
+    failWriteValidation2(`${path41} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -15332,7 +15359,7 @@ function parseListFileArg(path38, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation2(`${path38} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation2(`${path41} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -15428,11 +15455,11 @@ function readPositionals(args) {
 function splitIdList(raw) {
   return raw.split(",").map((id) => id.trim()).filter(Boolean);
 }
-function idsFileEntries(path38) {
-  if (typeof path38 !== "string" || path38.length === 0) {
+function idsFileEntries(path41) {
+  if (typeof path41 !== "string" || path41.length === 0) {
     return [];
   }
-  return readFileSync4(path38, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+  return readFileSync4(path41, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
 }
 function requireTargets(args, entity) {
   const positionals = readPositionals(args);
@@ -18053,9 +18080,9 @@ function compactRow(row) {
     ...destination.postUrn ? { postUrn: destination.postUrn } : {}
   };
 }
-function readPath(row, path38) {
+function readPath(row, path41) {
   let current = row;
-  for (const segment of path38.split(".")) {
+  for (const segment of path41.split(".")) {
     const record = asRecord2(current);
     if (!record) return void 0;
     current = record[segment];
@@ -18065,10 +18092,10 @@ function readPath(row, path38) {
 function projectFields(rows, paths) {
   return rows.map((row) => {
     const projected = {};
-    for (const path38 of paths) {
-      const value = readPath(row, path38);
+    for (const path41 of paths) {
+      const value = readPath(row, path41);
       if (value !== void 0) {
-        projected[path38] = value;
+        projected[path41] = value;
       }
     }
     return projected;
@@ -19368,11 +19395,11 @@ var updateStatusSchema = z25.enum(UPDATE_STATUSES);
 function currencyMinimums2(currencyCode) {
   return CURRENCY_MINIMUMS2[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM2;
 }
-function validateDailyBudgetFloor(money, ctx, path38) {
+function validateDailyBudgetFloor(money, ctx, path41) {
   if (money?.currencyCode) {
     const min = currencyMinimums2(money.currencyCode).dailyBudgetMin;
     if (Number(money.amount) < min) {
-      ctx.addIssue({ code: "custom", path: path38, message: `below the ${min} ${money.currencyCode} daily minimum` });
+      ctx.addIssue({ code: "custom", path: path41, message: `below the ${min} ${money.currencyCode} daily minimum` });
     }
   }
 }
@@ -20041,19 +20068,19 @@ function failWriteValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg3(path38) {
-  if (typeof path38 !== "string" || path38.length === 0) {
+function loadJsonFileArg3(path41) {
+  if (typeof path41 !== "string" || path41.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path38, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path41, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation3(`${path38} must contain a JSON object`);
+      failWriteValidation3(`${path41} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation3(`${path38} is not valid JSON: ${err.message}`);
+      failWriteValidation3(`${path41} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -24654,11 +24681,11 @@ function unwrap(response) {
   }
   return response.data;
 }
-async function readAvatars(path38, params) {
-  return unwrap(await apiGet(path38, params));
+async function readAvatars(path41, params) {
+  return unwrap(await apiGet(path41, params));
 }
-async function writeAvatars(path38, body) {
-  return unwrap(await apiPost(path38, body));
+async function writeAvatars(path41, body) {
+  return unwrap(await apiPost(path41, body));
 }
 
 // src/commands/avatars/create.ts
@@ -25492,12 +25519,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: path38, source } of sources) {
-    const dir = posix.dirname(path38);
+  for (const { path: path41, source } of sources) {
+    const dir = posix.dirname(path41);
     for (const face of declaredFontFaces(source)) {
       if (!wanted.has(face.family)) continue;
       const perFile = byFamily.get(face.family) ?? /* @__PURE__ */ new Map();
-      perFile.set(path38, [...perFile.get(path38) ?? [], rebaseFontFaceSrc(face.block, dir)]);
+      perFile.set(path41, [...perFile.get(path41) ?? [], rebaseFontFaceSrc(face.block, dir)]);
       byFamily.set(face.family, perFile);
     }
   }
@@ -26521,10 +26548,10 @@ import { defineCommand as defineCommand100 } from "citty";
 import { existsSync as existsSync3, realpathSync } from "fs";
 import { writeFile as writeFile2 } from "fs/promises";
 import path5 from "path";
-function findWorkspaceRoot(startDir, exists = existsSync3, maxDepth = 12) {
+function findWorkspaceRoot(startDir, exists2 = existsSync3, maxDepth = 12) {
   let dir = path5.resolve(startDir);
   for (let i = 0; i < maxDepth; i++) {
-    if (exists(path5.join(dir, "package.json"))) return dir;
+    if (exists2(path5.join(dir, "package.json"))) return dir;
     const parent = path5.dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -30471,10 +30498,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: readdir10 } = await import("fs/promises");
+  const { readdir: readdir11 } = await import("fs/promises");
   let entries;
   try {
-    entries = await readdir10(outputsDir);
+    entries = await readdir11(outputsDir);
   } catch {
     return;
   }
@@ -32266,12 +32293,12 @@ async function detectSceneCutsPySceneDetect(filePath, opts = {}) {
 // src/commands/canvas/composition-path.ts
 import { existsSync as existsSync4 } from "fs";
 import path21 from "path";
-function resolveShippedCanvasDir(name, startDir, exists = existsSync4, maxDepth = 8) {
+function resolveShippedCanvasDir(name, startDir, exists2 = existsSync4, maxDepth = 8) {
   const rel = path21.join("canvas", name);
   let dir = startDir;
   for (let i = 0; i < maxDepth; i++) {
     const candidate = path21.join(dir, rel);
-    if (exists(path21.join(candidate, "meta.json"))) return candidate;
+    if (exists2(path21.join(candidate, "meta.json"))) return candidate;
     const parent = path21.dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -33097,7 +33124,7 @@ registerSchema({
     }
   }
 });
-function capabilityHints(surfaces) {
+function capabilityHints(surfaces, tools = []) {
   const hints = [];
   const immediate = surfaces.filter((surface) => surface.writeMode === "applies-at-publish");
   if (immediate.length > 0) {
@@ -33120,6 +33147,18 @@ function capabilityHints(surfaces) {
       "Naming one surface (`baker capabilities google-ads`) adds `ops` \u2014 the exact fields and accepted values of every change there. Read that instead of guessing a field name."
     );
   }
+  const usable = tools.filter((tool) => tool.ready);
+  if (usable.length > 0) {
+    hints.push(
+      `ALSO AVAILABLE, and not on any surface above: ${usable.map((tool) => tool.label).join(", ")}. These answer WHY a page behaves as it does, which no surface here can. See \`tools[].reach\` for how to call each one.`
+    );
+  }
+  const broken = tools.filter((tool) => !tool.ready);
+  if (broken.length > 0) {
+    hints.push(
+      `CONNECTED BUT UNUSABLE: ${broken.map((tool) => `${tool.label} \u2014 ${tool.note ?? "not reachable"}`).join(" ")} Tell the user rather than planning around it silently.`
+    );
+  }
   return hints;
 }
 var runCapabilities = defineCommand108({
@@ -33129,6 +33168,8 @@ var runCapabilities = defineCommand108({
 
 Reports, per surface: what is connected and with what access, what a write there does when it lands, the entities that can be changed, and \u2014 the part nothing else tells you \u2014 what cannot be changed and why.
 
+Also returns \`tools\`: everything else this company can reach that is not one of those surfaces \u2014 Microsoft Clarity and any other MCP toolkit, custom servers, HubSpot. This is the one call that answers "what do I actually have".
+
 Examples:
   baker capabilities
   baker capabilities google-ads
@@ -33164,7 +33205,7 @@ Full guide: __tooling__/docs/tools/baker/capabilities.md`
         body.full = true;
       }
       const response = await apiPost("/api/capabilities", body);
-      const hints = capabilityHints(response.data.surfaces);
+      const hints = capabilityHints(response.data.surfaces, response.data.tools);
       writeJson({
         ...response,
         meta: { count: response.data.surfaces.length },
@@ -33634,12 +33675,793 @@ Full guide: __tooling__/docs/tools/baker/creatives.md`
   }
 });
 
+// src/commands/experiment/index.ts
+import { defineCommand as defineCommand112 } from "citty";
+
+// src/commands/landing/import-graph.ts
+import { readdir as readdir8, readFile as readFile20, stat as stat4 } from "fs/promises";
+import path26 from "path";
+var SOURCE_EXT = /\.(astro|ts|tsx|js|jsx|mjs|cjs|vue|svelte)$/;
+var RESOLVE_CANDIDATES = [
+  "",
+  ".astro",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  "/index.astro",
+  "/index.ts",
+  "/index.js"
+];
+var IMPORT_RE = /(?<![A-Za-z0-9_$])(?:import|export)\s*(?:[\s\S]*?\bfrom\s*)?["']([^"']+)["']/g;
+var DYNAMIC_IMPORT_RE = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+async function isFile(p) {
+  try {
+    return (await stat4(p)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function walkFiles(dir) {
+  let entries;
+  try {
+    entries = await readdir8(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    const full = path26.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === "dist") continue;
+      out.push(...await walkFiles(full));
+    } else if (SOURCE_EXT.test(entry.name)) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+async function resolveSpecifier(specifier, fromFile, root) {
+  const bare = specifier.split("?")[0] ?? "";
+  if (bare.includes("*")) return null;
+  let base;
+  if (bare.startsWith("/")) base = path26.join(root, bare.slice(1));
+  else if (bare.startsWith(".")) base = path26.resolve(path26.dirname(fromFile), bare);
+  else return null;
+  for (const suffix of RESOLVE_CANDIDATES) {
+    const candidate = base + suffix;
+    if (SOURCE_EXT.test(candidate) && await isFile(candidate)) return candidate;
+  }
+  return null;
+}
+async function importedFiles(text2, file, root) {
+  const out = [];
+  for (const re2 of [IMPORT_RE, DYNAMIC_IMPORT_RE]) {
+    for (const match of text2.matchAll(re2)) {
+      const spec = match[1];
+      if (spec === void 0) continue;
+      const target = await resolveSpecifier(spec, file, root);
+      if (target !== null) out.push(target);
+    }
+  }
+  return out;
+}
+async function landingGraphFiles(root, slug) {
+  const seen = /* @__PURE__ */ new Set();
+  const queue = await walkFiles(path26.join(root, "src/pages", slug));
+  while (queue.length > 0) {
+    const file = queue.pop();
+    if (file === void 0 || seen.has(file)) continue;
+    let text2;
+    try {
+      text2 = await readFile20(file, "utf8");
+    } catch {
+      continue;
+    }
+    seen.add(file);
+    for (const target of await importedFiles(text2, file, root)) {
+      if (!seen.has(target)) queue.push(target);
+    }
+  }
+  return new Set([...seen].map((abs) => path26.relative(root, abs).split(path26.sep).join("/")));
+}
+
+// src/commands/experiment/composition.ts
+function sectionsUnder(files, slug) {
+  const prefix = `src/pages/${slug}/`;
+  return files.filter((file) => file.startsWith(prefix) && !file.slice(prefix.length).startsWith("index.")).sort();
+}
+function compositionOf(controlSlug, variantSlug, variantGraph) {
+  return {
+    forked: sectionsUnder(variantGraph, variantSlug),
+    shared: sectionsUnder(variantGraph, controlSlug)
+  };
+}
+async function readComposition(root, controlSlug, variantSlug) {
+  try {
+    const graph = await landingGraphFiles(root, variantSlug);
+    return compositionOf(controlSlug, variantSlug, [...graph]);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/experiment/goal.ts
+function parseEventGoal(argument) {
+  const [name, filter] = argument.split("/");
+  if (!name) return { error: "Name the event: --goal event:request_demo" };
+  if (!filter) return { kind: "custom_event", name };
+  const separator = filter.indexOf("=");
+  if (separator === -1) {
+    return { error: `Write the property as key=value: --goal event:${name}/section=pricing` };
+  }
+  return { kind: "custom_event", name, property: filter.slice(0, separator), value: filter.slice(separator + 1) };
+}
+function parseGoal(raw) {
+  if (raw === void 0 || raw === "") return void 0;
+  const separator = raw.indexOf(":");
+  const kind = separator === -1 ? raw : raw.slice(0, separator);
+  const argument = separator === -1 ? "" : raw.slice(separator + 1);
+  if (kind === "leads") return argument ? { kind: "conversion", flowSlug: argument } : { kind: "conversion" };
+  if (kind === "click") return argument ? { kind: "outbound_click", targetHost: argument } : { kind: "outbound_click" };
+  if (kind === "event") return parseEventGoal(argument);
+  return {
+    error: `Unknown goal "${raw}". Use leads, leads:<form>, event:<name>, event:<name>/<key>=<value>, click, or click:<host>`
+  };
+}
+
+// src/commands/experiment/hints.ts
+var RUNNING_HINT = {
+  keep_running: (row) => `${row.experimentId} cannot yet tell the two pages apart \u2014 do not read its numbers as a result, and do not end it hoping for one. ${describeWait(row)}`,
+  winner: (row) => `${row.experimentId} has a winner. Run \`baker experiment finish --id ${row.experimentId}\` to send all the traffic to it. That only re-routes between two pages already published \u2014 it does not edit either.`,
+  no_difference: (row) => `${row.experimentId} measured the two pages as alike \u2014 it collected enough traffic to see the change it was looking for, and there was none. Finish it (the page you have stays live) and test a bigger change \u2014 a headline, an offer, the shape of the page, not a button colour.`,
+  stopped_early_harmful: (row) => `${row.experimentId} is doing damage. Finish it now \u2014 traffic goes back to the original page.`,
+  // Unreachable in practice — only `finish --abandon` produces it, and that
+  // leaves the test finished. The Record is exhaustive by type so a verdict
+  // added upstream fails to compile here rather than printing nothing.
+  abandoned: (row) => `${row.experimentId} was stopped before it concluded and found nothing.`,
+  invalid: (row) => `${row.experimentId} cannot be read: ${row.invalidReason === "crossover" ? "too many visitors saw both versions" : "the traffic did not split evenly"}. Finish it and start again rather than reporting anything from it.`
+};
+function describeWait(row) {
+  if (row.willNotConclude) {
+    return "This page's traffic will not settle it at any point, so abandon it with `--abandon` and test a bigger change.";
+  }
+  if (row.earliestDecisionAt === null) {
+    return "This page has produced no visitors yet, so there is nothing to project a finish date from.";
+  }
+  return `Earliest it could say anything: ${new Date(row.earliestDecisionAt).toISOString().slice(0, 10)}.`;
+}
+function buildStatusHints(experiments) {
+  const hints = experiments.filter((row) => row.status === "running").map((row) => RUNNING_HINT[row.verdict](row));
+  if (experiments.length === 0) {
+    hints.push(
+      "No tests yet. `baker experiment plan --landing <slug> --variant <slug>` says whether a page has enough traffic for one before you build the alternative."
+    );
+  }
+  return hints;
+}
+function asLift(value) {
+  return `+${Math.round(value * 100)}%`;
+}
+function windowHint(days, detectable) {
+  if (days === void 0) return null;
+  if (detectable === null || detectable === void 0) {
+    return `In ${days} days this page would not gather enough visitors to settle anything, at any size of change. The constraint is the traffic, not the test.`;
+  }
+  return `In ${days} days this page could only settle a change of ${asLift(detectable)} or more. Design the alternative to be at least that different \u2014 a smaller change needs traffic these ${days} days will not deliver, and the test would end saying nothing.`;
+}
+function buildPlanHints(plan, days) {
+  const window2 = windowHint(days, plan.detectableLiftInDays);
+  if (!plan.canRun) {
+    return [
+      plan.reason ?? "This test cannot run on this page.",
+      ...window2 ? [window2] : [],
+      "A test that cannot conclude is worse than no test \u2014 it still produces a number, and somebody acts on it."
+    ];
+  }
+  const hints = [
+    `This test measures ${plan.goalLabel}. That is fixed when it starts and cannot be changed later.`,
+    // Fires at the exact moment the hypothesis gets invented, whether or not
+    // the agent read the family doc. `plan` says a question CAN be settled here
+    // and says nothing about which question is worth asking — and a well-run
+    // test of a bad idea costs three weeks and returns `no_difference`.
+    "Now decide WHAT to change, from evidence rather than taste. These numbers say which page and which step; they cannot say why. A second opinion answers why \u2014 Microsoft Clarity for what visitors actually do on the page, `baker gsc` for what they searched, `baker ads <platform>` for what the ad promised, `baker ga4` for the client's own measurement. `baker capabilities` lists everything this client has in one call \u2014 the surfaces, and under `tools` everything else that is reachable. Message match \u2014 what the ad or the search promised against what the page opens with \u2014 is the cheapest hypothesis worth testing and is wrong surprisingly often.",
+    // The base always works, so a missing integration is never a reason to
+    // stop. Naming what it would have shown is worth more to the client than
+    // either a silent gap or a run that waited.
+    "If none of that is connected, this page's own drop-off is enough to test on \u2014 say which source you lacked and what it would have told you, then run the test anyway. A test never waits on an integration."
+  ];
+  if (plan.estimatedDays !== null && plan.estimatedDays > 60) {
+    hints.push(
+      `At this page's traffic it would take about ${plan.estimatedDays} days. Consider testing a bigger change, which needs less traffic to detect.`
+    );
+  }
+  if (window2) hints.push(window2);
+  return hints;
+}
+
+// ../api/src/experiments/composition.ts
+import { z as z29 } from "zod";
+var experimentCompositionSchema = z29.object({
+  /** Components the variant owns its own copy of — the thing under test. */
+  forked: z29.array(z29.string().max(300)).max(50),
+  /** Components both pages render from one file, so an edit reaches both arms. */
+  shared: z29.array(z29.string().max(300)).max(200)
+});
+
+// ../api/src/experiments/goal.ts
+import { z as z30 } from "zod";
+var eventNameSchema = z30.string().min(1).max(120);
+var experimentGoalSchema = z30.discriminatedUnion("kind", [
+  z30.object({
+    kind: z30.literal("conversion"),
+    /**
+     * Narrow to one Form, by the slug that is its identity.
+     *
+     * Absent means every marked conversion on the page counts, which is the
+     * right default for a landing with one Form and the wrong one for a page
+     * carrying both a newsletter signup and a demo request.
+     */
+    flowSlug: z30.string().max(120).optional()
+  }),
+  z30.object({
+    kind: z30.literal("custom_event"),
+    name: eventNameSchema,
+    /**
+     * Narrow to one value of one of the event's own properties.
+     *
+     * `section_view` on its own is every section; `section_view` where
+     * `section = pricing` is the one that matters. Without this a page would
+     * have to encode the answer into the event name to be testable against it,
+     * which is precisely what the properties map exists to stop.
+     */
+    property: z30.string().max(64).optional(),
+    value: z30.string().max(255).optional()
+  }),
+  z30.object({
+    kind: z30.literal("outbound_click"),
+    /**
+     * The destination host, as the row records it. Absent means any exit.
+     *
+     * A host rather than a full URL because that is what `event_name` carries
+     * on an `outbound_click` row — `target_url` has the rest, and matching on
+     * it would make the goal depend on query parameters a campaign rewrites.
+     */
+    targetHost: z30.string().max(255).optional()
+  })
+]);
+
+// ../api/src/experiments/hypothesis.ts
+import { z as z31 } from "zod";
+var experimentEvidenceSourceSchema = z31.enum([
+  "baker_analytics",
+  "clarity",
+  "ads",
+  "search_console",
+  "research",
+  "inspiration",
+  "client",
+  "hunch"
+]);
+var experimentEvidenceSchema = z31.object({
+  source: experimentEvidenceSourceSchema,
+  note: z31.string().min(1).max(200),
+  /**
+   * Where to go and look. Not a `z.url()` — a report inside Baker is reached by
+   * a relative path, and rejecting those would push every in-product citation
+   * into the note where nothing can link it.
+   */
+  href: z31.string().max(500).optional()
+});
+var experimentHypothesisSchema = z31.object({
+  /**
+   * The observation. The one genuinely new field, and the reason for the rest.
+   *
+   * Without it a lost test teaches nothing, because there is no belief for the
+   * result to be evidence against — which is how a testing programme ends up as
+   * a list of tests instead of a list of things learned.
+   */
+  because: z31.string().min(1).max(300),
+  /**
+   * The change, in the client's words.
+   *
+   * The machine-checkable truth lives in `plan.composition.forked`; this is what
+   * a person reads. The two are allowed to differ in wording and cannot differ
+   * in fact, because the brief shows both.
+   */
+  change: z31.string().min(1).max(200),
+  /** Which way the goal is expected to move. See the note at the top of this file. */
+  expect: z31.enum(["increase", "decrease"]).default("increase"),
+  evidence: z31.array(experimentEvidenceSchema).max(5).optional()
+});
+var experimentHypothesisOutcomeSchema = z31.enum([
+  "supported",
+  "refuted_opposite",
+  "refuted_no_effect",
+  "unanswered"
+]);
+
+// ../api/src/experiments/wire.ts
+import { z as z32 } from "zod";
+var slugSchema = z32.string().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Use a page slug, like `oferta`");
+var experimentPlanRequestSchema = z32.object({
+  landingSlug: slugSchema,
+  variantSlug: slugSchema,
+  goal: experimentGoalSchema.optional(),
+  /**
+   * The smallest lift worth detecting, relative to the baseline. `0.2` is +20%.
+   *
+   * The single most consequential number a caller supplies, and the one it is
+   * most tempting to set small. A test sized for +5% on a 3% page needs a
+   * quarter of a million visitors per arm; `plan` will say so rather than
+   * running it.
+   */
+  minDetectableRelativeLift: z32.number().gt(0).max(10).optional(),
+  /**
+   * "I have this many days — what could I even see?"
+   *
+   * Read-only, and deliberately not a setting. It does NOT shorten the test:
+   * the finish line is a number of visitors fixed before the test starts, and a
+   * horizon that can be moved is not a horizon. What it does is answer the
+   * question a refusal leaves hanging — `plan` says a +20% lift needs three
+   * weeks this page will not deliver, and this says what those weeks WOULD
+   * settle, which is a change somebody can actually go and make.
+   */
+  days: z32.number().int().gt(0).max(365).optional()
+});
+var experimentStartRequestSchema = experimentPlanRequestSchema.extend({
+  hypothesis: experimentHypothesisSchema,
+  /**
+   * What the two arms are made of, read off the import graph by the caller at
+   * the moment the test starts.
+   *
+   * Optional on the wire because the backend cannot compute it — only the
+   * Company Workspace has the files — and a workspace that cannot answer must
+   * not be blocked from running a test. The brief degrades to naming the two
+   * pages instead of naming the section under test.
+   */
+  composition: experimentCompositionSchema.optional()
+});
+var experimentFinishRequestSchema = z32.object({
+  experimentId: z32.string().min(1).max(64),
+  /**
+   * Stop the test, keep the page that is live, and record no result.
+   *
+   * The only way a person or an agent can end a test that is still
+   * `keep_running`, and it is deliberately its own field rather than a
+   * `survivor` they get to pick: an abandoned test has no winner, keeps the
+   * control, and is recorded as `abandoned` so it can never be reported later
+   * as a result. Without the separate flag, "stop this" and "the variant won"
+   * would be the same call.
+   *
+   * **It overrides the verdict, and does not defer to it.** The only outcome it
+   * can actually disagree with is a variant win — every other one keeps the
+   * control anyway — so reading it as "apply only when the numbers have nothing
+   * to say" meant that abandoning a won test handed all the traffic to the
+   * variant instead of keeping the original: the opposite of what this field
+   * promises, on live visitors, from a flag whose whole purpose is to be the
+   * conservative choice. The response reports `discardedVerdict` when it did
+   * override one, because throwing away a real finding should be said out loud.
+   */
+  abandon: z32.boolean().optional()
+});
+var experimentStatusRequestSchema = z32.object({
+  experimentId: z32.string().max(64).optional(),
+  full: z32.boolean().optional()
+});
+var experimentPlanResponseSchema = z32.object({
+  canRun: z32.boolean(),
+  /** Present when `canRun` is false. Product language, ready to show. */
+  reason: z32.string().optional(),
+  baselineRate: z32.number(),
+  minDetectableRelativeLift: z32.number(),
+  /** `null` when no amount of traffic could settle the hypothesis. */
+  requiredPerVariant: z32.number().nullable(),
+  /** Visitors a day the page has been getting, per arm once split. */
+  dailyVisitorsPerVariant: z32.number(),
+  /** `null` when the page has no traffic to project from. */
+  estimatedDays: z32.number().nullable(),
+  goal: experimentGoalSchema,
+  goalLabel: z32.string(),
+  /**
+   * The smallest lift `days` of this page's traffic could detect, when `days`
+   * was asked for. `null` when it was not, or when no lift at all would be
+   * detectable in that window.
+   */
+  detectableLiftInDays: z32.number().nullable().optional()
+});
+var experimentVerdictSchema = z32.enum([
+  "keep_running",
+  "winner",
+  "no_difference",
+  "invalid",
+  "stopped_early_harmful",
+  /**
+   * Stopped by a person before it concluded. Never produced by the stopping
+   * rule — only by `finish --abandon`.
+   *
+   * Its own verdict rather than folded into `no_difference`, because they are
+   * opposite claims: one says the two versions were measured and found alike,
+   * the other says nobody ever found out. Collapsing them would manufacture the
+   * exact finding this feature exists to refuse.
+   */
+  "abandoned"
+]);
+var experimentArmSchema = z32.object({
+  slug: z32.string(),
+  visitors: z32.number(),
+  conversions: z32.number(),
+  rate: z32.number()
+});
+var experimentStatusRowSchema = z32.object({
+  experimentId: z32.string(),
+  landingSlug: z32.string(),
+  variantSlug: z32.string(),
+  hypothesis: experimentHypothesisSchema,
+  /**
+   * The hypothesis as one sentence, built from its parts plus the goal and the
+   * lift on this same row. Rendered backend-side so what a client reads in chat
+   * and what they read on the dashboard can never be two different sentences.
+   */
+  hypothesisStatement: z32.string(),
+  /**
+   * What the test found out about the belief — derived from `verdict` and
+   * `winner`, never entered.
+   *
+   * Its own field because the verdict and the outcome come apart in exactly the
+   * case worth catching: a `winner` the *control* won is not a win, it is the
+   * change having made things worse.
+   */
+  hypothesisOutcome: experimentHypothesisOutcomeSchema,
+  /** What the two arms differ by. Absent for a test started before this was recorded. */
+  composition: experimentCompositionSchema.optional(),
+  /**
+   * The finish line this test was sized for. On the row rather than only inside
+   * the plan because the claim is not readable without it — "leads should go up"
+   * is not a hypothesis, "leads should go up by at least 20%" is.
+   */
+  minDetectableRelativeLift: z32.number(),
+  goalLabel: z32.string(),
+  status: z32.enum(["running", "finished"]),
+  startedAt: z32.number(),
+  finishedAt: z32.number().nullable(),
+  verdict: experimentVerdictSchema,
+  /** Set only on `winner`. Which page to keep. */
+  winner: z32.enum(["control", "variant"]).nullable(),
+  /** Set only on `invalid`. Why the numbers cannot be read. */
+  invalidReason: z32.enum(["sample_ratio_mismatch", "crossover"]).nullable(),
+  /** What a person should be told, in one sentence, in product language. */
+  summary: z32.string(),
+  control: experimentArmSchema,
+  variant: experimentArmSchema,
+  /**
+   * How close this test is to being able to say anything at all, 0 to 1.
+   *
+   * Not progress toward a planned sample — there is no longer one to progress
+   * toward. It is the traffic behind the test as a share of the traffic its own
+   * measured variance says it needs, so it moves when the page gets noisier or
+   * steadier rather than only when visitors arrive.
+   */
+  precision: z32.number(),
+  /** When the test could first say something. `null` with no traffic to project from. */
+  earliestDecisionAt: z32.number().nullable(),
+  /**
+   * True when no amount of this page's traffic would settle the comparison.
+   * A different thing from a page that is merely slow, and the reason to
+   * abandon a test rather than leave it running.
+   */
+  willNotConclude: z32.boolean(),
+  /** Printing only. Never a reason to act — `verdict` is. */
+  evidence: z32.object({
+    relativeLift: z32.number(),
+    probabilityVariantBetter: z32.number(),
+    controlInterval: z32.tuple([z32.number(), z32.number()]),
+    variantInterval: z32.tuple([z32.number(), z32.number()]),
+    /** The anytime-valid interval on the relative lift — what the verdict is read from. */
+    liftInterval: z32.tuple([z32.number(), z32.number()])
+  }).optional()
+});
+var experimentStatusResponseSchema = z32.object({
+  experiments: z32.array(experimentStatusRowSchema)
+});
+
+// src/commands/experiment/hypothesis.ts
+var SOURCES = experimentEvidenceSourceSchema.options.join(", ");
+function parseOne(raw) {
+  const separator = raw.indexOf(":");
+  if (separator === -1) {
+    return { error: `Write the evidence as source:note \u2014 for example \`${raw}:what you saw\`. Sources: ${SOURCES}` };
+  }
+  const source = experimentEvidenceSourceSchema.safeParse(raw.slice(0, separator).trim());
+  if (!source.success) {
+    return { error: `\u201C${raw.slice(0, separator).trim()}\u201D is not one of the evidence sources. Use one of: ${SOURCES}` };
+  }
+  const rest = raw.slice(separator + 1).trim();
+  const pipe = rest.lastIndexOf("|");
+  const note = (pipe === -1 ? rest : rest.slice(0, pipe)).trim();
+  const href = pipe === -1 ? void 0 : rest.slice(pipe + 1).trim();
+  if (note === "") {
+    return { error: `Say what ${source.data} showed: --evidence "${source.data}:what you saw"` };
+  }
+  return href ? { source: source.data, note, href } : { source: source.data, note };
+}
+function parseEvidence(raw) {
+  if (raw === void 0) return void 0;
+  const entries = (Array.isArray(raw) ? raw : [raw]).filter((entry) => entry !== "");
+  if (entries.length === 0) return void 0;
+  const parsed = [];
+  for (const entry of entries) {
+    const one = parseOne(entry);
+    if ("error" in one) return one;
+    parsed.push(one);
+  }
+  return parsed;
+}
+
+// src/commands/experiment/index.ts
+var GOAL_ARG = {
+  type: "string",
+  description: "What counts as success, and it is fixed for the life of the test. `leads` (default \u2014 whatever this company already marks as a conversion), `leads:<form>`, `event:<name>` for an event the page declares itself (see `baker analytics events`), `event:<name>/<key>=<value>` to narrow it, `click` or `click:<host>` for leaving the site. Pick the thing the business actually wants; a test that measures the wrong outcome can have the variant win and the revenue fall.",
+  required: false
+};
+var LIFT_ARG = {
+  type: "string",
+  description: "The smallest improvement worth detecting, relative \u2014 0.2 is +20% (default). The single most consequential number here: halving it roughly quadruples the traffic needed. Ask for the smallest lift that would actually change what the client does, not the smallest one you would like to see.",
+  required: false
+};
+var DAYS_ARG = {
+  type: "string",
+  description: "How many days you have, if that is the constraint. This does NOT shorten the test \u2014 the finish line is a visitor count fixed before it starts \u2014 it answers the other question: what a window that long could settle on this page's traffic. Use it when `plan` refuses and you need to know what WOULD fit.",
+  required: false
+};
+var BECAUSE_ARG = {
+  type: "string",
+  description: "What you SAW that makes this worth testing \u2014 the observation, not the change. \u201C60% of visitors never scroll past the hero\u201D, \u201CCPL doubled after the new headline\u201D. This is the field that makes a losing test worth something: without it there is no belief for the result to be evidence against, and the next test is no better informed than this one.",
+  required: true
+};
+var CHANGE_ARG = {
+  type: "string",
+  description: "What is different about the alternative version, in the client's words \u2014 \u201Cput the booking form in the hero\u201D. One thing. Say it as the reader of the report would.",
+  required: true
+};
+var EXPECT_ARG = {
+  type: "string",
+  description: "Which way you expect the goal to move: `increase` (default) or `decrease`. This is what lets Baker report whether your hypothesis HELD, rather than only which page won \u2014 a test the original page wins is not a win, it is the change having made things worse, and that is the most useful thing a test can tell you.",
+  required: false
+};
+var EVIDENCE_ARG = {
+  type: "string",
+  description: "Where the observation came from, as `source:what it showed`, optionally `|link`. Repeatable. Sources: baker_analytics, clarity, ads, search_console, research, inspiration, client, hunch. Use `hunch` honestly when there is no data \u2014 a stated guess is worth more than a guess dressed as analytics.",
+  required: false
+};
+function fail5(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function reportApiError(error) {
+  if (error instanceof ApiError) {
+    writeJsonEnvelope({ ok: false, error: { code: error.code ?? "ERROR", message: error.message } });
+    process.exit(1);
+  }
+  throw error;
+}
+registerSchema({
+  command: "experiment.plan",
+  description: "Whether a page has enough traffic to settle a question, before anything is built",
+  args: {
+    landing: { type: "string", description: "The page under test, by slug", required: true },
+    variant: { type: "string", description: "The alternative page's slug", required: true },
+    goal: GOAL_ARG,
+    lift: LIFT_ARG,
+    days: DAYS_ARG
+  }
+});
+var planCommand = defineCommand112({
+  meta: {
+    name: "plan",
+    description: "Start here, BEFORE building the alternative page. Says whether this page gets enough traffic to settle the question, how long it would take, and whether the thing you want to measure has ever happened on it. Most landing pages cannot run most tests \u2014 finding that out now costs one call, and finding it out later costs three weeks and a decision made on noise."
+  },
+  args: {
+    landing: { type: "string", description: "The page under test, by slug", required: true },
+    variant: { type: "string", description: "The alternative page's slug", required: true },
+    goal: GOAL_ARG,
+    lift: LIFT_ARG,
+    days: DAYS_ARG
+  },
+  run: async ({ args }) => {
+    const goal = parseGoal(args.goal ? String(args.goal) : void 0);
+    if (goal && "error" in goal) fail5(goal.error);
+    try {
+      const response = await apiPost("/api/experiments/plan", {
+        landingSlug: String(args.landing),
+        variantSlug: String(args.variant),
+        ...goal ? { goal } : {},
+        ...args.lift ? { minDetectableRelativeLift: Number(args.lift) } : {},
+        ...args.days ? { days: Number(args.days) } : {}
+      });
+      writeJsonEnvelope({
+        ok: true,
+        data: response.data,
+        hints: buildPlanHints(response.data, args.days ? Number(args.days) : void 0)
+      });
+    } catch (error) {
+      reportApiError(error);
+    }
+  }
+});
+registerSchema({
+  command: "experiment.start",
+  description: "Stage an A/B test between a page and its alternative",
+  args: {
+    landing: { type: "string", description: "The page under test, by slug", required: true },
+    variant: { type: "string", description: "The alternative page's slug", required: true },
+    because: BECAUSE_ARG,
+    change: CHANGE_ARG,
+    expect: EXPECT_ARG,
+    evidence: EVIDENCE_ARG,
+    goal: GOAL_ARG,
+    lift: LIFT_ARG
+  }
+});
+var startCommand = defineCommand112({
+  meta: {
+    name: "start",
+    description: "Stage a test between the page and its alternative. Both are ordinary published pages; visitors are split 50/50 at the edge, so there is no flicker and nothing for an ad blocker to suppress. Nothing goes live until the session is published \u2014 the person publishing is the review of the alternative page. Re-runs `plan` first and refuses on the same grounds."
+  },
+  args: {
+    landing: { type: "string", description: "The page under test, by slug", required: true },
+    variant: { type: "string", description: "The alternative page's slug", required: true },
+    because: BECAUSE_ARG,
+    change: CHANGE_ARG,
+    expect: EXPECT_ARG,
+    evidence: EVIDENCE_ARG,
+    goal: GOAL_ARG,
+    lift: LIFT_ARG
+  },
+  run: async ({ args }) => {
+    const goal = parseGoal(args.goal ? String(args.goal) : void 0);
+    if (goal && "error" in goal) fail5(goal.error);
+    const expect = args.expect === void 0 ? "increase" : String(args.expect);
+    if (expect !== "increase" && expect !== "decrease") {
+      fail5("`--expect` is either `increase` or `decrease` \u2014 which way should the goal move if you are right?");
+    }
+    const evidence = parseEvidence(args.evidence);
+    if (evidence && "error" in evidence) fail5(evidence.error);
+    const composition = await readComposition(process.cwd(), String(args.landing), String(args.variant));
+    try {
+      const response = await apiPost("/api/experiments/start", {
+        landingSlug: String(args.landing),
+        variantSlug: String(args.variant),
+        hypothesis: {
+          because: String(args.because),
+          change: String(args.change),
+          expect,
+          ...evidence ? { evidence } : {}
+        },
+        ...composition ? { composition } : {},
+        ...goal ? { goal } : {},
+        ...args.lift ? { minDetectableRelativeLift: Number(args.lift) } : {}
+      });
+      writeJsonEnvelope({
+        ok: true,
+        data: response.data,
+        hints: [
+          // The one composition worth interrupting for: `baker landing variant`
+          // with no `--fork` succeeds and produces a page that renders exactly
+          // the control, so the test would run for weeks against itself.
+          ...composition && composition.forked.length === 0 ? [
+            `\u201C${String(args.variant)}\u201D does not have its own copy of any section \u2014 it renders exactly the same page as \u201C${String(args.landing)}\u201D, so this test cannot find anything. Fork the section you want to test (\`baker landing variant ${String(args.landing)} ${String(args.variant)} --fork Hero.astro\`) and edit only that file.`
+          ] : [],
+          "Staged. The split starts when this session is published \u2014 publishing is the review of the alternative page.",
+          "Check it as often as you like \u2014 `baker experiment status` is safe to read at any moment and holds its error rate however often you ask. What is never safe is reading the numbers instead of the verdict: `keep_running` means this test cannot yet tell the two pages apart, whatever the rates happen to say today."
+        ]
+      });
+    } catch (error) {
+      reportApiError(error);
+    }
+  }
+});
+registerSchema({
+  command: "experiment.status",
+  description: "The verdict on every A/B test, running and finished",
+  args: {
+    id: { type: "string", description: "One test, by its id", required: false },
+    full: { type: "boolean", description: "Include the posteriors behind the verdict", required: false }
+  }
+});
+var statusCommand4 = defineCommand112({
+  meta: {
+    name: "status",
+    description: "The verdict on each test. Read `verdict` and nothing else to decide: keep_running | winner | no_difference | invalid | stopped_early_harmful. `summary` is one sentence you can show the client. The numbers under `--full` are for printing, never for deciding \u2014 a test that says keep_running has not finished, however good its numbers look."
+  },
+  args: {
+    id: { type: "string", description: "One test, by its id", required: false },
+    full: { type: "boolean", description: "Include the posteriors behind the verdict", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const response = await apiPost("/api/experiments/status", {
+        ...args.id ? { experimentId: String(args.id) } : {},
+        ...args.full === true ? { full: true } : {}
+      });
+      writeJsonEnvelope({
+        ok: true,
+        data: response.data,
+        hints: buildStatusHints(response.data.experiments)
+      });
+    } catch (error) {
+      reportApiError(error);
+    }
+  }
+});
+registerSchema({
+  command: "experiment.finish",
+  description: "End a test and send all its traffic to the surviving page",
+  args: {
+    id: { type: "string", description: "The test, by its id", required: true },
+    abandon: {
+      type: "boolean",
+      description: "Stop the test, keep the original page, and record no result. The only way to end a test that has not concluded \u2014 and it OVERRIDES a verdict if there is one, throwing that finding away. Do not pass it by reflex.",
+      required: false
+    }
+  }
+});
+var finishCommand = defineCommand112({
+  meta: {
+    name: "finish",
+    description: "End a test and send all its traffic to whichever page survived. Only a test whose verdict has concluded can be finished with a result \u2014 a `keep_running` test can only be `--abandon`ed, which keeps the original page and records no finding. Promotion is a traffic change over two pages that were both already published and reviewed; it does not edit either page."
+  },
+  args: {
+    id: { type: "string", description: "The test, by its id", required: true },
+    abandon: {
+      type: "boolean",
+      description: "Stop the test, keep the original page, and record no result. The only way to end a test that has not concluded \u2014 and it OVERRIDES a verdict if there is one, throwing that finding away. Do not pass it by reflex.",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const response = await apiPost("/api/experiments/finish", {
+        experimentId: String(args.id),
+        ...args.abandon === true ? { abandon: true } : {}
+      });
+      writeJsonEnvelope({
+        ok: true,
+        data: response.data,
+        hints: [
+          `Staged. All the traffic goes to the ${response.data.survivor === "variant" ? "alternative" : "original"} page when this session is published.`,
+          ...response.data.discardedVerdict ? [
+            `You abandoned a test that HAD concluded (${response.data.discardedVerdict}). The original page keeps the traffic and no result is recorded \u2014 the finding is gone. If that was not what you meant, run this again without --abandon.`
+          ] : [],
+          "If the alternative won and you want it to become the page itself, that is an ordinary page edit afterwards \u2014 copy its content over and delete the alternative."
+        ]
+      });
+    } catch (error) {
+      reportApiError(error);
+    }
+  }
+});
+var experimentCommand = defineCommand112({
+  meta: {
+    name: "experiment",
+    description: "Run an A/B test between a landing page and an alternative version of it, and be told which one is better. Always `plan` first: most pages do not get enough traffic to settle most questions, and a test that cannot conclude still produces a number somebody will act on."
+  },
+  subCommands: {
+    plan: planCommand,
+    start: startCommand,
+    status: statusCommand4,
+    finish: finishCommand
+  }
+});
+
 // src/commands/flows/index.ts
-import { defineCommand as defineCommand116 } from "citty";
+import { defineCommand as defineCommand117 } from "citty";
 
 // src/commands/flows/add.ts
 import { randomUUID } from "crypto";
-import { defineCommand as defineCommand112 } from "citty";
+import { defineCommand as defineCommand113 } from "citty";
 
 // src/commands/flows/shared.ts
 import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
@@ -33692,12 +34514,12 @@ function collectSideEffects(tree) {
   );
 }
 function readFlowTree(slug) {
-  const path38 = join3(flowsDir(), slug, "_data.json");
-  if (!existsSync5(path38)) {
+  const path41 = join3(flowsDir(), slug, "_data.json");
+  if (!existsSync5(path41)) {
     failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
   }
   try {
-    return JSON.parse(readFileSync9(path38, "utf-8"));
+    return JSON.parse(readFileSync9(path41, "utf-8"));
   } catch (error) {
     failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -33849,7 +34671,7 @@ registerSchema({
     parent: { type: "string", description: "Parent node id. Omit to append to the root's children.", required: false }
   }
 });
-var addNodeCommand = defineCommand112({
+var addNodeCommand = defineCommand113({
   meta: {
     name: "add-node",
     description: 'Add a step to a form, with the skeleton its type requires. Example: baker flows add-node contact --type customForm --name "Contact Info"'
@@ -33945,7 +34767,7 @@ registerSchema({
     }
   }
 });
-var addSideEffectCommand = defineCommand112({
+var addSideEffectCommand = defineCommand113({
   meta: {
     name: "add-side-effect",
     description: "Add a side effect to a step, with the skeleton its type requires. Example: baker flows add-side-effect contact --node <id> --type googleSpreadsheet"
@@ -34027,7 +34849,7 @@ var addSideEffectCommand = defineCommand112({
 
 // src/commands/flows/map.ts
 import { readFileSync as readFileSync11 } from "fs";
-import { defineCommand as defineCommand113 } from "citty";
+import { defineCommand as defineCommand114 } from "citty";
 
 // src/commands/flows/value-expression.ts
 import { existsSync as existsSync6, readFileSync as readFileSync10 } from "fs";
@@ -34089,10 +34911,10 @@ function parseValueExpression(raw) {
   return parts.map(parsePart);
 }
 function trackingFieldIds() {
-  const path38 = join4(flowsDir(), "..", "tracking.ts");
-  if (!existsSync6(path38)) return null;
+  const path41 = join4(flowsDir(), "..", "tracking.ts");
+  if (!existsSync6(path41)) return null;
   try {
-    const source = readFileSync10(path38, "utf-8");
+    const source = readFileSync10(path41, "utf-8");
     const block2 = source.match(/TRACKING_FIELD_IDS\s*=\s*\[([\s\S]*?)\]\s*as const/)?.[1];
     if (!block2) return null;
     const ids = [...block2.matchAll(/"(tracking\.[a-z0-9_]+)"/g)].map((match) => match[1]);
@@ -34644,13 +35466,13 @@ function specsFromFile(parsed) {
     return `${destField}${type}=${entry?.value ?? ""}`;
   });
 }
-function readSpecFile(path38) {
+function readSpecFile(path41) {
   let raw;
   try {
-    raw = path38 === "-" ? readFileSync11(0, "utf-8") : readFileSync11(path38, "utf-8");
+    raw = path41 === "-" ? readFileSync11(0, "utf-8") : readFileSync11(path41, "utf-8");
   } catch (error) {
     refuse(
-      `Could not read ${path38 === "-" ? "the mapping from stdin" : `"${path38}"`}: ${error instanceof Error ? error.message : String(error)}`
+      `Could not read ${path41 === "-" ? "the mapping from stdin" : `"${path41}"`}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   let parsed;
@@ -34658,7 +35480,7 @@ function readSpecFile(path38) {
     parsed = JSON.parse(raw);
   } catch (error) {
     refuse(
-      `${path38 === "-" ? "stdin" : `"${path38}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      `${path41 === "-" ? "stdin" : `"${path41}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
       'Expected { "map": { "<destField>": "<value>", \u2026 } }'
     );
   }
@@ -34800,7 +35622,7 @@ async function mapOptions(args, fromFile, into) {
     destinationFields: hubspotForm ? await hubspotFieldCatalog(hubspotForm) : void 0
   };
 }
-var mapCommand2 = defineCommand113({
+var mapCommand2 = defineCommand114({
   meta: {
     name: "map",
     description: "Map form fields onto any value a side effect sends \u2014 never hand-write a mapping. Start here: baker flows map contact --from map.json --write"
@@ -34898,7 +35720,7 @@ var mapCommand2 = defineCommand113({
 });
 
 // src/commands/flows/normalize.ts
-import { defineCommand as defineCommand114 } from "citty";
+import { defineCommand as defineCommand115 } from "citty";
 var OPTIONAL_STRINGS = ["oauthProviderId"];
 var ARRAY_FIELDS = [
   "fieldMapping",
@@ -34912,18 +35734,18 @@ var ARRAY_FIELDS = [
   "tagIds"
 ];
 var ARRAY_OWNERS = ["", "body"];
-function dropUnsetOptionals(sideEffect, path38) {
+function dropUnsetOptionals(sideEffect, path41) {
   return OPTIONAL_STRINGS.flatMap((key) => {
     if (!(key in sideEffect) || sideEffect[key] !== null && sideEffect[key] !== "") return [];
     delete sideEffect[key];
-    return [{ path: path38, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
+    return [{ path: path41, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
   });
 }
-function fillNulledArrays(target, prefix, path38) {
+function fillNulledArrays(target, prefix, path41) {
   return ARRAY_FIELDS.flatMap((key) => {
     if (!(key in target) || target[key] !== null) return [];
     target[key] = [];
-    return [{ path: path38, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
+    return [{ path: path41, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
   });
 }
 function sideEffectsOf(node) {
@@ -34933,13 +35755,13 @@ function sideEffectsOf(node) {
   );
 }
 function normalizeSideEffect(sideEffect, where) {
-  const path38 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
+  const path41 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
   const arrays = ARRAY_OWNERS.flatMap((owner) => {
     const target = owner ? sideEffect[owner] : sideEffect;
     if (!target || typeof target !== "object") return [];
-    return fillNulledArrays(target, owner ? `${owner}.` : "", path38);
+    return fillNulledArrays(target, owner ? `${owner}.` : "", path41);
   });
-  return [...dropUnsetOptionals(sideEffect, path38), ...arrays];
+  return [...dropUnsetOptionals(sideEffect, path41), ...arrays];
 }
 function normalizeFlowTree(tree) {
   const changes = [];
@@ -34967,7 +35789,7 @@ registerSchema({
     }
   }
 });
-var normalizeCommand = defineCommand114({
+var normalizeCommand = defineCommand115({
   meta: {
     name: "normalize",
     description: "Repair the shapes a form file is allowed to get slightly wrong. Example: baker flows normalize contact --write"
@@ -34998,7 +35820,7 @@ var normalizeCommand = defineCommand114({
 });
 
 // src/commands/flows/schema.ts
-import { defineCommand as defineCommand115 } from "citty";
+import { defineCommand as defineCommand116 } from "citty";
 registerSchema({
   command: "flows.schema",
   description: "The shape of one node or side-effect type: a pasteable skeleton, who fills each part, and the reference file with the craft. Start here before authoring anything in a form's _data.json.",
@@ -35023,7 +35845,7 @@ function triggerHints(triggers) {
     `A side effect on this step carries \`triggerId: "${triggers.completion}"\`, and \`baker flows add-side-effect\` writes it for you. The trigger belongs to the STEP, not to the side-effect type: one that does not match is valid, ships, and never runs.` + (others.length > 0 ? ` Other moments this step raises: ${others.join(", ")}.` : "")
   ];
 }
-var schemaCommand = defineCommand115({
+var schemaCommand = defineCommand116({
   meta: {
     name: "schema",
     description: "Show a node or side-effect type's shape. Start here: baker flows schema node customForm \xB7 baker flows schema side-effect googleSpreadsheet \xB7 baker flows schema (lists both)"
@@ -35157,7 +35979,7 @@ function displayName(slug) {
   const name = tree.displayName;
   return typeof name === "string" && name.trim() ? name.trim() : slug;
 }
-var listCommand12 = defineCommand116({
+var listCommand12 = defineCommand117({
   meta: {
     name: "list",
     description: "List Forms in this workspace with the count of confidential fields still needing setup. Example: baker flows list"
@@ -35178,7 +36000,7 @@ var listCommand12 = defineCommand116({
     });
   }
 });
-var showCommand3 = defineCommand116({
+var showCommand3 = defineCommand117({
   meta: {
     name: "show",
     description: "Show a Form's confidential fields and their configuration status (never secret values). Example: baker flows show contact"
@@ -35206,7 +36028,7 @@ var showCommand3 = defineCommand116({
     });
   }
 });
-var flowsCommand = defineCommand116({
+var flowsCommand = defineCommand117({
   meta: {
     name: "flows",
     description: `Read and shape this workspace's Forms (flows).
@@ -35240,10 +36062,10 @@ Full guide: __tooling__/docs/tools/baker/flows.md`
 });
 
 // src/commands/ga4/index.ts
-import { defineCommand as defineCommand123 } from "citty";
+import { defineCommand as defineCommand124 } from "citty";
 
 // src/commands/ga4/audit.ts
-import { defineCommand as defineCommand117 } from "citty";
+import { defineCommand as defineCommand118 } from "citty";
 
 // src/commands/ga4/resolve.ts
 async function fetchProperties(useCache = true) {
@@ -35309,7 +36131,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
   }
 });
-var auditCommand2 = defineCommand117({
+var auditCommand2 = defineCommand118({
   meta: {
     name: "audit",
     description: `Run all GA4 admin health checks. Returns property config with playbook warnings.
@@ -35364,7 +36186,7 @@ Examples:
 });
 
 // src/commands/ga4/config.ts
-import { defineCommand as defineCommand118 } from "citty";
+import { defineCommand as defineCommand119 } from "citty";
 
 // src/commands/ga4/shared.ts
 import { readFileSync as readFileSync12 } from "fs";
@@ -35477,10 +36299,10 @@ async function stageOps(ops) {
     handleError2(err);
   }
 }
-async function draftAction2(path38, body, chat) {
+async function draftAction2(path41, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path38, { chatId, ...body });
+    const data = await apiPost(path41, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -35560,7 +36382,7 @@ function configHints(config) {
   }
   return hints;
 }
-var configCommand = defineCommand118({
+var configCommand = defineCommand119({
   meta: {
     name: "config",
     description: `Read how the property is configured to measure \u2014 key events, custom definitions, custom events, retention
@@ -35592,7 +36414,7 @@ Examples:
 });
 
 // src/commands/ga4/draft.ts
-import { defineCommand as defineCommand119 } from "citty";
+import { defineCommand as defineCommand120 } from "citty";
 registerSchema({
   command: "ga4.draft",
   description: "Review and undo the Google Analytics changes staged on this chat. Use `list` to see everything staged, `show` to inspect one change in full before the chat completes, `amend` to correct one in place, and `remove`/`clear` to drop them. `list` and `show` take --chat <id> to read an earlier chat's changes instead.",
@@ -35601,13 +36423,13 @@ registerSchema({
     chat: { type: "string", description: CHAT_READ_ARG.description, required: false }
   }
 });
-var draftCommand3 = defineCommand119({
+var draftCommand3 = defineCommand120({
   meta: {
     name: "draft",
     description: "List, show, amend, remove or clear the Google Analytics changes staged on this chat. `list` and `show` take --chat <id> to read an earlier chat's changes instead."
   },
   subCommands: {
-    list: defineCommand119({
+    list: defineCommand120({
       meta: { name: "list", description: "Review everything staged on this chat (--json for the raw envelope)" },
       args: {
         json: { type: "boolean", description: "Print the raw JSON envelope", required: false },
@@ -35617,7 +36439,7 @@ var draftCommand3 = defineCommand119({
         await draftList(args.json === true, args.chat);
       }
     }),
-    show: defineCommand119({
+    show: defineCommand120({
       meta: {
         name: "show",
         description: "Print the full staged payload for one change, alongside how the property looks today \u2014 the receipt to verify it before the chat completes (never truncated)."
@@ -35634,7 +36456,7 @@ var draftCommand3 = defineCommand119({
         );
       }
     }),
-    amend: defineCommand119({
+    amend: defineCommand120({
       meta: {
         name: "amend",
         description: "Update a staged change in place \u2014 merges a JSON patch into its payload (objects deep-merge, null deletes a key, arrays/scalars replace) and re-runs every check. Use this instead of remove + re-create."
@@ -35651,7 +36473,7 @@ var draftCommand3 = defineCommand119({
         });
       }
     }),
-    remove: defineCommand119({
+    remove: defineCommand120({
       meta: { name: "remove", description: "Remove one staged change" },
       args: { ref: { type: "positional", description: "Staged ref or target id", required: false } },
       run: async ({ args }) => {
@@ -35660,7 +36482,7 @@ var draftCommand3 = defineCommand119({
         });
       }
     }),
-    clear: defineCommand119({
+    clear: defineCommand120({
       meta: { name: "clear", description: "Discard all Google Analytics changes staged on this chat" },
       run: async () => {
         await draftAction2("/api/ga4/draft/clear", {});
@@ -35670,7 +36492,7 @@ var draftCommand3 = defineCommand119({
 });
 
 // src/commands/ga4/properties.ts
-import { defineCommand as defineCommand120 } from "citty";
+import { defineCommand as defineCommand121 } from "citty";
 registerSchema({
   command: "ga4.properties",
   description: "List the GA4 properties this company connected \u2014 there can be several, and every one of them is yours to query. Returns the property IDs the query and audit commands take. Run this first to find property IDs.",
@@ -35686,7 +36508,7 @@ function propertyHints(properties) {
     resources: properties.map((property) => ({ id: property.externalId, label: property.name }))
   });
 }
-var propertiesCommand = defineCommand120({
+var propertiesCommand = defineCommand121({
   meta: {
     name: "properties",
     description: `List accessible GA4 properties.
@@ -35736,7 +36558,7 @@ Examples:
 // src/commands/ga4/query.ts
 import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve2 } from "path";
-import { defineCommand as defineCommand121 } from "citty";
+import { defineCommand as defineCommand122 } from "citty";
 
 // src/commands/ga4/presets.ts
 var GA4_PRESETS = [
@@ -35871,7 +36693,7 @@ function handleError3(err) {
   });
   process.exit(1);
 }
-var queryCommand2 = defineCommand121({
+var queryCommand2 = defineCommand122({
   meta: {
     name: "query",
     description: `Run GA4 Data API reports. Preset-first with free-form escape hatch.
@@ -35942,7 +36764,7 @@ Free-form (escape hatch):
 });
 
 // src/commands/ga4/write-commands.ts
-import { defineCommand as defineCommand122 } from "citty";
+import { defineCommand as defineCommand123 } from "citty";
 var PROPERTY_ARG_DESCRIPTION = "GA4 property id (optional only when one property is connected \u2014 run `baker ga4 properties`)";
 var propertyArg = { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false };
 function createJsonDescription(noun) {
@@ -35960,7 +36782,7 @@ registerSchema({
     "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
   }
 });
-var keyEventCommand = defineCommand122({
+var keyEventCommand = defineCommand123({
   meta: {
     name: "key-event",
     description: `Stage key-event (conversion) changes
@@ -35973,7 +36795,7 @@ Examples:
   baker ga4 key-event delete 4185`
   },
   subCommands: {
-    create: defineCommand122({
+    create: defineCommand123({
       meta: {
         name: "create",
         description: "Stage a new key event. Needs eventName and countingMethod (ONCE_PER_EVENT or ONCE_PER_SESSION); defaultValue sets a monetary value when the event does not send one."
@@ -35994,7 +36816,7 @@ Examples:
         );
       }
     }),
-    update: defineCommand122({
+    update: defineCommand123({
       meta: {
         name: "update",
         description: "Stage a change to an existing key event (pass its id). Only countingMethod and defaultValue can change \u2014 Google will not rename a key event."
@@ -36014,7 +36836,7 @@ Examples:
         });
       }
     }),
-    delete: defineCommand122({
+    delete: defineCommand123({
       meta: {
         name: "delete",
         description: "Stage removing a key event, so the event stops counting as a conversion. The event itself keeps being collected. Irreversible once the chat completes \u2014 confirm with the user first."
@@ -36062,7 +36884,7 @@ for (const { kind, noun, createHint } of DEFINITIONS) {
 }
 function definitionCommand(definition) {
   const { command, kind, noun, example } = definition;
-  return defineCommand122({
+  return defineCommand123({
     meta: {
       name: command,
       description: `Stage ${noun} changes
@@ -36074,7 +36896,7 @@ Examples:
   baker ga4 ${command} archive 12`
     },
     subCommands: {
-      create: defineCommand122({
+      create: defineCommand123({
         meta: { name: "create", description: `Stage a new ${noun} (or a JSON array of them, staged together)` },
         args: {
           json: { type: "string", description: createJsonDescription(noun), required: false },
@@ -36092,7 +36914,7 @@ Examples:
           );
         }
       }),
-      update: defineCommand122({
+      update: defineCommand123({
         meta: {
           name: "update",
           description: `Stage a change to an existing ${noun} (pass its id). The parameter name and scope cannot change \u2014 archive and recreate for that.`
@@ -36112,7 +36934,7 @@ Examples:
           });
         }
       }),
-      archive: defineCommand122({
+      archive: defineCommand123({
         meta: {
           name: "archive",
           description: `Stage archiving a ${noun} (pass its id). It stops collecting and leaves reporting; past data stays. Irreversible once the chat completes \u2014 confirm with the user first.`
@@ -36157,7 +36979,7 @@ var dataStreamArg = {
 function withStream(args) {
   return typeof args["data-stream"] === "string" ? { dataStream: args["data-stream"] } : {};
 }
-var customEventCommand = defineCommand122({
+var customEventCommand = defineCommand123({
   meta: {
     name: "custom-event",
     description: `Stage custom events \u2014 new events built from events the site already sends
@@ -36168,7 +36990,7 @@ Examples:
   baker ga4 custom-event delete 7`
   },
   subCommands: {
-    create: defineCommand122({
+    create: defineCommand123({
       meta: {
         name: "create",
         description: "Stage a new custom event. Conditions match the source event: use field `event_name` to match the event itself, or any parameter name to match its value."
@@ -36191,7 +37013,7 @@ Examples:
         );
       }
     }),
-    update: defineCommand122({
+    update: defineCommand123({
       meta: { name: "update", description: "Stage a change to an existing custom event (pass its id)" },
       args: {
         id: { type: "positional", description: "Custom event rule id", required: false },
@@ -36210,7 +37032,7 @@ Examples:
         });
       }
     }),
-    delete: defineCommand122({
+    delete: defineCommand123({
       meta: {
         name: "delete",
         description: "Stage removing a custom event (pass its id). The event stops being created from then on; data already collected under it stays. Confirm with the user first."
@@ -36265,7 +37087,7 @@ function booleanArg(input, flag) {
   if (input === "false") return false;
   return failValidation3(`--${flag} must be true or false`);
 }
-var dataRetentionCommand = defineCommand122({
+var dataRetentionCommand = defineCommand123({
   meta: {
     name: "data-retention",
     description: `Stage a change to how long Google Analytics keeps data
@@ -36275,7 +37097,7 @@ Examples:
   baker ga4 data-retention set --event-data 14 --user-data 14 --reset-on-activity true`
   },
   subCommands: {
-    set: defineCommand122({
+    set: defineCommand123({
       meta: { name: "set", description: "Stage the retention window (months)" },
       args: {
         "event-data": { type: "string", description: "2, 14, 26, 38 or 50", required: false },
@@ -36311,7 +37133,7 @@ registerSchema({
     "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
   }
 });
-var audienceCommand = defineCommand122({
+var audienceCommand = defineCommand123({
   meta: {
     name: "audience",
     description: `Stage audience changes (saved groups of users, for retargeting and analysis)
@@ -36343,7 +37165,7 @@ Examples:
   baker ga4 audience archive 8813`
   },
   subCommands: {
-    create: defineCommand122({
+    create: defineCommand123({
       meta: { name: "create", description: createJsonDescription("audience") },
       args: {
         json: { type: "string", description: createJsonDescription("audience"), required: false },
@@ -36361,7 +37183,7 @@ Examples:
         );
       }
     }),
-    update: defineCommand122({
+    update: defineCommand123({
       meta: {
         name: "update",
         description: "Stage a new name or description (pass the audience id). Who is in it cannot be changed."
@@ -36382,7 +37204,7 @@ Examples:
         });
       }
     }),
-    archive: defineCommand122({
+    archive: defineCommand123({
       meta: {
         name: "archive",
         description: "Stage retiring an audience. Cannot be undone \u2014 the users it gathered do not come back."
@@ -36411,7 +37233,7 @@ registerSchema({
     "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
   }
 });
-var propertyCommand = defineCommand122({
+var propertyCommand = defineCommand123({
   meta: {
     name: "property",
     description: `Stage a change to the property's own settings
@@ -36421,7 +37243,7 @@ Examples:
   baker ga4 property set --name "Acme \u2014 Web" --industry REAL_ESTATE`
   },
   subCommands: {
-    set: defineCommand122({
+    set: defineCommand123({
       meta: { name: "set", description: "Stage the property name and/or industry category" },
       args: {
         name: { type: "string", description: "New property display name", required: false },
@@ -36461,7 +37283,7 @@ registerSchema({
     "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
   }
 });
-var adsLinkCommand = defineCommand122({
+var adsLinkCommand = defineCommand123({
   meta: {
     name: "ads-link",
     description: `Stage linking this property to a Google Ads account
@@ -36476,7 +37298,7 @@ Examples:
   baker ga4 ads-link delete L1234`
   },
   subCommands: {
-    create: defineCommand122({
+    create: defineCommand123({
       meta: { name: "create", description: "Stage linking the property to a Google Ads account" },
       args: {
         "customer-id": { type: "string", description: "Google Ads customer id (123-456-7890)", required: false },
@@ -36495,7 +37317,7 @@ Examples:
         await stageOp3({ kind: "ga4.googleAdsLink.create", payload, ...withProperty(args) });
       }
     }),
-    update: defineCommand122({
+    update: defineCommand123({
       meta: {
         name: "update",
         description: "Stage the ads-personalisation setting on an existing link (pass its id)"
@@ -36517,7 +37339,7 @@ Examples:
         });
       }
     }),
-    delete: defineCommand122({
+    delete: defineCommand123({
       meta: {
         name: "delete",
         description: "Stage unlinking. Stops conversion imports and strands every audience on this property."
@@ -36568,7 +37390,7 @@ var MEASUREMENT_FLAGS = {
   "page-changes": "pageChangesEnabled",
   "form-interactions": "formInteractionsEnabled"
 };
-var enhancedMeasurementCommand = defineCommand122({
+var enhancedMeasurementCommand = defineCommand123({
   meta: {
     name: "enhanced-measurement",
     description: `Stage the automatic events GA4 collects on a website stream
@@ -36582,7 +37404,7 @@ Examples:
   baker ga4 enhanced-measurement set --video false`
   },
   subCommands: {
-    set: defineCommand122({
+    set: defineCommand123({
       meta: { name: "set", description: "Stage which automatic events the website stream collects" },
       args: {
         scrolls: { type: "string", description: "true|false", required: false },
@@ -36625,7 +37447,7 @@ Examples:
 });
 
 // src/commands/ga4/index.ts
-var ga4Command = defineCommand123({
+var ga4Command = defineCommand124({
   meta: {
     name: "ga4",
     description: `Google Analytics 4. Report on a property, audit its config, and change what it measures.
@@ -36674,12 +37496,12 @@ Full guide: __tooling__/docs/tools/baker/ga4.md`
 });
 
 // src/commands/gsc/index.ts
-import { defineCommand as defineCommand127 } from "citty";
+import { defineCommand as defineCommand128 } from "citty";
 
 // src/commands/gsc/query.ts
 import { appendFileSync as appendFileSync3, existsSync as existsSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "fs";
 import { resolve as resolve3 } from "path";
-import { defineCommand as defineCommand124 } from "citty";
+import { defineCommand as defineCommand125 } from "citty";
 
 // src/commands/gsc/presets.ts
 var GSC_PRESETS = [
@@ -36873,7 +37695,7 @@ function handleError4(err) {
   });
   process.exit(1);
 }
-var queryCommand3 = defineCommand124({
+var queryCommand3 = defineCommand125({
   meta: {
     name: "query",
     description: `Run GSC Search Analytics queries. Preset-first with free-form escape hatch.
@@ -36951,7 +37773,7 @@ Free-form (escape hatch):
 });
 
 // src/commands/gsc/sitemaps.ts
-import { defineCommand as defineCommand125 } from "citty";
+import { defineCommand as defineCommand126 } from "citty";
 registerSchema({
   command: "gsc.sitemaps",
   description: "List sitemaps for a Search Console site. Check sitemap health and errors.",
@@ -36960,7 +37782,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
   }
 });
-var sitemapsCommand = defineCommand125({
+var sitemapsCommand = defineCommand126({
   meta: {
     name: "sitemaps",
     description: `List sitemaps for a site. Check health and errors.
@@ -37013,7 +37835,7 @@ Examples:
 });
 
 // src/commands/gsc/sites.ts
-import { defineCommand as defineCommand126 } from "citty";
+import { defineCommand as defineCommand127 } from "citty";
 registerSchema({
   command: "gsc.sites",
   description: "List the Search Console sites this company connected \u2014 there can be several, and every one of them is yours to query. Returns the site URLs the query and sitemaps commands take.",
@@ -37029,7 +37851,7 @@ function siteHints(sites) {
     resources: sites.map((site) => ({ id: site.siteUrl, label: site.permissionLevel }))
   });
 }
-var sitesCommand = defineCommand126({
+var sitesCommand = defineCommand127({
   meta: {
     name: "sites",
     description: `List verified Search Console sites.
@@ -37077,7 +37899,7 @@ Examples:
 });
 
 // src/commands/gsc/index.ts
-var gscCommand = defineCommand127({
+var gscCommand = defineCommand128({
   meta: {
     name: "gsc",
     description: `Google Search Console commands. PPC-SEO arbitrage, brand halo analysis, negative keyword discovery.
@@ -37101,7 +37923,7 @@ Full guide: __tooling__/docs/tools/baker/gsc.md`
 });
 
 // src/commands/history/index.ts
-import { defineCommand as defineCommand128 } from "citty";
+import { defineCommand as defineCommand129 } from "citty";
 registerSchema({
   command: "history.list",
   description: "Start here: unified account history (audit log) \u2014 everything that changed on this account, newest first: publishes, chat lifecycle, backlog actions, team changes, setup links, tags, schedules, ad-platform writes, followed advertisers, media, creatives, reports, domains, and integrations. Use it to see what happened recently before planning work. Compact by default; add --full for raw metadata per entry.",
@@ -37156,7 +37978,7 @@ function parseBoundedInt2(raw, name, min, max) {
   }
   return value;
 }
-var listCommand13 = defineCommand128({
+var listCommand13 = defineCommand129({
   meta: {
     name: "list",
     description: "List recent account changes (unified audit log), newest first."
@@ -37202,7 +38024,7 @@ var listCommand13 = defineCommand128({
     }
   }
 });
-var historyCommand = defineCommand128({
+var historyCommand = defineCommand129({
   meta: {
     name: "history",
     description: `Unified account history (audit log): what changed, who did it, and when.
@@ -37212,7 +38034,7 @@ Full guide: __tooling__/docs/tools/baker/history.md`
 });
 
 // src/commands/hubspot/index.ts
-import { defineCommand as defineCommand129 } from "citty";
+import { defineCommand as defineCommand130 } from "citty";
 var EMBED_TYPES = ["legacy", "v4", "unknown"];
 function failNotConnected(err) {
   if (err instanceof ApiError && err.code === "FORBIDDEN" && err.message.includes(HUBSPOT_MISSING_GRANT_MARKER)) {
@@ -37366,7 +38188,7 @@ registerSchema({
     }
   }
 });
-var formsListCommand = defineCommand129({
+var formsListCommand = defineCommand130({
   meta: {
     name: "list",
     description: "List HubSpot forms with embed type and post-submit action. Example: baker hubspot forms list --redirecting-only"
@@ -37411,7 +38233,7 @@ var formsListCommand = defineCommand129({
     }
   }
 });
-var formsViewCommand = defineCommand129({
+var formsViewCommand = defineCommand130({
   meta: {
     name: "view",
     description: "Show one HubSpot form's fields and configuration. Example: baker hubspot forms view 1a2b3c"
@@ -37463,7 +38285,7 @@ var formsViewCommand = defineCommand129({
     }
   }
 });
-var meetingsListCommand = defineCommand129({
+var meetingsListCommand = defineCommand130({
   meta: {
     name: "list",
     description: "List HubSpot meeting links (calendars). Example: baker hubspot meetings list"
@@ -37505,7 +38327,7 @@ var meetingsListCommand = defineCommand129({
     }
   }
 });
-var meetingsViewCommand = defineCommand129({
+var meetingsViewCommand = defineCommand130({
   meta: {
     name: "view",
     description: "Show one HubSpot meeting link's booking fields. Example: baker hubspot meetings view discovery-call"
@@ -37549,7 +38371,7 @@ var meetingsViewCommand = defineCommand129({
     }
   }
 });
-var formsSubmissionsCommand = defineCommand129({
+var formsSubmissionsCommand = defineCommand130({
   meta: {
     name: "submissions",
     description: "How many leads a form received, and when. Example: baker hubspot forms submissions <formId> --days 30"
@@ -37598,7 +38420,7 @@ var formsSubmissionsCommand = defineCommand129({
     }
   }
 });
-var workflowsListCommand = defineCommand129({
+var workflowsListCommand = defineCommand130({
   meta: {
     name: "list",
     description: "List HubSpot workflows. Example: baker hubspot workflows list --enabled-only"
@@ -37663,7 +38485,7 @@ function workflowViewHints(workflow) {
   }
   return hints;
 }
-var workflowsViewCommand = defineCommand129({
+var workflowsViewCommand = defineCommand130({
   meta: {
     name: "view",
     description: "Read one workflow's real configuration \u2014 enrolment, branches in order, and what each step writes. Example: baker hubspot workflows view 121183594 --full"
@@ -37690,7 +38512,7 @@ var workflowsViewCommand = defineCommand129({
     }
   }
 });
-var pipelinesListCommand = defineCommand129({
+var pipelinesListCommand = defineCommand130({
   meta: {
     name: "list",
     description: "List HubSpot deal pipelines and their stages. Example: baker hubspot pipelines list"
@@ -37707,7 +38529,7 @@ var pipelinesListCommand = defineCommand129({
     }
   }
 });
-var contactsSummaryCommand = defineCommand129({
+var contactsSummaryCommand = defineCommand130({
   meta: {
     name: "summary",
     description: "Whether recent leads are being worked, as counts. Example: baker hubspot contacts summary --days 30"
@@ -37777,7 +38599,7 @@ function contactLookupHints(data) {
   }
   return hints;
 }
-var contactsLookupCommand = defineCommand129({
+var contactsLookupCommand = defineCommand130({
   meta: {
     name: "lookup",
     description: "Find one contact by email and see whether it was worked. Example: baker hubspot contacts lookup a@b.com"
@@ -37801,27 +38623,27 @@ var contactsLookupCommand = defineCommand129({
     }
   }
 });
-var contactsCommand = defineCommand129({
+var contactsCommand = defineCommand130({
   meta: { name: "contacts", description: "Contacts on the connected HubSpot account." },
   subCommands: { summary: contactsSummaryCommand, lookup: contactsLookupCommand }
 });
-var formsCommand = defineCommand129({
+var formsCommand = defineCommand130({
   meta: { name: "forms", description: "HubSpot forms on the connected account." },
   subCommands: { list: formsListCommand, view: formsViewCommand, submissions: formsSubmissionsCommand }
 });
-var workflowsCommand = defineCommand129({
+var workflowsCommand = defineCommand130({
   meta: { name: "workflows", description: "HubSpot workflows on the connected account." },
   subCommands: { list: workflowsListCommand, view: workflowsViewCommand }
 });
-var pipelinesCommand = defineCommand129({
+var pipelinesCommand = defineCommand130({
   meta: { name: "pipelines", description: "HubSpot deal pipelines on the connected account." },
   subCommands: { list: pipelinesListCommand }
 });
-var meetingsCommand = defineCommand129({
+var meetingsCommand = defineCommand130({
   meta: { name: "meetings", description: "HubSpot meeting links (calendars) on the connected account." },
   subCommands: { list: meetingsListCommand, view: meetingsViewCommand }
 });
-var hubspotCommand = defineCommand129({
+var hubspotCommand = defineCommand130({
   meta: {
     name: "hubspot",
     description: `Read the connected HubSpot account \u2014 forms, the leads they received, workflows, deal pipelines and
@@ -37859,10 +38681,10 @@ Full guide: __tooling__/docs/tools/baker/hubspot.md`
 });
 
 // src/commands/images/index.ts
-import { defineCommand as defineCommand155 } from "citty";
+import { defineCommand as defineCommand156 } from "citty";
 
 // src/commands/images/crop.ts
-import { defineCommand as defineCommand130 } from "citty";
+import { defineCommand as defineCommand131 } from "citty";
 
 // src/lib/image/crop-sprite.ts
 import sharp from "sharp";
@@ -37877,7 +38699,7 @@ function cropSprite(input, region) {
 
 // src/lib/image/io.ts
 import { randomBytes } from "crypto";
-import { glob as fsGlob, readFile as readFile20, rename, stat as stat4, writeFile as writeFile11 } from "fs/promises";
+import { glob as fsGlob, readFile as readFile21, rename, stat as stat5, writeFile as writeFile11 } from "fs/promises";
 import { dirname as dirname2, extname as extname2, join as join5, resolve as resolve4 } from "path";
 var REMOTE_RE = /^https?:\/\//i;
 var GLOB_RE = /[*?[\]{}]/;
@@ -37910,11 +38732,11 @@ async function readImageBuffer(pathOrUrl) {
     const { buffer } = await fetchExternalBytes(pathOrUrl, { maxBytes: MAX_REMOTE_IMAGE_BYTES });
     return buffer;
   }
-  return readFile20(pathOrUrl);
+  return readFile21(pathOrUrl);
 }
-async function isDirectory(path38) {
+async function isDirectory(path41) {
   try {
-    const s = await stat4(path38);
+    const s = await stat5(path41);
     return s.isDirectory();
   } catch {
     return false;
@@ -37984,7 +38806,7 @@ function emitError2(err) {
   }
   process.exit(1);
 }
-var cropCommand = defineCommand130({
+var cropCommand = defineCommand131({
   meta: {
     name: "crop",
     description: "Crop a rectangular region from an image.\n\nExample: baker images crop sprite.png --x 0 --y 0 --width 64 --height 64 --output icon.png"
@@ -38020,7 +38842,7 @@ var cropCommand = defineCommand130({
 });
 
 // src/commands/images/delete.ts
-import { defineCommand as defineCommand131 } from "citty";
+import { defineCommand as defineCommand132 } from "citty";
 registerSchema({
   command: "images.delete",
   description: "Delete an image by ID",
@@ -38034,7 +38856,7 @@ registerSchema({
     }
   }
 });
-var deleteCommand2 = defineCommand131({
+var deleteCommand2 = defineCommand132({
   meta: {
     name: "delete",
     description: "Delete an image by ID. Use --dry-run to preview. Example: baker images delete j571abc123 --dry-run"
@@ -38075,7 +38897,7 @@ var deleteCommand2 = defineCommand131({
 });
 
 // src/commands/images/dimensions.ts
-import { defineCommand as defineCommand132 } from "citty";
+import { defineCommand as defineCommand133 } from "citty";
 
 // src/lib/image/dimensions.ts
 import { imageSize } from "image-size";
@@ -38104,7 +38926,7 @@ registerSchema({
     }
   }
 });
-var dimensionsCommand = defineCommand132({
+var dimensionsCommand = defineCommand133({
   meta: {
     name: "dimensions",
     description: "Read image dimensions without decoding the full file.\n\nExample: baker images dimensions ./logo.png\nExample: baker images dimensions https://acme.com/hero.png"
@@ -38160,7 +38982,7 @@ var dimensionsCommand = defineCommand132({
 });
 
 // src/commands/images/download.ts
-import { defineCommand as defineCommand133 } from "citty";
+import { defineCommand as defineCommand134 } from "citty";
 
 // src/commands/images/downloadPaths.ts
 import { basename as basename2, extname as extname3, join as join6 } from "path";
@@ -38216,13 +39038,13 @@ function resolveDownloadPath({ baseName, extension, out, outIsDirectory: outIsDi
 }
 function disambiguate(paths) {
   const taken = /* @__PURE__ */ new Set();
-  return paths.map((path38) => {
-    if (!taken.has(path38)) {
-      taken.add(path38);
-      return path38;
+  return paths.map((path41) => {
+    if (!taken.has(path41)) {
+      taken.add(path41);
+      return path41;
     }
-    const ext = extname3(path38);
-    const stem = path38.slice(0, path38.length - ext.length);
+    const ext = extname3(path41);
+    const stem = path41.slice(0, path41.length - ext.length);
     let n = 2;
     while (taken.has(`${stem}-${n}${ext}`)) n += 1;
     const unique = `${stem}-${n}${ext}`;
@@ -38349,10 +39171,10 @@ async function runDownloads(plan) {
   const paths = disambiguate(fetched.map((item) => item.path));
   const downloaded = [];
   for (const [index, item] of fetched.entries()) {
-    const path38 = paths[index] ?? item.path;
+    const path41 = paths[index] ?? item.path;
     try {
-      await atomicWrite(path38, item.buffer);
-      downloaded.push({ input: item.input, output: path38, bytes: item.buffer.length, contentType: item.contentType });
+      await atomicWrite(path41, item.buffer);
+      downloaded.push({ input: item.input, output: path41, bytes: item.buffer.length, contentType: item.contentType });
     } catch (err) {
       failed.push({ input: item.input, error: failureMessage(err, "Write failed") });
     }
@@ -38385,7 +39207,7 @@ function emitError3(err) {
   writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
   process.exit(1);
 }
-var downloadCommand = defineCommand133({
+var downloadCommand = defineCommand134({
   meta: {
     name: "download",
     description: "Download image URLs and/or library images to local files \u2014 the missing first half of `source \u2192 download \u2192 normalize \u2192 place`. Never use `curl` for this.\n\nExamples:\n  baker images download https://media.withbaker.com/\u2026/logo.webp\n  baker images download j57abc123 j57def456 --out src/pages/pricing/_images/\n  baker images download https://\u2026/hero.png --out ./hero.png"
@@ -38418,7 +39240,7 @@ var downloadCommand = defineCommand133({
 });
 
 // src/commands/images/extract.ts
-import { defineCommand as defineCommand134 } from "citty";
+import { defineCommand as defineCommand135 } from "citty";
 
 // src/commands/images/autoIngest.ts
 var AUTO_INGEST_MAX = {
@@ -38465,7 +39287,7 @@ registerSchema({
     }
   }
 });
-var extractCommand = defineCommand134({
+var extractCommand = defineCommand135({
   meta: {
     name: "extract",
     description: "Pull every image from a single URL via Firecrawl. ~$0.001/scrape. Cap auto-ingest at 20.\n\nExample: baker images extract https://stripe.com --auto-ingest 5"
@@ -38520,7 +39342,7 @@ var extractCommand = defineCommand134({
 });
 
 // src/commands/images/find.ts
-import { defineCommand as defineCommand135 } from "citty";
+import { defineCommand as defineCommand136 } from "citty";
 
 // src/commands/images/providerHits.ts
 function asRecord3(value) {
@@ -38658,7 +39480,7 @@ registerSchema({
     full: { type: "boolean", description: "Include full metadata", required: false, default: false }
   }
 });
-var findCommand = defineCommand135({
+var findCommand = defineCommand136({
   meta: {
     name: "find",
     description: "Library-first fanout image search. Opt in to providers with --sources. `--fallback` short-circuits to externals only when library is thin. With --auto-ingest, ingested external hits return Baker-owned URLs.\n\nExample: baker images find 'office' --sources library,magnific --limit 20"
@@ -38731,7 +39553,7 @@ var findCommand = defineCommand135({
 });
 
 // src/commands/images/get.ts
-import { defineCommand as defineCommand136 } from "citty";
+import { defineCommand as defineCommand137 } from "citty";
 registerSchema({
   command: "images.get",
   description: "Get a single image by ID",
@@ -38739,7 +39561,7 @@ registerSchema({
     id: { type: "string", description: "Image ID", required: true }
   }
 });
-var getCommand3 = defineCommand136({
+var getCommand3 = defineCommand137({
   meta: { name: "get", description: "Get a single image by ID. Example: baker images get j571abc123" },
   args: {
     id: { type: "positional", description: "Image ID", required: false },
@@ -38775,7 +39597,7 @@ var getCommand3 = defineCommand136({
 });
 
 // src/commands/images/gif.ts
-import { defineCommand as defineCommand137 } from "citty";
+import { defineCommand as defineCommand138 } from "citty";
 registerSchema({
   command: "images.gif",
   description: "Search Giphy for GIFs / reaction memes (paid social creative).",
@@ -38807,7 +39629,7 @@ registerSchema({
     }
   }
 });
-var gifCommand = defineCommand137({
+var gifCommand = defineCommand138({
   meta: {
     name: "gif",
     description: "Search Giphy for GIFs / reaction memes \u2014 built for paid-social creative (Meta, TikTok, LinkedIn, X). Free API. Each hit carries WebP + GIF + MP4 URLs in providerMeta so you can pick the right format per platform.\n\nExample: baker images gif 'this is fine' --limit 10\nExample: baker images gif 'office reaction' --rating pg --auto-ingest 2\nExample: baker images gif --trending --limit 25"
@@ -38854,7 +39676,7 @@ var gifCommand = defineCommand137({
 });
 
 // src/commands/images/google.ts
-import { defineCommand as defineCommand138 } from "citty";
+import { defineCommand as defineCommand139 } from "citty";
 var GOOGLE_ERROR_FIX = {
   action: "use_different_resource",
   explanation: "Generate the asset instead of retrying Google. Google is the last-resort image provider. Run `baker studio generate` to make the asset. Never sleep-and-retry this command \u2014 the CLI already backs off on rate limits. If no image can be sourced, continue the rest of the task with a placeholder rather than aborting it."
@@ -38894,7 +39716,7 @@ registerSchema({
     }
   }
 });
-var googleCommand2 = defineCommand138({
+var googleCommand2 = defineCommand139({
   meta: {
     name: "google",
     description: "Google Images via the official Custom Search JSON API ($0.005/query, free 100/day). \u26A0 Source unverified \u2014 watermarks, low-res, mislabeled results are common. Use as last resort. With --auto-ingest, ingested hits return Baker-owned URLs.\n\nExample: baker images google 'industrial workshop' --type photo --size large --limit 20"
@@ -38967,7 +39789,7 @@ var googleCommand2 = defineCommand138({
 });
 
 // src/commands/images/group.ts
-import { defineCommand as defineCommand139 } from "citty";
+import { defineCommand as defineCommand140 } from "citty";
 
 // src/commands/mediaGroup.ts
 async function runMediaGroupLookup(input) {
@@ -39020,7 +39842,7 @@ registerSchema({
     "group-key": { type: "string", description: "The set key directly, when you already have it", required: false }
   }
 });
-var groupCommand = defineCommand139({
+var groupCommand = defineCommand140({
   meta: {
     name: "group",
     description: "List every asset that arrived in the same set \u2014 the slides of one Instagram carousel, the images off one scraped page. Start here whenever a hit looks like part of a sequence: carousel slides are authored to be read in order and usually only make sense together. Takes an image or a video id, since one carousel can contain both. Example: baker images group <imageId>"
@@ -39040,7 +39862,7 @@ var groupCommand = defineCommand139({
 });
 
 // src/commands/images/icon.ts
-import { defineCommand as defineCommand140 } from "citty";
+import { defineCommand as defineCommand141 } from "citty";
 
 // src/commands/images/brandVerification.ts
 function brandToken(domain) {
@@ -39137,7 +39959,7 @@ registerSchema({
     full: { type: "boolean", description: "Include full metadata", required: false, default: false }
   }
 });
-var iconCommand = defineCommand140({
+var iconCommand = defineCommand141({
   meta: {
     name: "icon",
     description: "Icon via Iconify (simple-icons, logos, lucide, devicon, heroicons, tabler, phosphor, material-symbols, \u2026). Free CDN, no API key.\n\nExample: baker images icon react --set devicon\nExample: baker images icon lucide:check --color '#0a0a0a'"
@@ -39207,7 +40029,7 @@ var iconCommand = defineCommand140({
 });
 
 // src/commands/images/ingest.ts
-import { defineCommand as defineCommand141 } from "citty";
+import { defineCommand as defineCommand142 } from "citty";
 var SOURCE_VALUES = imageSourceSchema.options.join(" | ");
 registerSchema({
   command: "images.ingest",
@@ -39222,7 +40044,7 @@ registerSchema({
     fields: { type: "string", description: "Comma-separated field names to include", required: false }
   }
 });
-var ingestCommand = defineCommand141({
+var ingestCommand = defineCommand142({
   meta: {
     name: "ingest",
     description: "Download a remote URL and store it in the library. Hash-deduped on bytes + externalId.\n\nExample: baker images ingest https://img.freepik.com/free-photo/xyz.jpg --source magnific --external-id 12345"
@@ -39291,7 +40113,7 @@ var ingestCommand = defineCommand141({
 });
 
 // src/commands/images/layerize.ts
-import { defineCommand as defineCommand142 } from "citty";
+import { defineCommand as defineCommand143 } from "citty";
 registerSchema({
   command: "images.layerize",
   description: "Split a library image into editable layers: transparent PNG cutouts for each element, plus any headline recovered as EDITABLE TEXT with its font, size, colour and position. Waits for completion by default. Costs credits.",
@@ -39355,7 +40177,7 @@ async function pollUntilSettled(imageId, maxWait) {
   }
   return null;
 }
-var layerizeCommand = defineCommand142({
+var layerizeCommand = defineCommand143({
   meta: {
     name: "layerize",
     description: "Split a library image into editable layers \u2014 transparent cutouts per element, plus any baked-in headline recovered as editable text with its typography.\n\nStart here: baker images layerize j571abc123def\nExample: baker images layerize j571abc123def --full\nExample: baker images layerize j571abc123def --instructions 'keep the product and its shadow together'"
@@ -39424,7 +40246,7 @@ registerSchema({
     full: { type: "boolean", description: "Include geometry and typography for every layer", required: false }
   }
 });
-var layersCommand = defineCommand142({
+var layersCommand = defineCommand143({
   meta: {
     name: "layers",
     description: "Read the layers of an image that has already been split. Free \u2014 no provider call.\n\nStart here: baker images layers j571abc123def\nExample: baker images layers j571abc123def --full"
@@ -39464,7 +40286,7 @@ var layersCommand = defineCommand142({
 });
 
 // src/commands/images/library.ts
-import { defineCommand as defineCommand143 } from "citty";
+import { defineCommand as defineCommand144 } from "citty";
 registerSchema({
   command: "images.library",
   description: "Search the company image library. Returns only ready images.",
@@ -39490,7 +40312,7 @@ registerSchema({
     }
   }
 });
-var libraryCommand = defineCommand143({
+var libraryCommand = defineCommand144({
   meta: {
     name: "library",
     description: "Search the company image library (hybrid BM25 + vector + Cohere rerank). Use this BEFORE any external provider.\n\nExample: baker images library 'hero banner' --aspect-ratio 16:9 --source magnific"
@@ -39553,7 +40375,7 @@ var libraryCommand = defineCommand143({
 });
 
 // src/commands/images/logo.ts
-import { defineCommand as defineCommand144 } from "citty";
+import { defineCommand as defineCommand145 } from "citty";
 registerSchema({
   command: "images.logo",
   description: "Brand logo lookup via Brandfetch. Auto-ingests by default. Returns `brandMatch` \u2014 Brandfetch's own verdict on whose brand the domain is (confirmed | mismatch | unverified). Branch on it: `mismatch` means the mark is another company's, so do not place it. `confirmed` verifies the record, not the artwork \u2014 read the ingested row back to check the mark itself.",
@@ -39581,7 +40403,7 @@ registerSchema({
     full: { type: "boolean", description: "Include full metadata", required: false, default: false }
   }
 });
-var logoCommand = defineCommand144({
+var logoCommand = defineCommand145({
   meta: {
     name: "logo",
     description: "Brand logo via Brandfetch. Returns up to 5 variants (icon, light/dark logo, light/dark symbol) plus `brandMatch`. Auto-ingests the first variant.\n\nStart here: check `brandMatch.verdict`.\n  mismatch   \u2192 the mark belongs to `brandMatch.name`, a different company. Do not place it.\n  unverified \u2192 nothing confirmed whose logo this is. Treat as unchecked.\n  confirmed  \u2192 Brandfetch has this brand's record. That verifies the record, NOT the artwork \u2014 a confirmed domain has served another company's logo before.\n\n\u26A0 Whatever the verdict, read the ingested row back with `baker images get <imageId>` and check `textInImage`/`subject` before placing it. That is the only check that looks at the mark.\n\nExample: baker images logo stripe.com --variant logo"
@@ -39654,7 +40476,7 @@ var logoCommand = defineCommand144({
 });
 
 // src/commands/images/normalize.ts
-import { defineCommand as defineCommand145 } from "citty";
+import { defineCommand as defineCommand146 } from "citty";
 
 // src/lib/image/color-changer.ts
 import quantize from "quantize";
@@ -40386,7 +41208,7 @@ function coerceRawArgs(args) {
     "dry-run": bool(args["dry-run"])
   };
 }
-var normalizeCommand2 = defineCommand145({
+var normalizeCommand2 = defineCommand146({
   meta: {
     name: "normalize",
     description: `Normalize logos / images: declarative recolor + bg removal + trim + resize. Operates on local files; writes in-place by default.
@@ -40441,7 +41263,7 @@ Examples:
 });
 
 // src/commands/images/pinterest.ts
-import { defineCommand as defineCommand146 } from "citty";
+import { defineCommand as defineCommand147 } from "citty";
 registerSchema({
   command: "images.pinterest",
   description: "Pinterest image search via ScrapeCreators. Reference-grade real-world photography, product styling, interiors, fashion, food, and aesthetic mood boards. Inspect before placing \u2014 Pinterest is unverified, trademark-bearing web content.",
@@ -40461,7 +41283,7 @@ registerSchema({
     }
   }
 });
-var pinterestCommand = defineCommand146({
+var pinterestCommand = defineCommand147({
   meta: {
     name: "pinterest",
     description: "Pinterest image search via ScrapeCreators ($0.00188/request). Best for photo-realistic reference imagery \u2014 lifestyle, interiors, fashion, food, product styling, and mood boards to brief AI generation against. \u26A0 Unverified, trademark-bearing web content \u2014 inspect and respect rights before placing on a customer page. Browse first; auto-ingest only the pins you commit to.\n\nExamples:\n  baker images pinterest 'scandinavian living room'\n  baker images pinterest 'minimalist skincare product photography' --limit 20\n  baker images pinterest 'cozy coffee shop interior' --auto-ingest 2 --context 'Mood reference for hero photography'"
@@ -40518,7 +41340,7 @@ var pinterestCommand = defineCommand146({
 });
 
 // src/commands/images/screenshot.ts
-import { defineCommand as defineCommand147 } from "citty";
+import { defineCommand as defineCommand148 } from "citty";
 registerSchema({
   command: "images.screenshot",
   description: "Capture a website screenshot via ScreenshotOne. Auto-ingests on success.",
@@ -40537,7 +41359,7 @@ registerSchema({
     full: { type: "boolean", description: "Include full metadata", required: false, default: false }
   }
 });
-var screenshotCommand = defineCommand147({
+var screenshotCommand = defineCommand148({
   meta: {
     name: "screenshot",
     description: "Screenshot a URL via ScreenshotOne. $0.009/capture. Auto-ingests to library.\n\nExample: baker images screenshot https://stripe.com --full-page"
@@ -40601,7 +41423,7 @@ var screenshotCommand = defineCommand147({
 });
 
 // src/commands/images/search.ts
-import { defineCommand as defineCommand148 } from "citty";
+import { defineCommand as defineCommand149 } from "citty";
 registerSchema({
   command: "images.search",
   description: "Search images by text query. Only returns ready images.",
@@ -40617,7 +41439,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand = defineCommand148({
+var searchCommand = defineCommand149({
   meta: {
     name: "search",
     description: "Semantic search images by text query. Uses hybrid BM25 + vector + reranking. Example: baker images search 'hero banner' --aspect-ratio 16:9 --tags logo"
@@ -40677,7 +41499,7 @@ var searchCommand = defineCommand148({
 });
 
 // src/commands/images/sticker.ts
-import { defineCommand as defineCommand149 } from "citty";
+import { defineCommand as defineCommand150 } from "citty";
 registerSchema({
   command: "images.sticker",
   description: "Search Giphy stickers \u2014 transparent-background overlays for ad creative.",
@@ -40709,7 +41531,7 @@ registerSchema({
     }
   }
 });
-var stickerCommand = defineCommand149({
+var stickerCommand = defineCommand150({
   meta: {
     name: "sticker",
     description: "Search Giphy's sticker corpus \u2014 transparent-background WebPs / GIFs ideal for overlaying on ad creative (Meta, TikTok, Stories). Same Giphy free API as `baker images gif`; results carry WebP + GIF + MP4 URLs in providerMeta.\n\nExample: baker images sticker 'thumbs up' --limit 10\nExample: baker images sticker celebration --rating g --auto-ingest 3\nExample: baker images sticker --trending --limit 25"
@@ -40756,7 +41578,7 @@ var stickerCommand = defineCommand149({
 });
 
 // src/commands/images/stock.ts
-import { defineCommand as defineCommand150 } from "citty";
+import { defineCommand as defineCommand151 } from "citty";
 var STOCK_ERROR_FIX = {
   action: "use_different_resource",
   explanation: "Switch provider instead of retrying stock search. Stock search is one of several image sources. Run `baker images find <query> --sources library,pinterest,google` (`--sources` is required \u2014 `find` alone searches the library only) or `baker studio generate` to make the asset. Never sleep-and-retry this command \u2014 the CLI already backs off on rate limits. If no image can be sourced, continue the rest of the task with a placeholder rather than aborting it."
@@ -40833,7 +41655,7 @@ function buildStockRequest(query, args) {
   if (args.context) body.descriptionContext = args.context;
   return body;
 }
-var stockCommand = defineCommand150({
+var stockCommand = defineCommand151({
   meta: {
     name: "stock",
     description: "Stock search via Magnific \u2014 Freepik's developer API (~250M assets: photos, vectors, illustrations, icons, PSDs). $0.002/req. With --auto-ingest, ingested hits return Baker-owned URLs.\n\nExamples:\n  baker images stock 'minimalist office'\n  baker images stock 'flat office workers' --type vector\n  baker images stock 'hero photo of a kitchen' --type photo --orientation landscape --ai exclude\n  baker images stock 'brand pattern' --color '#0a0a0a' --license freemium --auto-ingest 2"
@@ -40906,7 +41728,7 @@ var stockCommand = defineCommand150({
 });
 
 // src/lib/tags-command.ts
-import { defineCommand as defineCommand151 } from "citty";
+import { defineCommand as defineCommand152 } from "citty";
 function makeTagsCommand(command, label, endpoint) {
   registerSchema({
     command: `${command}.tags`,
@@ -40915,7 +41737,7 @@ function makeTagsCommand(command, label, endpoint) {
       output: { type: "string", description: "Output format: md|json", required: false, default: "md" }
     }
   });
-  return defineCommand151({
+  return defineCommand152({
     meta: {
       name: "tags",
       description: `List the available ${label} tag names (defaults + company custom tags). Use before filtering with --tags. Example: baker ${command} tags`
@@ -40951,7 +41773,7 @@ function makeTagsCommand(command, label, endpoint) {
 var tagsCommand3 = makeTagsCommand("images", "image", "/api/images/tags");
 
 // src/commands/images/upload.ts
-import { defineCommand as defineCommand152 } from "citty";
+import { defineCommand as defineCommand153 } from "citty";
 registerSchema({
   command: "images.upload",
   description: "Upload an image to the library \u2014 local file path or remote http(s) URL.",
@@ -40989,7 +41811,7 @@ registerSchema({
 function isRemoteUrl2(value) {
   return /^https?:\/\//i.test(value);
 }
-var uploadCommand = defineCommand152({
+var uploadCommand = defineCommand153({
   meta: {
     name: "upload",
     description: "Upload an image to the library \u2014 accepts a local file path OR a remote http(s) URL.\n\nLocal: reads bytes, sends to /api/images/upload, content-type auto-detected from extension.\nRemote: dispatches to /api/images/ingest with hash-dedup on bytes + externalId.\n\nExamples:\n  baker images upload ./logo.png --source uploaded\n  baker images upload ./cert.png --context 'ISO 27001 badge \u2014 enterprise tier'\n  baker images upload https://acme.com/hero.png --source firecrawl --context 'Acme competitor pricing hero'"
@@ -41082,7 +41904,7 @@ async function uploadLocal(target, args) {
 }
 
 // src/commands/images/upscale.ts
-import { defineCommand as defineCommand153 } from "citty";
+import { defineCommand as defineCommand154 } from "citty";
 registerSchema({
   command: "images.upscale",
   description: "Upscale a library image via the backend (Replicate, cost-tracked). Waits for completion by default. The image must be status 'ready' and raster (not SVG/AVIF).",
@@ -41097,7 +41919,7 @@ registerSchema({
   }
 });
 var POLL_INTERVAL_MS4 = 1500;
-var upscaleCommand = defineCommand153({
+var upscaleCommand = defineCommand154({
   meta: {
     name: "upscale",
     description: "Upscale a library image via the Convex backend (Replicate, cost-tracked at $0.05/image). Waits for completion by default.\n\nExample: baker images upscale j571abc123def\nExample: baker images upscale j571abc123def --max-wait 0   # fire-and-forget"
@@ -41152,7 +41974,7 @@ var upscaleCommand = defineCommand153({
 });
 
 // src/commands/images/use.ts
-import { defineCommand as defineCommand154 } from "citty";
+import { defineCommand as defineCommand155 } from "citty";
 registerSchema({
   command: "images.use",
   description: "Ingest a URL and wait for the library record to be ready.",
@@ -41181,7 +42003,7 @@ function emitReady(ingestResult, doc, args) {
     args.full === true
   );
 }
-var useCommand = defineCommand154({
+var useCommand = defineCommand155({
   meta: {
     name: "use",
     description: "Sugar over `ingest`: download \u2192 store \u2192 wait until describe + embed complete \u2192 return ready library record.\n\nExample: baker images use https://cdn.example.com/hero.png --source uploaded"
@@ -41230,7 +42052,7 @@ var useCommand = defineCommand154({
 });
 
 // src/commands/images/index.ts
-var imagesCommand = defineCommand155({
+var imagesCommand = defineCommand156({
   meta: {
     name: "images",
     description: `Find, source, and normalize images. Subcommands route by provider so cost + license are explicit.
@@ -41308,12 +42130,12 @@ Full guide: __tooling__/docs/tools/baker/images.md`
 });
 
 // src/commands/landing/index.ts
-import { defineCommand as defineCommand166 } from "citty";
+import { defineCommand as defineCommand168 } from "citty";
 
 // src/commands/landing/critique.ts
 import { readdir as readdir9, stat as stat6 } from "fs/promises";
-import path28 from "path";
-import { defineCommand as defineCommand156 } from "citty";
+import path29 from "path";
+import { defineCommand as defineCommand157 } from "citty";
 
 // src/engine/landing/lib/constants.ts
 var OVERUSED_FONTS = /* @__PURE__ */ new Set([
@@ -42280,13 +43102,13 @@ function describeCounts(findings) {
 
 // src/commands/landing/snapshot.ts
 import { mkdir as mkdir8, rename as rename2, writeFile as writeFile12 } from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 var CRITIC_VERSION = "2";
 function critiqueCacheDir(projectRoot) {
-  return path26.join(projectRoot, ".cache", "landing-critique");
+  return path27.join(projectRoot, ".cache", "landing-critique");
 }
 function snapshotPath(projectRoot, slug) {
-  return path26.join(critiqueCacheDir(projectRoot), `${slug}.json`);
+  return path27.join(critiqueCacheDir(projectRoot), `${slug}.json`);
 }
 async function writeCritiqueSnapshot(projectRoot, snapshot) {
   await mkdir8(critiqueCacheDir(projectRoot), { recursive: true });
@@ -42298,30 +43120,26 @@ async function writeCritiqueSnapshot(projectRoot, snapshot) {
 }
 
 // src/commands/landing/source-version.ts
-import { readdir as readdir8, readFile as readFile21, stat as stat5 } from "fs/promises";
-import path27 from "path";
-async function landingSourceRelPaths(landingDir) {
-  const rel = [];
-  if (await isFile(path27.join(landingDir, "index.astro"))) rel.push("index.astro");
-  const componentsDir = path27.join(landingDir, "_components");
-  for (const abs of await walkAstro(componentsDir)) {
-    rel.push(path27.relative(landingDir, abs).split(path27.sep).join("/"));
-  }
-  return rel.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+import { readFile as readFile22 } from "fs/promises";
+import path28 from "path";
+var CRITIQUED_ROOTS = ["src/pages/", "src/components/"];
+async function landingSourceRelPaths(root, slug) {
+  const files = await landingGraphFiles(root, slug);
+  return [...files].filter((rel) => rel.endsWith(".astro") && CRITIQUED_ROOTS.some((r) => rel.startsWith(r))).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
 }
-async function readLandingSources(landingDir) {
-  const rel = await landingSourceRelPaths(landingDir);
+async function readLandingSources(root, slug) {
+  const rel = await landingSourceRelPaths(root, slug);
   const out = [];
-  for (const r of rel) out.push({ path: r, text: await readFile21(path27.join(landingDir, r), "utf8") });
+  for (const r of rel) out.push({ path: r, text: await readFile22(path28.join(root, r), "utf8") });
   return out;
 }
-async function computeLandingSourceSha(landingDir) {
-  const rel = await landingSourceRelPaths(landingDir);
+async function computeLandingSourceSha(root, slug) {
+  const rel = await landingSourceRelPaths(root, slug);
   const parts = [];
   for (const r of rel) {
     let bytes;
     try {
-      bytes = await readFile21(path27.join(landingDir, r));
+      bytes = await readFile22(path28.join(root, r));
     } catch {
       bytes = Buffer.alloc(0);
     }
@@ -42329,28 +43147,6 @@ async function computeLandingSourceSha(landingDir) {
   }
   return sha256Hex(Buffer.concat(parts));
 }
-async function isFile(p) {
-  try {
-    return (await stat5(p)).isFile();
-  } catch {
-    return false;
-  }
-}
-async function walkAstro(dir) {
-  let entries;
-  try {
-    entries = await readdir8(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const entry of entries) {
-    const abs = path27.join(dir, entry.name);
-    if (entry.isDirectory()) out.push(...await walkAstro(abs));
-    else if (entry.isFile() && entry.name.endsWith(".astro")) out.push(abs);
-  }
-  return out;
-}
 
 // src/commands/landing/critique.ts
 registerSchema({
@@ -42375,14 +43171,14 @@ function parseCritiqueSlugs(args) {
   const all = [args.slug, ...rest].filter((s) => typeof s === "string" && s.length > 0);
   return [...new Set(all.map(String))];
 }
-function fail5(code, message, fix) {
+function fail6(code, message, fix) {
   process.stderr.write(
     `${JSON.stringify({ ok: false, error: { code, message, ...fix ? { fix } : {} } }, null, 2)}
 `
   );
   process.exit(2);
 }
-var critiqueCommand2 = defineCommand156({
+var critiqueCommand2 = defineCommand157({
   meta: {
     name: "critique",
     description: "Start here: `baker landing critique <slug>` after building or editing a landing. Deterministic design-quality critic (ADVISORY \u2014 findings never fail it). Flags the known AI design tells (gradient text, overused fonts, side-tab borders, cream palettes, buzzword copy, broken images) tiered block/warn/advisory, respecting the client's BRAND.md as the allowlist. Also records the critique that publishing requires \u2014 run it before finishing a landing."
@@ -42400,14 +43196,14 @@ var critiqueCommand2 = defineCommand156({
     const projectRoot = process.cwd();
     for (const slug of slugs) {
       if (!SLUG_RE.test(slug) || slug.includes("..")) {
-        fail5(
+        fail6(
           "INVALID_SLUG",
           `"${slug}" is not a landing slug \u2014 use the folder name directly under src/pages/ (letters, digits, dashes; not a path, not a _-private folder).`,
           { availableSlugs: await listLandingSlugs(projectRoot) }
         );
       }
-      if (!await isDir(path28.resolve(projectRoot, "src", "pages", slug))) {
-        fail5("NOT_FOUND", `No landing at src/pages/${slug}/`, {
+      if (!await isDir(path29.resolve(projectRoot, "src", "pages", slug))) {
+        fail6("NOT_FOUND", `No landing at src/pages/${slug}/`, {
           availableSlugs: await listLandingSlugs(projectRoot)
         });
       }
@@ -42445,8 +43241,10 @@ var critiqueCommand2 = defineCommand156({
   }
 });
 async function critiqueOne(projectRoot, slug, brand) {
-  const landingDir = path28.resolve(projectRoot, "src", "pages", slug);
-  const [sources, sourceSha] = await Promise.all([readLandingSources(landingDir), computeLandingSourceSha(landingDir)]);
+  const [sources, sourceSha] = await Promise.all([
+    readLandingSources(projectRoot, slug),
+    computeLandingSourceSha(projectRoot, slug)
+  ]);
   const report = critiqueLanding({ slug, sources, brand });
   let snapshotFailed = false;
   try {
@@ -42465,7 +43263,7 @@ async function critiqueOne(projectRoot, slug, brand) {
 }
 async function listLandingSlugs(projectRoot) {
   try {
-    const entries = await readdir9(path28.join(projectRoot, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir9(path29.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 [];
@@ -42491,10 +43289,10 @@ async function isDir(p) {
 }
 
 // src/commands/landing/inspiration/index.ts
-import { defineCommand as defineCommand165 } from "citty";
+import { defineCommand as defineCommand166 } from "citty";
 
 // src/commands/landing/inspiration/add.ts
-import { defineCommand as defineCommand157 } from "citty";
+import { defineCommand as defineCommand158 } from "citty";
 
 // src/commands/landing/inspiration/shared.ts
 var INSPIRATION_HINTS = {
@@ -42576,7 +43374,7 @@ registerSchema({
     note: { type: "string", description: "Why this page is worth keeping", required: false }
   }
 });
-var addCommand = defineCommand157({
+var addCommand = defineCommand158({
   meta: {
     name: "add",
     description: "Add someone else's landing page to the reference library. Example: baker landing inspiration add https://linear.app --note 'the client likes this density'"
@@ -42617,8 +43415,8 @@ var addCommand = defineCommand157({
 
 // src/commands/landing/inspiration/code.ts
 import { mkdir as mkdir9, writeFile as writeFile13 } from "fs/promises";
-import path29 from "path";
-import { defineCommand as defineCommand158 } from "citty";
+import path30 from "path";
+import { defineCommand as defineCommand159 } from "citty";
 registerSchema({
   command: "landing.inspiration.code",
   description: "Write a reference section's standalone HTML+CSS to .baker/inspiration/<id>/ so you can read how it is built. Reference only \u2014 the structure is the lesson, the words are not yours to reuse.",
@@ -42627,7 +43425,7 @@ registerSchema({
     full: { type: "boolean", description: "Print the markup inline as well as writing it", required: false }
   }
 });
-var codeCommand = defineCommand158({
+var codeCommand = defineCommand159({
   meta: {
     name: "code",
     description: "Write one reference section's standalone markup to disk. Example: baker landing inspiration code k57abc\u2026 \u2014 read it for structure, then build your own."
@@ -42640,9 +43438,9 @@ var codeCommand = defineCommand158({
     try {
       const id = args.id;
       const data = await apiGet("/api/landing-inspiration/section-code", { id });
-      const dir = path29.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path30.join(process.cwd(), ".baker", "inspiration", id);
       await mkdir9(dir, { recursive: true });
-      const file = path29.join(dir, "section.html");
+      const file = path30.join(dir, "section.html");
       await writeFile13(file, data.html);
       const hints = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
       const fidelity = fidelityHint(data.fidelity);
@@ -42652,7 +43450,7 @@ var codeCommand = defineCommand158({
         ok: true,
         data: {
           id,
-          file: path29.relative(process.cwd(), file),
+          file: path30.relative(process.cwd(), file),
           bytes: data.html.length,
           fidelity: data.fidelity,
           reproduction_notes: data.reproductionNotes,
@@ -42673,7 +43471,7 @@ var codeCommand = defineCommand158({
 });
 
 // src/commands/landing/inspiration/favorites.ts
-import { defineCommand as defineCommand159 } from "citty";
+import { defineCommand as defineCommand160 } from "citty";
 registerSchema({
   command: "landing.inspiration.favorites",
   description: "List the reference sections this company has saved. This is what `search` looks at by default, so it is the client's own taste profile \u2014 read it before proposing a direction.",
@@ -42687,7 +43485,7 @@ registerSchema({
     }
   }
 });
-var favoritesCommand = defineCommand159({
+var favoritesCommand = defineCommand160({
   meta: {
     name: "favorites",
     description: "List this company's saved reference sections. Example: baker landing inspiration favorites --type hero,pricing"
@@ -42767,7 +43565,7 @@ registerSchema({
     note: { type: "string", description: "Why this is worth keeping", required: false }
   }
 });
-var favoriteCommand = defineCommand159({
+var favoriteCommand = defineCommand160({
   meta: {
     name: "favorite",
     description: "Save a reference section to this company. Example: baker landing inspiration favorite k57abc\u2026"
@@ -42805,7 +43603,7 @@ registerSchema({
     page: { type: "boolean", description: "Treat the id as a page rather than a section", required: false }
   }
 });
-var unfavoriteCommand = defineCommand159({
+var unfavoriteCommand = defineCommand160({
   meta: {
     name: "unfavorite",
     description: "Remove a reference section from this company's saved set. Example: baker landing inspiration unfavorite k57abc\u2026"
@@ -42827,7 +43625,7 @@ var unfavoriteCommand = defineCommand159({
 });
 
 // src/commands/landing/inspiration/page.ts
-import { defineCommand as defineCommand160 } from "citty";
+import { defineCommand as defineCommand161 } from "citty";
 registerSchema({
   command: "landing.inspiration.page",
   description: "Show a whole reference page as a sequence: every section top to bottom with its type and the idea behind it. This is the view to use when the question is how a good page is ORDERED rather than what one section looks like.",
@@ -42844,7 +43642,7 @@ registerSchema({
     }
   }
 });
-var pageCommand2 = defineCommand160({
+var pageCommand2 = defineCommand161({
   meta: {
     name: "page",
     description: "Show how a reference page sequences its sections. Example: baker landing inspiration page j91xyz\u2026 \u2014 the blueprint, not the pixels."
@@ -42907,7 +43705,7 @@ var pageCommand2 = defineCommand160({
 });
 
 // src/commands/landing/inspiration/scrape.ts
-import { defineCommand as defineCommand161 } from "citty";
+import { defineCommand as defineCommand162 } from "citty";
 
 // src/engine/landing-library/proxyFailure.ts
 var PROXY_STATUS = 407;
@@ -43084,7 +43882,7 @@ function classifyCaptureFailure(error) {
 
 // src/engine/landing-library/run.ts
 import { mkdir as mkdir10, writeFile as writeFile15 } from "fs/promises";
-import path31 from "path";
+import path32 from "path";
 
 // ../proxy/src/preflight.ts
 import http from "http";
@@ -44500,9 +45298,9 @@ async function renderBundleToPng(browser, html, viewportWidth, options = {}) {
 
 // src/engine/landing-library/report.ts
 import { writeFile as writeFile14 } from "fs/promises";
-import path30 from "path";
+import path31 from "path";
 async function writeCaptureReport(manifest, outDir) {
-  const file = path30.join(outDir, "report.html");
+  const file = path31.join(outDir, "report.html");
   await writeFile14(file, renderReport(manifest));
   return file;
 }
@@ -44681,32 +45479,32 @@ async function reproducePage(args) {
   const { browser, page, outDir, pageUrl, livePageShot } = args;
   const built = await buildSectionBundle(page, "body", pageUrl).catch(() => null);
   if (!built) return { bundle: null, fidelity: null };
-  await writeFile15(path31.join(outDir, "page.html"), built.html);
+  await writeFile15(path32.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 writeFile15(path31.join(outDir, "page-rendered.png"), rendered);
+  await writeFile15(path32.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(args) {
   const { browser, page, candidate, sectionsDir, outDir, pageUrl, withCode } = args;
-  const dir = path31.join(sectionsDir, String(candidate.index).padStart(2, "0"));
+  const dir = path32.join(sectionsDir, String(candidate.index).padStart(2, "0"));
   await mkdir10(dir, { recursive: true });
   const desktop = await captureSection(page, candidate);
-  if (desktop) await writeFile15(path31.join(dir, "desktop.png"), desktop);
+  if (desktop) await writeFile15(path32.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 writeFile15(path31.join(dir, "section.html"), built.html);
+    await writeFile15(path32.join(dir, "section.html"), built.html);
     const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width);
     if (rendered && desktop) {
-      await writeFile15(path31.join(dir, "section-rendered.png"), rendered);
+      await writeFile15(path32.join(dir, "section-rendered.png"), rendered);
       const result = await scoreFidelity(desktop, rendered);
       fidelity = result.score;
       fidelityNote = result.note;
@@ -44714,9 +45512,9 @@ async function captureOneSection(args) {
   }
   return {
     ...candidate,
-    desktopShot: desktop ? path31.relative(outDir, path31.join(dir, "desktop.png")) : null,
+    desktopShot: desktop ? path32.relative(outDir, path32.join(dir, "desktop.png")) : null,
     mobileShot: null,
-    bundle: built ? path31.relative(outDir, path31.join(dir, "section.html")) : null,
+    bundle: built ? path32.relative(outDir, path32.join(dir, "section.html")) : null,
     fidelity,
     ...fidelityNote ? { fidelityNote } : {},
     ...built ? { cssStats: built.stats } : {},
@@ -44735,9 +45533,9 @@ async function captureMobileShots(args) {
     for (const section of sections) {
       const shot = await captureSectionOnMobile(mobile.page, section);
       if (!shot) continue;
-      const file = path31.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
+      const file = path32.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
       await writeFile15(file, shot);
-      section.mobileShot = path31.relative(outDir, file);
+      section.mobileShot = path32.relative(outDir, file);
     }
   } finally {
     await mobile.context.close();
@@ -44752,10 +45550,10 @@ async function captureMotionTakes(args) {
   const filmOne = async (section) => {
     const take = await captureMotionTake(browser, pageUrl, section.selector).catch(() => null);
     if (!take) return;
-    const dir = path31.join(sectionsDir, String(section.index).padStart(2, "0"));
-    const file = path31.join(dir, "motion-filmstrip.png");
+    const dir = path32.join(sectionsDir, String(section.index).padStart(2, "0"));
+    const file = path32.join(dir, "motion-filmstrip.png");
     await writeFile15(file, take.filmstrip);
-    section.motionFilmstrip = path31.relative(outDir, file);
+    section.motionFilmstrip = path32.relative(outDir, file);
     log(`  [${section.index}] ${section.motion.summary}`);
   };
   const queue = [...moving];
@@ -44812,7 +45610,7 @@ async function captureAlternateViews(args) {
 async function reproduceWholePage(args) {
   const { browser, page, outDir, pageUrl, withCode, log } = args;
   const fullPage = await page.screenshot({ type: "png", fullPage: true }).catch(() => null);
-  if (fullPage) await writeFile15(path31.join(outDir, "full-page.png"), fullPage);
+  if (fullPage) await writeFile15(path32.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)}`);
@@ -44883,7 +45681,7 @@ async function openViaLadder(args) {
 async function scrapeLanding(options) {
   const timeoutMs = options.timeoutMs ?? 45e3;
   const log = options.onProgress ?? (() => void 0);
-  const sectionsDir = path31.join(options.outDir, "sections");
+  const sectionsDir = path32.join(options.outDir, "sections");
   const nonPublic = refuseNonPublicUrl(options.url);
   if (nonPublic) {
     throw new BlockedPageError({
@@ -44945,7 +45743,7 @@ async function scrapeLanding(options) {
       security: prepared.security,
       captureTier: tier
     };
-    await writeFile15(path31.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile15(path32.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
     if (options.report !== false) {
       const reportPath = await writeCaptureReport(manifest, options.outDir);
@@ -44960,28 +45758,28 @@ async function scrapeLanding(options) {
 
 // src/commands/landing/inspiration/captureOut.ts
 import { existsSync as existsSync9 } from "fs";
-import path32 from "path";
+import path33 from "path";
 var SCRATCH_DIR = ".baker";
 function isWithin(parent, target) {
-  const relative = path32.relative(parent, target);
-  return relative === "" || !relative.startsWith("..") && !path32.isAbsolute(relative);
+  const relative = path33.relative(parent, target);
+  return relative === "" || !relative.startsWith("..") && !path33.isAbsolute(relative);
 }
 function findRepoRoot(from) {
-  let dir = path32.resolve(from);
+  let dir = path33.resolve(from);
   for (; ; ) {
-    if (existsSync9(path32.join(dir, ".git"))) return dir;
-    const parent = path32.dirname(dir);
+    if (existsSync9(path33.join(dir, ".git"))) return dir;
+    const parent = path33.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function checkCaptureOut(out, options) {
   const { cwd, repoRoot } = options;
-  const resolved = path32.resolve(cwd, out);
+  const resolved = path33.resolve(cwd, out);
   if (repoRoot === null || !isWithin(repoRoot, resolved)) return { ok: true };
-  const scratch = path32.join(repoRoot, SCRATCH_DIR);
+  const scratch = path33.join(repoRoot, SCRATCH_DIR);
   if (isWithin(scratch, resolved)) return { ok: true };
-  const suggestion = path32.posix.join(SCRATCH_DIR, "teardowns", path32.basename(resolved) || "capture");
+  const suggestion = path33.posix.join(SCRATCH_DIR, "teardowns", path33.basename(resolved) || "capture");
   return {
     ok: false,
     error: {
@@ -45047,7 +45845,7 @@ registerSchema({
     report: { type: "boolean", description: "Write report.html. `--no-report` to skip", required: false }
   }
 });
-var scrapeCommand = defineCommand161({
+var scrapeCommand = defineCommand162({
   meta: {
     name: "scrape",
     description: "Capture a landing page to a directory, now. Example: baker landing inspiration scrape https://linear.app --out .baker/inspiration/linear.app"
@@ -45155,12 +45953,12 @@ var scrapeCommand = defineCommand161({
 });
 
 // src/commands/landing/inspiration/search.ts
-import path34 from "path";
-import { defineCommand as defineCommand162 } from "citty";
+import path35 from "path";
+import { defineCommand as defineCommand163 } from "citty";
 
 // src/commands/landing/inspiration/shot.ts
 import { mkdir as mkdir11, writeFile as writeFile16 } from "fs/promises";
-import path33 from "path";
+import path34 from "path";
 import sharp6 from "sharp";
 var READABLE_SHOT = {
   maxWidth: 1440,
@@ -45186,9 +45984,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 mkdir11(path33.dirname(file), { recursive: true });
+    await mkdir11(path34.dirname(file), { recursive: true });
     await writeFile16(file, shot);
-    return path33.relative(process.cwd(), file);
+    return path34.relative(process.cwd(), file);
   } catch {
     return null;
   }
@@ -45280,20 +46078,20 @@ function buildSearchBody(args) {
   return body;
 }
 async function downloadShots(results) {
-  const dir = path34.join(process.cwd(), ".baker", "inspiration");
+  const dir = path35.join(process.cwd(), ".baker", "inspiration");
   const saved = /* @__PURE__ */ new Map();
   await Promise.all(
     results.map(async (result) => {
       const file = await downloadReadableShot(
         result.desktopShotUrl,
-        path34.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
+        path35.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
       );
       if (file) saved.set(result.id, file);
     })
   );
   return saved;
 }
-var searchCommand2 = defineCommand162({
+var searchCommand2 = defineCommand163({
   meta: {
     name: "search",
     description: "Search real landing-page sections for reference. Example: baker landing inspiration search 'dark developer hero with a terminal' --register dev-tool-minimal --scope all"
@@ -45391,7 +46189,7 @@ var searchCommand2 = defineCommand162({
 });
 
 // src/commands/landing/inspiration/sequences.ts
-import { defineCommand as defineCommand163 } from "citty";
+import { defineCommand as defineCommand164 } from "citty";
 var COMPACT_TRANSITIONS = 12;
 var COMPACT_ENDS = 5;
 var MAX_PAGES = 50;
@@ -45465,7 +46263,7 @@ function sequencesHints(data, { scope, full }) {
   if (scope === "favorites") hints.push(...favoritesScopeHints(data.favoritesHealth, data.pagesReturned));
   return hints;
 }
-var sequencesCommand = defineCommand163({
+var sequencesCommand = defineCommand164({
   meta: {
     name: "sequences",
     description: "What section follows what, across many real pages at once. Example: baker landing inspiration sequences 'developer tool pricing page' --scope all \u2014 the evidence for how to order a page you are about to build."
@@ -45514,8 +46312,8 @@ var sequencesCommand = defineCommand163({
 });
 
 // src/commands/landing/inspiration/view.ts
-import path35 from "path";
-import { defineCommand as defineCommand164 } from "citty";
+import path36 from "path";
+import { defineCommand as defineCommand165 } from "citty";
 registerSchema({
   command: "landing.inspiration.view",
   description: "Everything known about one section: composition, motion, design tokens, the copy it uses, why it works, and what must change to make it yours. Downloads the desktop and mobile screenshots plus the motion filmstrip so you can look at them.",
@@ -45528,7 +46326,7 @@ registerSchema({
     }
   }
 });
-var viewCommand2 = defineCommand164({
+var viewCommand2 = defineCommand165({
   meta: {
     name: "view",
     description: "Full detail for one reference section. Example: baker landing inspiration view k57abc\u2026 \u2014 read the screenshots it saves before you build."
@@ -45547,12 +46345,12 @@ var viewCommand2 = defineCommand164({
       const id = args.id;
       const data = await apiGet("/api/landing-inspiration/section", { id });
       const section = data.section;
-      const dir = path35.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path36.join(process.cwd(), ".baker", "inspiration", id);
       const ext = READABLE_SHOT.extension;
       const [desktop, mobile, filmstrip] = await Promise.all([
-        downloadReadableShot(section.desktopShotUrl, path35.join(dir, `desktop.${ext}`)),
-        downloadReadableShot(section.mobileShotUrl, path35.join(dir, `mobile.${ext}`)),
-        downloadReadableShot(section.motionFilmstripUrl, path35.join(dir, `motion-filmstrip.${ext}`))
+        downloadReadableShot(section.desktopShotUrl, path36.join(dir, `desktop.${ext}`)),
+        downloadReadableShot(section.mobileShotUrl, path36.join(dir, `mobile.${ext}`)),
+        downloadReadableShot(section.motionFilmstripUrl, path36.join(dir, `motion-filmstrip.${ext}`))
       ]);
       const full = args.full;
       const hints = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
@@ -45612,7 +46410,7 @@ var viewCommand2 = defineCommand164({
 });
 
 // src/commands/landing/inspiration/index.ts
-var inspirationCommand = defineCommand165({
+var inspirationCommand = defineCommand166({
   meta: {
     name: "inspiration",
     description: `Reference library of real landing-page sections \u2014 look at how good pages actually solve a problem before you design one.
@@ -45656,8 +46454,310 @@ Full guide: __tooling__/docs/tools/baker/landing.md`
   }
 });
 
+// src/commands/landing/variant.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdir as mkdir12, readdir as readdir10, readFile as readFile23, stat as stat7, writeFile as writeFile17 } from "fs/promises";
+import path38 from "path";
+import { defineCommand as defineCommand167 } from "citty";
+
+// src/commands/landing/repoint.ts
+import path37 from "path";
+var QUOTED_RELATIVE = /(['"])(\.\.?\/[^'"]*)\1/g;
+function isInside3(abs, dir) {
+  return abs === dir || abs.startsWith(dir + path37.sep);
+}
+function toSpecifier(from, to) {
+  const rel = path37.relative(from, to).split(path37.sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function repointSpecifier(spec, opts) {
+  if (!spec.startsWith(".")) return spec;
+  const abs = path37.resolve(opts.fromDir, spec);
+  if (opts.forkedTargets?.has(abs)) {
+    const withinControl = path37.relative(opts.controlDir, abs);
+    return toSpecifier(opts.toDir, path37.resolve(opts.variantDir, withinControl));
+  }
+  if (!isInside3(abs, opts.controlDir)) return spec;
+  return toSpecifier(opts.toDir, abs);
+}
+function repointFile(text2, opts) {
+  return text2.replace(QUOTED_RELATIVE, (_match, quote, spec) => {
+    return `${quote}${repointSpecifier(spec, opts)}${quote}`;
+  });
+}
+
+// src/commands/landing/variant.ts
+registerSchema({
+  command: "landing.variant",
+  description: "Create the alternative version of a landing for an A/B test. The new page shares the control's sections instead of copying them, so the only difference between the two is the one you fork \u2014 which is the only way the test measures what you think it measures. Run `baker experiment plan` FIRST: most pages cannot settle most questions.",
+  args: {
+    control: { type: "string", description: "The page under test, by slug", required: true },
+    slug: { type: "string", description: "Slug for the alternative page (convention: <control>-b)", required: true },
+    fork: {
+      type: "string",
+      description: "The component the variant owns its own copy of, named as it appears under _components/ (`Hero.astro`, or `hero/Card.astro`). Repeat for several. Everything else is shared with the control, so a later edit to the control reaches both arms and cannot skew the test.",
+      required: false
+    },
+    because: {
+      type: "string",
+      description: "What you SAW that makes this worth building \u2014 the observation, not the change. Required here, before the page exists, because a reason written afterwards is a caption for a page rather than the reason for one.",
+      required: true
+    },
+    change: {
+      type: "string",
+      description: "What is different about this version, in the client's words \u2014 \u201Cput the booking form in the hero\u201D.",
+      required: true
+    }
+  }
+});
+var SLUG_RE2 = /^[a-z0-9][a-z0-9-]*$/;
+function fail7(code, message, fix) {
+  process.stderr.write(
+    `${JSON.stringify({ ok: false, error: { code, message, ...fix ? { fix } : {} } }, null, 2)}
+`
+  );
+  process.exit(2);
+}
+async function isDir2(p) {
+  try {
+    return (await stat7(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function exists(p) {
+  try {
+    await stat7(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listLandingSlugs2(root) {
+  try {
+    const entries = await readdir10(path38.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 [];
+  }
+}
+async function listComponents(componentsDir, prefix = "") {
+  let entries;
+  try {
+    entries = await readdir10(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(path38.join(componentsDir, entry.name), rel));
+    else if (entry.name.endsWith(".astro")) out.push(rel);
+  }
+  return out.sort();
+}
+function resolveForkName(requested, available) {
+  const cleaned = requested.replace(/^\.?\/?(_components\/)?/, "");
+  for (const candidate of [cleaned, `${cleaned}.astro`]) {
+    if (available.includes(candidate)) return candidate;
+  }
+  const basename4 = (p) => p.slice(p.lastIndexOf("/") + 1);
+  const matches = available.filter((a) => basename4(a) === cleaned || basename4(a) === `${cleaned}.astro`);
+  return matches.length === 1 ? matches[0] ?? null : null;
+}
+function parseForks(fork) {
+  const list = Array.isArray(fork) ? fork : fork === void 0 || fork === null ? [] : [fork];
+  const names = list.filter((s) => typeof s === "string").flatMap((s) => s.split(",")).map((s) => s.trim()).filter((s) => s.length > 0);
+  return [...new Set(names)];
+}
+function buildVariantDefinition(controlDefinition, opts) {
+  let out = controlDefinition;
+  out = out.replace(/^internalId:.*$/m, `internalId: "${opts.internalId}"`);
+  out = out.replace(/^internalTitle:\s*(.*)$/m, (_m, title) => `internalTitle: ${title.trim()} (variant)`);
+  const shared = opts.forks.length > 0 ? opts.forks.join(", ") : "nothing yet";
+  const note = [
+    "",
+    `## A/B test \u2014 alternative version of \`${opts.controlSlug}\``,
+    "",
+    `This page is the alternative arm of a test against \`${opts.controlSlug}\`. Visitors are split at the edge and the address bar keeps saying \`/${opts.controlSlug}/\`, so both arms are the same page seen by different people.`,
+    "",
+    `**Only this differs:** ${shared}. Every other section is imported from \`${opts.controlSlug}\`, on purpose \u2014 an edit to the control reaches both arms, so the test keeps measuring the one difference rather than a drift between two copies.`,
+    ...opts.because ? ["", `**Because:** ${opts.because}`] : [],
+    ...opts.change ? ["", `**We changed:** ${opts.change}`] : [],
+    "",
+    `Run \`baker experiment start --landing ${opts.controlSlug} --variant ${opts.variantSlug} --because "\u2026" --change "\u2026"\` to begin, and read the result with \`baker experiment status\`.`,
+    ""
+  ].join("\n");
+  return `${out.trimEnd()}
+${note}`;
+}
+async function resolveTargets(projectRoot, opts) {
+  const { controlSlug, variantSlug } = opts;
+  for (const [label, slug] of [
+    ["control", controlSlug],
+    ["slug", variantSlug]
+  ]) {
+    if (!SLUG_RE2.test(slug)) {
+      fail7(
+        "INVALID_SLUG",
+        `"${slug}" is not a landing slug \u2014 use the folder name directly under src/pages/ (lowercase letters, digits and dashes).`,
+        { argument: label, availableSlugs: await listLandingSlugs2(projectRoot) }
+      );
+    }
+  }
+  if (controlSlug === variantSlug) {
+    fail7("INVALID_SLUG", `The alternative needs its own slug \u2014 try \`${controlSlug}-b\`.`);
+  }
+  const controlDir = path38.resolve(projectRoot, "src", "pages", controlSlug);
+  const variantDir = path38.resolve(projectRoot, "src", "pages", variantSlug);
+  if (!await isDir2(controlDir)) {
+    fail7("NOT_FOUND", `No landing at src/pages/${controlSlug}/`, {
+      availableSlugs: await listLandingSlugs2(projectRoot)
+    });
+  }
+  if (await exists(variantDir)) {
+    fail7(
+      "ALREADY_EXISTS",
+      `src/pages/${variantSlug}/ already exists \u2014 pick another slug, or delete that page if it was a false start.`
+    );
+  }
+  if (!await exists(path38.join(controlDir, "index.astro"))) {
+    fail7("NOT_FOUND", `src/pages/${controlSlug}/index.astro is missing, so there is no page to make a variant of.`);
+  }
+  const available = await listComponents(path38.join(controlDir, "_components"));
+  const forks = [];
+  for (const name of parseForks(opts.fork)) {
+    const resolved = resolveForkName(name, available);
+    if (resolved === null) {
+      fail7("NOT_FOUND", `"${name}" is not a component of ${controlSlug}.`, {
+        availableComponents: available,
+        hint: "Name it as it appears under _components/ \u2014 `Hero.astro`, or `hero/Card.astro`."
+      });
+    }
+    forks.push(resolved);
+  }
+  return { controlDir, variantDir, available, forks };
+}
+async function writeVariant(opts) {
+  const { controlDir, variantDir, controlSlug, variantSlug, forks } = opts;
+  const forkedTargets = new Set(forks.map((f) => path38.join(controlDir, "_components", f)));
+  const written = [];
+  const indexText = await readFile23(path38.join(controlDir, "index.astro"), "utf8");
+  await mkdir12(variantDir, { recursive: true });
+  await writeFile17(
+    path38.join(variantDir, "index.astro"),
+    repointFile(indexText, { fromDir: controlDir, toDir: variantDir, controlDir, variantDir, forkedTargets }),
+    "utf8"
+  );
+  written.push(`src/pages/${variantSlug}/index.astro`);
+  for (const fork of forks) {
+    const fromFile = path38.join(controlDir, "_components", fork);
+    const toFile = path38.join(variantDir, "_components", fork);
+    const text2 = await readFile23(fromFile, "utf8");
+    await mkdir12(path38.dirname(toFile), { recursive: true });
+    await writeFile17(
+      toFile,
+      repointFile(text2, {
+        fromDir: path38.dirname(fromFile),
+        toDir: path38.dirname(toFile),
+        controlDir,
+        variantDir,
+        forkedTargets
+      }),
+      "utf8"
+    );
+    written.push(`src/pages/${variantSlug}/_components/${fork}`);
+  }
+  const controlDefinitionPath = path38.join(controlDir, "_definition.md");
+  if (await exists(controlDefinitionPath)) {
+    const definition = buildVariantDefinition(await readFile23(controlDefinitionPath, "utf8"), {
+      internalId: randomUUID2().replace(/-/g, "").slice(0, 8),
+      variantSlug,
+      controlSlug,
+      forks,
+      ...opts.because ? { because: opts.because } : {},
+      ...opts.change ? { change: opts.change } : {}
+    });
+    await writeFile17(path38.join(variantDir, "_definition.md"), definition, "utf8");
+    written.push(`src/pages/${variantSlug}/_definition.md`);
+  }
+  await mkdir12(path38.join(variantDir, "_images"), { recursive: true });
+  await writeFile17(path38.join(variantDir, "_images", ".gitkeep"), "", "utf8");
+  return written;
+}
+var variantCommand = defineCommand167({
+  meta: {
+    name: "variant",
+    description: "Create the alternative version of a landing for an A/B test. The new page SHARES the control's sections and forks only the component you name, so the two arms differ by exactly the thing you are testing. Run `baker experiment plan` first \u2014 most pages do not have the traffic to settle most questions."
+  },
+  args: {
+    control: { type: "positional", required: true, description: "The page under test, by slug" },
+    slug: {
+      type: "positional",
+      required: true,
+      description: "Slug for the alternative page (convention: <control>-b)"
+    },
+    fork: {
+      type: "string",
+      description: "Component the variant owns its own copy of (`Hero.astro`). Repeat for several."
+    },
+    because: {
+      type: "string",
+      required: true,
+      description: "What you SAW that makes this worth building \u2014 the observation, not the change. Required here, before the page exists, because a reason written afterwards is a caption for a page rather than the reason for one, and a test with no stated belief teaches nothing whichever way it lands. Recorded in the page's notes and passed to `baker experiment start`."
+    },
+    change: {
+      type: "string",
+      required: true,
+      description: "What is different about this version, in the client's words \u2014 \u201Cput the booking form in the hero\u201D."
+    }
+  },
+  async run({ args }) {
+    const projectRoot = process.cwd();
+    const controlSlug = String(args.control);
+    const variantSlug = String(args.slug);
+    const { controlDir, variantDir, available, forks } = await resolveTargets(projectRoot, {
+      controlSlug,
+      variantSlug,
+      fork: args.fork
+    });
+    const written = await writeVariant({
+      controlDir,
+      variantDir,
+      controlSlug,
+      variantSlug,
+      forks,
+      because: String(args.because),
+      change: String(args.change)
+    });
+    const hints = [
+      forks.length === 0 ? `MISSING --fork: ${variantSlug} currently renders exactly ${controlSlug}, so a test between them cannot conclude anything. Re-run with --fork <Component>, or copy the one section your change touches into src/pages/${variantSlug}/_components/ and repoint that import.` : `Edit ONLY src/pages/${variantSlug}/_components/${forks.join(", ")} \u2014 every other section is shared with ${controlSlug}, and editing a shared one changes both arms at once.`,
+      `Preview both at http://localhost:4321/${controlSlug}/ and http://localhost:4321/${variantSlug}/ and check they differ only where you meant.`,
+      `Then: baker experiment start --landing ${controlSlug} --variant ${variantSlug} --because "${String(args.because)}" --change "${String(args.change)}". Nothing is split until the session is published \u2014 the person publishing is the review of this page.`
+    ];
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          data: {
+            control: controlSlug,
+            slug: variantSlug,
+            forked: forks,
+            shared: available.filter((c) => !forks.includes(c)),
+            written
+          },
+          hints
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+});
+
 // src/commands/landing/index.ts
-var landingCommand = defineCommand166({
+var landingCommand = defineCommand168({
   meta: {
     name: "landing",
     description: `Design-quality tools for landing pages (src/pages/<slug>/).
@@ -45666,16 +46766,18 @@ Start here: \`baker landing critique <slug>\` after building or editing a landin
 
 Subcommands:
   baker landing inspiration      \u2014 reference library of real landing-page sections; search it during research, BEFORE writing the Direction Contract. Inspiration only: take the mechanism, never the words.
+  baker landing variant <control> <slug> \u2014 the alternative version of a page for an A/B test: shares the control's sections, forks only the component you name, so the two arms differ by exactly your hypothesis. Run \`baker experiment plan\` first.
   baker landing critique <slug>   \u2014 deterministic design-quality critic (advisory): flags the known AI 'slop' tells (gradient text, overused fonts, side-tab borders, cream palettes, buzzword copy, broken images) tiered block/warn/advisory, respecting the client's BRAND.md. Records the critique the publish quality gate requires \u2014 run it before finishing a landing.`
   },
   subCommands: {
     inspiration: inspirationCommand,
-    critique: critiqueCommand2
+    critique: critiqueCommand2,
+    variant: variantCommand
   }
 });
 
 // src/commands/mcp/index.ts
-import { defineCommand as defineCommand167 } from "citty";
+import { defineCommand as defineCommand169 } from "citty";
 
 // src/commands/mcp/platforms.ts
 function readsKey(label) {
@@ -45730,7 +46832,7 @@ function parseHeaders(raw) {
   }
   return Object.keys(headers).length > 0 ? headers : void 0;
 }
-function fail6(err) {
+function fail8(err) {
   if (err instanceof ApiError) {
     writeJson({ ok: false, error: { code: err.code, message: err.message } });
     process.exit(1);
@@ -45744,7 +46846,7 @@ registerSchema({
   description: "List everything this chat can reach: managed integrations (Attio, Slack, Gmail, Google Sheets, \u2026), custom MCP servers, and the platforms the company signed in to (HubSpot, Google Ads, GA4, Search Console, Tag Manager) which you read through their own `baker` commands. Start here when the user mentions an external tool or platform.",
   args: {}
 });
-var connectedCommand = defineCommand167({
+var connectedCommand = defineCommand169({
   meta: {
     name: "connected",
     description: `Everything this chat can reach \u2014 managed integrations, custom MCP servers, and connected platforms.
@@ -45794,7 +46896,7 @@ A tool or platform the user names that is NOT listed anywhere here is simply not
         hints
       });
     } catch (err) {
-      fail6(err);
+      fail8(err);
     }
   }
 });
@@ -45803,7 +46905,7 @@ registerSchema({
   description: "List the custom MCP servers this company's chats see (org + company + your own user scope).",
   args: {}
 });
-var listCommand14 = defineCommand167({
+var listCommand14 = defineCommand169({
   meta: { name: "list", description: "List custom MCP servers visible to this company's chats." },
   run: async () => {
     try {
@@ -45822,7 +46924,7 @@ var listCommand14 = defineCommand167({
         } : {}
       });
     } catch (err) {
-      fail6(err);
+      fail8(err);
     }
   }
 });
@@ -45840,7 +46942,7 @@ registerSchema({
     header: { type: "string", description: 'Auth header "Key: Value" (repeatable)', required: false }
   }
 });
-var addCommand2 = defineCommand167({
+var addCommand2 = defineCommand169({
   meta: {
     name: "add",
     description: `Register a custom MCP server. Tools appear as mcp__<name>__* on the NEXT message.
@@ -45883,7 +46985,7 @@ Examples:
         ]
       });
     } catch (err) {
-      fail6(err);
+      fail8(err);
     }
   }
 });
@@ -45892,7 +46994,7 @@ registerSchema({
   description: "Remove a company custom MCP server by name.",
   args: { name: { type: "string", description: "Server name to remove", required: true } }
 });
-var removeCommand4 = defineCommand167({
+var removeCommand4 = defineCommand169({
   meta: {
     name: "remove",
     description: `Remove a company custom MCP server by name.
@@ -45910,11 +47012,11 @@ Example:
       });
       writeJson({ ok: true, data });
     } catch (err) {
-      fail6(err);
+      fail8(err);
     }
   }
 });
-var mcpCommand = defineCommand167({
+var mcpCommand = defineCommand169({
   meta: {
     name: "mcp",
     description: `Third-party tools for this company \u2014 see what's connected, register custom HTTPS MCP endpoints.
@@ -45940,10 +47042,10 @@ Full guide: __tooling__/docs/tools/baker/mcp.md`
 });
 
 // src/commands/research/index.ts
-import { defineCommand as defineCommand179 } from "citty";
+import { defineCommand as defineCommand181 } from "citty";
 
 // src/commands/research/advertisers.ts
-import { defineCommand as defineCommand168 } from "citty";
+import { defineCommand as defineCommand170 } from "citty";
 
 // src/commands/research/hints.ts
 var AD_COPY_ROUTE = 'This returns competing DOMAINS and their SERP economics \u2014 no ad copy, no headlines, no creative. For the actual copy of a competitor\'s ads: `baker winning-ads advertisers "<brand>"` \u2192 `baker winning-ads search "<brief>" --advertiser-id <id>` \u2192 `baker winning-ads content <adId>` (`primary_text` / `headline` / `cta`, plus the spoken transcript and on-screen text for video). That corpus is Meta and LinkedIn only \u2014 Google SERP ad copy is not available through any Baker command, so do not keep querying for it here.';
@@ -46126,7 +47228,7 @@ var FIELDS3 = {
   etv: "Estimated traffic value (USD)",
   visibility: "SERP visibility score (0-1)"
 };
-var advertisersCommand = defineCommand168({
+var advertisersCommand = defineCommand170({
   meta: {
     name: "advertisers",
     description: `Domains competing for a keyword in Google SERPs, with position, relevance, traffic value and visibility. Returns NO ad copy \u2014 for a competitor's headlines and body copy use \`baker winning-ads content <adId>\` (Meta/LinkedIn only).
@@ -46182,7 +47284,7 @@ Examples:
 });
 
 // src/commands/research/autocomplete.ts
-import { defineCommand as defineCommand169 } from "citty";
+import { defineCommand as defineCommand171 } from "citty";
 registerSchema({
   command: "research.autocomplete",
   description: "Get Google Autocomplete suggestions for a seed keyword. Useful for keyword expansion and discovering what people actually search for. IMPORTANT: If --location and --language are omitted, defaults to United States (us) and English (en).",
@@ -46205,7 +47307,7 @@ registerSchema({
 var FIELDS4 = {
   suggestion: "Autocomplete suggestion from Google"
 };
-var autocompleteCommand = defineCommand169({
+var autocompleteCommand = defineCommand171({
   meta: {
     name: "autocomplete",
     description: `Get Google Autocomplete suggestions for keyword expansion.
@@ -46260,7 +47362,7 @@ Examples:
 });
 
 // src/commands/research/countries.ts
-import { defineCommand as defineCommand170 } from "citty";
+import { defineCommand as defineCommand172 } from "citty";
 registerSchema({
   command: "research.countries",
   description: "List all supported country codes for --location flag in research commands.",
@@ -46317,7 +47419,7 @@ var FIELDS5 = {
   code: "Country code to pass as --location",
   name: "Country name"
 };
-var countriesCommand = defineCommand170({
+var countriesCommand = defineCommand172({
   meta: {
     name: "countries",
     description: "List all supported country codes for --location flag."
@@ -46328,7 +47430,7 @@ var countriesCommand = defineCommand170({
 });
 
 // src/commands/research/fetch.ts
-import { defineCommand as defineCommand171 } from "citty";
+import { defineCommand as defineCommand173 } from "citty";
 var CONTENT_PREVIEW_CHARS = 2e4;
 var TIMEOUT_MS = 18e4;
 registerSchema({
@@ -46401,7 +47503,7 @@ function fetchFix(code) {
     explanation: "This read failed. Don't build a retry ladder around it \u2014 finish the rest of the job with what you can reach and name this page as a gap."
   };
 }
-var fetchCommand = defineCommand171({
+var fetchCommand = defineCommand173({
   meta: {
     name: "fetch",
     description: `Read a page an ordinary web fetch could not. Bot walls and JavaScript-rendered pages are resolved for you \u2014 you never have to retry, wait, or drive a browser yourself.
@@ -46478,7 +47580,7 @@ Examples:
 });
 
 // src/commands/research/intent.ts
-import { defineCommand as defineCommand172 } from "citty";
+import { defineCommand as defineCommand174 } from "citty";
 registerSchema({
   command: "research.intent",
   description: "Classify Google Search intent for keywords. Determines if someone searching is looking to buy, research, or navigate. IMPORTANT: If --language is omitted, defaults to English (en). The response includes a query_context object showing which language was used.",
@@ -46501,7 +47603,7 @@ var FIELDS7 = {
   intent: "Primary Google Search intent: informational, navigational, commercial, transactional",
   probability: "Confidence score 0.0-1.0"
 };
-var intentCommand = defineCommand172({
+var intentCommand = defineCommand174({
   meta: {
     name: "intent",
     description: `Classify Google Search intent for keywords. Returns intent type and confidence.
@@ -46549,7 +47651,7 @@ Examples:
 });
 
 // src/commands/research/keyword-gap.ts
-import { defineCommand as defineCommand173 } from "citty";
+import { defineCommand as defineCommand175 } from "citty";
 registerSchema({
   command: "research.keyword-gap",
   description: "Find keywords a competitor ranks for (organic or paid) that you don't. Discovers expansion opportunities. IMPORTANT: If --location and --language are omitted, defaults to United States (us) and English (en). The response includes a query_context object showing which location/language were used.",
@@ -46578,7 +47680,7 @@ var FIELDS8 = {
   cpc: "Cost per click USD",
   their_position: "Competitor's ranking position"
 };
-var keywordGapCommand = defineCommand173({
+var keywordGapCommand = defineCommand175({
   meta: {
     name: "keyword-gap",
     description: `Find keywords a competitor has that you don't. Supports pagination via --offset.
@@ -46653,7 +47755,7 @@ Examples:
 });
 
 // src/commands/research/keywords-for-site.ts
-import { defineCommand as defineCommand174 } from "citty";
+import { defineCommand as defineCommand176 } from "citty";
 registerSchema({
   command: "research.keywords-for-site",
   description: "Get keywords a competitor targets in Google. Use --type paid to see only paid keywords, --type organic for organic only. IMPORTANT: If --location and --language are omitted, defaults to United States (us) and English (en). The response includes a query_context object showing which location/language were used.",
@@ -46686,7 +47788,7 @@ var FIELDS9 = {
   competition: "LOW, MEDIUM, or HIGH",
   competition_index: "Competition score 0-100"
 };
-var keywordsForSiteCommand = defineCommand174({
+var keywordsForSiteCommand = defineCommand176({
   meta: {
     name: "keywords-for-site",
     description: `Get keywords a competitor targets in Google. Use --type to filter paid/organic.
@@ -46748,7 +47850,7 @@ Examples:
 });
 
 // src/commands/research/languages.ts
-import { defineCommand as defineCommand175 } from "citty";
+import { defineCommand as defineCommand177 } from "citty";
 registerSchema({
   command: "research.languages",
   description: "List all supported language codes for --language flag in research commands.",
@@ -46778,7 +47880,7 @@ var FIELDS10 = {
   code: "Language code to pass as --language",
   name: "Language name (also accepted by --language)"
 };
-var languagesCommand2 = defineCommand175({
+var languagesCommand2 = defineCommand177({
   meta: {
     name: "languages",
     description: "List all supported language codes for --language flag."
@@ -46789,7 +47891,7 @@ var languagesCommand2 = defineCommand175({
 });
 
 // src/commands/research/lighthouse.ts
-import { defineCommand as defineCommand176 } from "citty";
+import { defineCommand as defineCommand178 } from "citty";
 registerSchema({
   command: "research.lighthouse",
   description: "Landing page performance audit. Returns metrics that affect Google Ads Quality Score and CPC.",
@@ -46808,7 +47910,7 @@ var FIELDS11 = {
   speed_index_ms: "Speed Index in ms (good: < 3400)",
   interactive_ms: "Time to Interactive in ms (good: < 3800)"
 };
-var lighthouseCommand = defineCommand176({
+var lighthouseCommand = defineCommand178({
   meta: {
     name: "lighthouse",
     description: `Landing page performance audit. Metrics affecting Google Ads Quality Score.
@@ -46846,7 +47948,7 @@ Examples:
 });
 
 // src/commands/research/relevant-pages.ts
-import { defineCommand as defineCommand177 } from "citty";
+import { defineCommand as defineCommand179 } from "citty";
 registerSchema({
   command: "research.relevant-pages",
   description: "Get the top pages of a competitor domain with organic traffic and ranking data. Shows which pages drive the most traffic. IMPORTANT: If --location and --language are omitted, defaults to United States (us) and English (en).",
@@ -46872,7 +47974,7 @@ var FIELDS12 = {
   keywords: "Total organic keywords the page ranks for",
   top_10: "Keywords in positions 1-10"
 };
-var relevantPagesCommand = defineCommand177({
+var relevantPagesCommand = defineCommand179({
   meta: {
     name: "relevant-pages",
     description: `Get the top pages of a competitor domain with traffic data.
@@ -46919,7 +48021,7 @@ Examples:
 });
 
 // src/commands/research/web.ts
-import { defineCommand as defineCommand178 } from "citty";
+import { defineCommand as defineCommand180 } from "citty";
 registerSchema({
   command: "research.web",
   description: "Search the web with AI to answer marketing questions \u2014 competitors, ICP, pricing, pain points, market trends. Three depth levels: medium (quick, default), high (thorough), xhigh (exhaustive deep research).",
@@ -46970,7 +48072,7 @@ async function runDeepResearch(question) {
   }
   throw new Error("Deep research timed out");
 }
-var webCommand = defineCommand178({
+var webCommand = defineCommand180({
   meta: {
     name: "web",
     description: `Search the web with AI to answer any open-ended marketing question. Uses live internet data via Google Search.
@@ -47032,7 +48134,7 @@ Examples:
 });
 
 // src/commands/research/index.ts
-var researchCommand = defineCommand179({
+var researchCommand = defineCommand181({
   meta: {
     name: "research",
     description: `Competitive intelligence and AI-powered research commands.
@@ -47076,10 +48178,10 @@ Full guide: __tooling__/docs/tools/baker/research.md`
 });
 
 // src/commands/scheduled-actions/index.ts
-import { defineCommand as defineCommand187 } from "citty";
+import { defineCommand as defineCommand189 } from "citty";
 
 // src/commands/scheduled-actions/create.ts
-import { defineCommand as defineCommand180 } from "citty";
+import { defineCommand as defineCommand182 } from "citty";
 
 // src/commands/scheduled-actions/shared.ts
 var TEMP_SCHEDULED_ACTION_PREFIX = "temp_sched_";
@@ -47226,7 +48328,7 @@ registerSchema({
     }
   }
 });
-var createCommand3 = defineCommand180({
+var createCommand3 = defineCommand182({
   meta: {
     name: "create",
     description: 'Stage a scheduled action. Example: baker scheduled-actions create --name "Weekly report" --description "..." --cron "0 9 * * MON"'
@@ -47285,7 +48387,7 @@ var createCommand3 = defineCommand180({
 });
 
 // src/commands/scheduled-actions/delete.ts
-import { defineCommand as defineCommand181 } from "citty";
+import { defineCommand as defineCommand183 } from "citty";
 registerSchema({
   command: "scheduled-actions.delete",
   description: "Stage deletion of a published scheduled action or cancellation of a temp_sched_* draft creation.",
@@ -47293,7 +48395,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID or temp_sched_* draft ID", required: true }
   }
 });
-var deleteCommand3 = defineCommand181({
+var deleteCommand3 = defineCommand183({
   meta: {
     name: "delete",
     description: "Stage scheduled action deletion. Example: baker scheduled-actions delete <id-or-temp_sched_id>"
@@ -47322,7 +48424,7 @@ var deleteCommand3 = defineCommand181({
 });
 
 // src/commands/scheduled-actions/get.ts
-import { defineCommand as defineCommand182 } from "citty";
+import { defineCommand as defineCommand184 } from "citty";
 registerSchema({
   command: "scheduled-actions.get",
   description: "Get a published scheduled action or a temp_sched_* draft-created scheduled action.",
@@ -47331,7 +48433,7 @@ registerSchema({
     chat: { type: "string", description: CHAT_READ_ARG.description, required: false }
   }
 });
-var getCommand4 = defineCommand182({
+var getCommand4 = defineCommand184({
   meta: {
     name: "get",
     description: "Get a scheduled action. Example: baker scheduled-actions get <id-or-temp_sched_id>"
@@ -47370,7 +48472,7 @@ var getCommand4 = defineCommand182({
 });
 
 // src/commands/scheduled-actions/list.ts
-import { defineCommand as defineCommand183 } from "citty";
+import { defineCommand as defineCommand185 } from "citty";
 registerSchema({
   command: "scheduled-actions.list",
   description: "List published scheduled actions. Includes draft state when BAKER_CHAT_ID is set, or --chat <id> to read an earlier chat's staged schedules instead.",
@@ -47378,7 +48480,7 @@ registerSchema({
     chat: { type: "string", description: CHAT_READ_ARG.description, required: false }
   }
 });
-var listCommand15 = defineCommand183({
+var listCommand15 = defineCommand185({
   meta: {
     name: "list",
     description: "List scheduled actions. Includes staged draft ops when BAKER_CHAT_ID is set, or --chat <id> to read an earlier chat's staged schedules instead."
@@ -47401,9 +48503,9 @@ var listCommand15 = defineCommand183({
 });
 
 // src/commands/scheduled-actions/templates.ts
-import { readFile as readFile22 } from "fs/promises";
-import path36 from "path";
-import { defineCommand as defineCommand184 } from "citty";
+import { readFile as readFile24 } from "fs/promises";
+import path39 from "path";
+import { defineCommand as defineCommand186 } from "citty";
 registerSchema({
   command: "scheduled-actions.templates",
   description: "The recipes available to this company: the ones Baker ships plus the ones they wrote themselves, each with its id, what it produces and how often it is meant to run. Read this before proposing a company's automation, so every recipe you name is one that exists. Also how a company gets a recipe of its own \u2014 save a brief, prove it runs, then publish it.",
@@ -47458,7 +48560,7 @@ registerSchema({
     }
   }
 });
-var templatesCommand = defineCommand184({
+var templatesCommand = defineCommand186({
   meta: {
     name: "templates",
     description: `The recipes this company can run \u2014 Baker's own plus theirs, with what each one produces.
@@ -47505,7 +48607,7 @@ Full guide: __tooling__/docs/tools/baker/scheduled-actions.md`
       }
       if (save.length > 0) {
         const briefFile = flag("brief-file");
-        const brief = briefFile.length > 0 ? await readFile22(path36.resolve(briefFile), "utf8") : flag("brief");
+        const brief = briefFile.length > 0 ? await readFile24(path39.resolve(briefFile), "utf8") : flag("brief");
         if (brief.trim().length === 0) {
           failValidation4("--brief-file (preferred) or --brief is required: the brief is the recipe.");
         }
@@ -47550,7 +48652,7 @@ Full guide: __tooling__/docs/tools/baker/scheduled-actions.md`
 });
 
 // src/commands/scheduled-actions/trigger.ts
-import { defineCommand as defineCommand185 } from "citty";
+import { defineCommand as defineCommand187 } from "citty";
 registerSchema({
   command: "scheduled-actions.trigger",
   description: "Immediately trigger a published scheduled action. Does not require BAKER_CHAT_ID and rejects temp_sched_* IDs.",
@@ -47558,7 +48660,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID", required: true }
   }
 });
-var triggerCommand = defineCommand185({
+var triggerCommand = defineCommand187({
   meta: {
     name: "trigger",
     description: "Immediately trigger a published scheduled action. Example: baker scheduled-actions trigger <id>"
@@ -47595,7 +48697,7 @@ var triggerCommand = defineCommand185({
 });
 
 // src/commands/scheduled-actions/update.ts
-import { defineCommand as defineCommand186 } from "citty";
+import { defineCommand as defineCommand188 } from "citty";
 registerSchema({
   command: "scheduled-actions.update",
   description: "Stage an update to a published scheduled action or temp_sched_* draft-created scheduled action.",
@@ -47626,7 +48728,7 @@ registerSchema({
     prompt: { type: "string", description: "Replacement additional spawned-agent instructions", required: false }
   }
 });
-var updateCommand3 = defineCommand186({
+var updateCommand3 = defineCommand188({
   meta: {
     name: "update",
     description: "Stage a scheduled action update. Examples: baker scheduled-actions update <id> --enabled false | baker scheduled-actions update <id> --mode publish"
@@ -47704,7 +48806,7 @@ var updateCommand3 = defineCommand186({
 });
 
 // src/commands/scheduled-actions/index.ts
-var scheduledActionsCommand = defineCommand187({
+var scheduledActionsCommand = defineCommand189({
   meta: {
     name: "scheduled-actions",
     description: `Manage Scheduled Actions. Subcommands: list, get, create, update, delete, trigger, templates.
@@ -47733,14 +48835,14 @@ Full guide: __tooling__/docs/tools/baker/scheduled-actions.md`
 });
 
 // src/commands/schema.ts
-import { defineCommand as defineCommand188 } from "citty";
+import { defineCommand as defineCommand190 } from "citty";
 function narrowToFamily(commandName, available) {
   const segments = commandName.split(".");
   const prefix = segments[0] === "ads" && segments[1] ? `ads.${segments[1]}.` : `${segments[0]}.`;
   const siblings = available.filter((name) => name.startsWith(prefix));
   return siblings.length > 0 ? siblings : available;
 }
-var schemaCommand2 = defineCommand188({
+var schemaCommand2 = defineCommand190({
   meta: {
     name: "schema",
     description: "Inspect command argument schemas (for AI agent introspection). Lists all commands if no argument given. Example: baker schema images.search"
@@ -47784,10 +48886,10 @@ var schemaCommand2 = defineCommand188({
 });
 
 // src/commands/studio/index.ts
-import { defineCommand as defineCommand197 } from "citty";
+import { defineCommand as defineCommand199 } from "citty";
 
 // src/commands/studio/animate.ts
-import { defineCommand as defineCommand189 } from "citty";
+import { defineCommand as defineCommand191 } from "citty";
 
 // src/commands/studio/batch.ts
 function projectBatch(generation, full) {
@@ -47976,7 +49078,7 @@ function parseImageRefs(spec) {
 }
 var defaultDeps = {
   ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
-  upload: (path38) => uploadLocalImage({ file: path38, contentType: detectImageContentType(path38), source: "uploaded" })
+  upload: (path41) => uploadLocalImage({ file: path41, contentType: detectImageContentType(path41), source: "uploaded" })
 };
 async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   const refs = parseImageRefs(spec);
@@ -47996,10 +49098,10 @@ async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   }
   return { imageIds, added };
 }
-function uploadFailure(path38) {
+function uploadFailure(path41) {
   return (error) => {
     if (error instanceof ApiError) throw error;
-    throw new ApiError("VALIDATION_ERROR", `Could not read "${path38}" as an image.`);
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path41}" as an image.`);
   };
 }
 
@@ -48238,7 +49340,7 @@ function costHintsFor(body) {
   }
   return hints;
 }
-var animateCommand = defineCommand189({
+var animateCommand = defineCommand191({
   meta: {
     name: "animate",
     description: "Render a clip. With an image the look is already fixed, so the prompt describes MOVEMENT \u2014 what the camera does, what the subject does, in what order. With --from text there is no image and the prompt is the whole shot.\n\nA rendered clip is NOT usable anywhere until you keep it: `baker studio keep <id> --slot N` is what puts it in the video library. Takes nobody keeps are never ingested, which is what makes a rejected batch cheap.\n\nFor anything longer than 15 seconds, or to build on footage that already exists, use --model bytedance/seedance-2.5: it renders 4-30s and is the only model that reads an existing clip or an existing soundtrack.\n\nExamples:\n  baker studio animate 'slow push in, model turns to camera and smiles' --image j57abc123def456ghi789\n  baker studio animate 'handheld drift right, steam rising from the cup' --image './out/hero.png' --duration 6 --quality 1080p\n  baker studio animate 'product rotates once on a turntable' --image j57abc\u2026,j57def\u2026 --from references\n  baker studio animate 'she keeps walking, camera stays with her, then she stops and looks up' --image j57abc\u2026 --from references --from-clip j57batch\u2026:0 --model bytedance/seedance-2.5 --duration 20\n  baker studio animate 'hold on the product, then a slow push-in' --from references --from-video j57vid\u2026 --model bytedance/seedance-2.5\n  baker studio animate 'slow drone pull-back over a solar farm at golden hour, no people' --from text --model bytedance/seedance-2.5 --duration 12"
@@ -48357,7 +49459,7 @@ var animateCommand = defineCommand189({
 });
 
 // src/commands/studio/generate.ts
-import { defineCommand as defineCommand190 } from "citty";
+import { defineCommand as defineCommand192 } from "citty";
 var MODEL_LIST2 = IMAGE_MODEL_IDS;
 var DEFAULT_MAX_WAIT_MS2 = 24e4;
 registerSchema({
@@ -48493,7 +49595,7 @@ function buildGenerateBody(args, prompt) {
   }
   return body;
 }
-var generateCommand = defineCommand190({
+var generateCommand = defineCommand192({
   meta: {
     name: "generate",
     description: "Start here to make an image. Renders 1-8 takes of one brief, ingests each into the media library as it lands, and shows the batch in the dashboard Studio next to the ones the client ran.\n\nModel choice: google/gemini-3.1-flash-image-preview (default \u2014 fast, best at editing a reference and at extreme ratios), google/gemini-3-pro-image-preview (highest fidelity, slower), openai/gpt-image-2 (photoreal and the cleanest in-image text \u2014 no --image-size, no 4:5 / 5:4), recraft/recraft-v4.1-pro-vector (vector/flat marks with palette control).\n\n--reference is the biggest quality lever there is: a real logo, product shot, Pinterest pin or sandbox screenshot beats any amount of adjectives.\n\nExamples:\n  baker studio generate 'matte black bottle on wet marble, hard studio light, 35mm' --aspect-ratio 3:2 --count 3\n  baker studio generate 'this bottle on a sunlit kitchen counter' --reference './src/brand/product.png,https://\u2026/kitchen.jpg'\n  baker studio generate 'founder-style selfie, kitchen background, natural light' --skill ugc-selfie-hook\n  baker studio generate 'flat geometric mascot, brand palette' --model recraft/recraft-v4.1-pro-vector --rgb-colors '[[10,10,10],[255,80,0]]'"
@@ -48571,7 +49673,7 @@ var generateCommand = defineCommand190({
 });
 
 // src/commands/studio/get.ts
-import { defineCommand as defineCommand191 } from "citty";
+import { defineCommand as defineCommand193 } from "citty";
 registerSchema({
   command: "studio.get",
   description: "Read one Studio batch: every take, where it lives, and why a take is missing. This is how you pick up a batch that was still rendering when the start command returned.",
@@ -48580,7 +49682,7 @@ registerSchema({
     full: { type: "boolean", description: "Include settings, references and attribution", required: false }
   }
 });
-var getCommand5 = defineCommand191({
+var getCommand5 = defineCommand193({
   meta: {
     name: "get",
     description: "Read one Studio batch \u2014 the takes, their urls, whether each is in the library, and the reason for any that failed.\n\nExample: baker studio get j57abc123def456ghi789\nExample: baker studio get j57abc123def456ghi789 --full"
@@ -48609,7 +49711,7 @@ var getCommand5 = defineCommand191({
 });
 
 // src/commands/studio/improve.ts
-import { defineCommand as defineCommand192 } from "citty";
+import { defineCommand as defineCommand194 } from "citty";
 var DESCRIPTION = "Sharpen a rough brief into directed art direction \u2014 the same rewrite the client gets from the wand in the Studio prompt bar. Reach for it when you are relaying the CLIENT's own words and want them shaped without substituting your voice; when you are writing the art direction yourself, just write it, because you will do a better job than this does.";
 registerSchema({
   command: "studio.improve",
@@ -48634,7 +49736,7 @@ registerSchema({
     }
   }
 });
-var improveCommand = defineCommand192({
+var improveCommand = defineCommand194({
   meta: {
     name: "improve",
     description: `${DESCRIPTION}
@@ -48678,7 +49780,7 @@ Examples:
 });
 
 // src/commands/studio/keep.ts
-import { defineCommand as defineCommand193 } from "citty";
+import { defineCommand as defineCommand195 } from "citty";
 registerSchema({
   command: "studio.keep",
   description: "Mark one take as the keeper. For an image this stars it, so the client reviewing the batch sees which one you used. For a CLIP it is the step that puts it in the video library \u2014 until then the clip cannot be used in a canvas, a landing, or an ad.",
@@ -48688,7 +49790,7 @@ registerSchema({
     undo: { type: "boolean", description: "Un-star an image, or take a kept clip back out", required: false }
   }
 });
-var keepCommand = defineCommand193({
+var keepCommand = defineCommand195({
   meta: {
     name: "keep",
     description: "Mark one take as the keeper. An image gets starred (it was already in the library); a clip gets INGESTED into the video library, which is what makes it usable anywhere else.\n\nExample: baker studio keep j57abc123def456ghi789 --slot 2\nExample: baker studio keep j57abc123def456ghi789 --slot 2 --undo"
@@ -48739,7 +49841,7 @@ var keepCommand = defineCommand193({
 });
 
 // src/commands/studio/list.ts
-import { defineCommand as defineCommand194 } from "citty";
+import { defineCommand as defineCommand196 } from "citty";
 registerSchema({
   command: "studio.list",
   description: "Recent Studio batches for THIS conversation, newest first \u2014 what you have already generated, so you re-use a take instead of paying for it twice. `--all` widens it to everything the company generated, including what people ran themselves in the dashboard.",
@@ -48750,7 +49852,7 @@ registerSchema({
     full: { type: "boolean", description: "Include settings, references and attribution", required: false }
   }
 });
-var listCommand16 = defineCommand194({
+var listCommand16 = defineCommand196({
   meta: {
     name: "list",
     description: "Recent Studio batches, newest first. Scoped to this conversation unless you pass --all.\n\nExample: baker studio list\nExample: baker studio list --kind video --limit 5\nExample: baker studio list --all   # includes batches the client ran in the dashboard"
@@ -48784,7 +49886,7 @@ var listCommand16 = defineCommand194({
 });
 
 // src/commands/studio/models.ts
-import { defineCommand as defineCommand195 } from "citty";
+import { defineCommand as defineCommand197 } from "citty";
 var DESCRIPTION2 = "What each Studio model actually accepts: its shapes, resolutions, clip lengths, prompt character cap, how many reference images it takes, and which knobs it has. Read this before a batch you care about \u2014 the models disagree far more than they look like they do, and a setting the chosen model does not have is REFUSED, not ignored.";
 registerSchema({
   command: "studio.models",
@@ -48871,7 +49973,7 @@ function buildModelCards(kind, model) {
   const selected = model ? ids.filter((id) => id === model) : ids;
   return selected.map((id) => build(id));
 }
-var modelsCommand = defineCommand195({
+var modelsCommand = defineCommand197({
   meta: {
     name: "models",
     description: `${DESCRIPTION2}
@@ -48918,13 +50020,13 @@ Examples:
 });
 
 // src/commands/studio/skills.ts
-import { defineCommand as defineCommand196 } from "citty";
+import { defineCommand as defineCommand198 } from "citty";
 registerSchema({
   command: "studio.skills",
   description: "The craft directions `studio generate --skill <id>` accepts. Each one carries directed art direction plus the model, shape and take count it wants, so you pick a look by name instead of writing the boilerplate yourself.",
   args: {}
 });
-var skillsCommand = defineCommand196({
+var skillsCommand = defineCommand198({
   meta: {
     name: "skills",
     description: "List the craft directions available to `baker studio generate --skill <id>` \u2014 what each one is for, whether it wants a reference image, and the model/shape/count it defaults to.\n\nExample: baker studio skills"
@@ -48948,7 +50050,7 @@ var skillsCommand = defineCommand196({
 });
 
 // src/commands/studio/index.ts
-var studioCommand = defineCommand197({
+var studioCommand = defineCommand199({
   meta: {
     name: "studio",
     description: `Make new imagery and clips. Every batch is recorded and shows up in the dashboard Studio for the client to review, labelled with this conversation.
@@ -48991,10 +50093,10 @@ Full guide: __tooling__/docs/tools/baker/studio.md`
 });
 
 // src/commands/tag-manager/index.ts
-import { defineCommand as defineCommand201 } from "citty";
+import { defineCommand as defineCommand203 } from "citty";
 
 // src/commands/tag-manager/draft.ts
-import { defineCommand as defineCommand198 } from "citty";
+import { defineCommand as defineCommand200 } from "citty";
 
 // src/commands/tag-manager/shared.ts
 import { readFileSync as readFileSync15 } from "fs";
@@ -49061,10 +50163,10 @@ async function stageOp4(op) {
     handleError5(err);
   }
 }
-async function draftAction3(path38, body, chat) {
+async function draftAction3(path41, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path38, { chatId, ...body });
+    const data = await apiPost(path41, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -49117,13 +50219,13 @@ registerSchema({
     chat: { type: "string", description: CHAT_READ_ARG.description, required: false }
   }
 });
-var draftCommand4 = defineCommand198({
+var draftCommand4 = defineCommand200({
   meta: {
     name: "draft",
     description: "List, show, amend, remove, or clear staged Tag Manager changes for this chat. `list` and `show` take --chat <id> to read an earlier chat's changes instead."
   },
   subCommands: {
-    list: defineCommand198({
+    list: defineCommand200({
       meta: {
         name: "list",
         description: "Review everything staged on this chat (--json for the raw envelope)"
@@ -49136,7 +50238,7 @@ var draftCommand4 = defineCommand198({
         await draftList2(args.json === true, args.chat);
       }
     }),
-    show: defineCommand198({
+    show: defineCommand200({
       meta: {
         name: "show",
         description: "Print the full staged payload for one change \u2014 the receipt to verify it looks right before publish (never truncated)."
@@ -49153,7 +50255,7 @@ var draftCommand4 = defineCommand198({
         );
       }
     }),
-    amend: defineCommand198({
+    amend: defineCommand200({
       meta: {
         name: "amend",
         description: "Update a staged change in place \u2014 merges a JSON patch into its payload (objects deep-merge, null deletes a key, arrays/scalars replace) and re-validates. Use this instead of remove + re-create."
@@ -49170,7 +50272,7 @@ var draftCommand4 = defineCommand198({
         });
       }
     }),
-    remove: defineCommand198({
+    remove: defineCommand200({
       meta: { name: "remove", description: "Remove one staged change (cascades to anything depending on it)" },
       args: { ref: { type: "positional", description: "Staged ref (gtm_temp_*) or target", required: false } },
       run: async ({ args }) => {
@@ -49179,7 +50281,7 @@ var draftCommand4 = defineCommand198({
         });
       }
     }),
-    clear: defineCommand198({
+    clear: defineCommand200({
       meta: { name: "clear", description: "Discard all Tag Manager changes staged on this chat" },
       run: async () => {
         await draftAction3("/api/tag-manager/draft/clear", {});
@@ -49189,7 +50291,7 @@ var draftCommand4 = defineCommand198({
 });
 
 // src/commands/tag-manager/read.ts
-import { defineCommand as defineCommand199 } from "citty";
+import { defineCommand as defineCommand201 } from "citty";
 registerSchema({
   command: "tagManager.containers",
   description: "List the Google Tag Manager containers this company's connection can reach. Every container the company connected is flagged `connected: true` \u2014 there can be several, and Baker may read and change all of them. Start here to confirm which containers you are managing.",
@@ -49230,7 +50332,7 @@ function containersHints(containers) {
     }))
   });
 }
-var containersCommand = defineCommand199({
+var containersCommand = defineCommand201({
   meta: {
     name: "containers",
     description: `List Tag Manager containers reachable by this company's connection.
@@ -49247,7 +50349,7 @@ Start here:
     }
   }
 });
-var readCommand = defineCommand199({
+var readCommand = defineCommand201({
   meta: {
     name: "read",
     description: `Read the current contents of the Tag Manager container \u2014 always do this before staging changes.
@@ -49289,7 +50391,7 @@ Examples:
 });
 
 // src/commands/tag-manager/write-commands.ts
-import { defineCommand as defineCommand200 } from "citty";
+import { defineCommand as defineCommand202 } from "citty";
 var CONTAINER_ARG_DESCRIPTION = "Numeric container id (optional only when one container is connected \u2014 run `baker tag-manager containers`)";
 var ENTITIES = [
   {
@@ -49345,10 +50447,10 @@ for (const { entity, noun, createHint } of ENTITIES) {
   });
 }
 function entityCommand(entity, noun, example) {
-  return defineCommand200({
+  return defineCommand202({
     meta: { name: entity, description: `Stage ${noun} changes on this chat's Tag Manager draft` },
     subCommands: {
-      create: defineCommand200({
+      create: defineCommand202({
         meta: {
           name: "create",
           description: `Stage a new ${noun}
@@ -49370,7 +50472,7 @@ Examples:
           });
         }
       }),
-      update: defineCommand200({
+      update: defineCommand202({
         meta: {
           name: "update",
           description: `Stage an update to an existing ${noun} (pass its id or path)`
@@ -49390,7 +50492,7 @@ Examples:
           });
         }
       }),
-      delete: defineCommand200({
+      delete: defineCommand202({
         meta: { name: "delete", description: `Stage the deletion of a ${noun} (pass its id or path)` },
         args: {
           id: { type: "positional", description: `${noun} id or path`, required: false },
@@ -49431,7 +50533,7 @@ function builtinTypes(args) {
   }
   return raw.split(",").map((entry) => entry.trim());
 }
-var builtinCommand = defineCommand200({
+var builtinCommand = defineCommand202({
   meta: {
     name: "builtin",
     description: `Enable or disable built-in variables
@@ -49441,7 +50543,7 @@ Examples:
   baker tag-manager builtin disable --types formId`
   },
   subCommands: {
-    enable: defineCommand200({
+    enable: defineCommand202({
       meta: { name: "enable", description: "Stage enabling built-in variables" },
       args: {
         types: { type: "string", description: "Comma-separated types", required: false },
@@ -49455,7 +50557,7 @@ Examples:
         });
       }
     }),
-    disable: defineCommand200({
+    disable: defineCommand202({
       meta: { name: "disable", description: "Stage disabling built-in variables" },
       args: {
         types: { type: "string", description: "Comma-separated types", required: false },
@@ -49473,7 +50575,7 @@ Examples:
 });
 
 // src/commands/tag-manager/index.ts
-var tagManagerCommand = defineCommand201({
+var tagManagerCommand = defineCommand203({
   meta: {
     name: "tag-manager",
     description: `Read and change what lives inside the client's Google Tag Manager container \u2014 tags, triggers, variables, folders and built-in variables.
@@ -49510,7 +50612,7 @@ Full guide: __tooling__/docs/tools/baker/tag-manager.md`
 });
 
 // src/commands/tags/index.ts
-import { defineCommand as defineCommand202 } from "citty";
+import { defineCommand as defineCommand204 } from "citty";
 
 // src/commands/tags/shared.ts
 function failApi3(err) {
@@ -49579,7 +50681,7 @@ async function listTags(json) {
 var listArgs9 = {
   json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable list" }
 };
-var listCommand17 = defineCommand202({
+var listCommand17 = defineCommand204({
   meta: {
     name: "list",
     description: "Effective tags for this chat (production + staged), with each tag's full readable config (secrets excluded) \u2014 reuse a stored value to pre-fill a change rather than asking the user. Refs printed here are what flow side-effect tagIds should use. Example: baker tags list"
@@ -49598,7 +50700,7 @@ async function listDraft3(chat) {
     failApi3(err);
   }
 }
-var draftCommand5 = defineCommand202({
+var draftCommand5 = defineCommand204({
   meta: {
     name: "draft",
     description: "Review the tag changes staged in this chat (read-only). Staged changes were approved via request_tag_input and apply when the chat is published; to amend or drop one, propose a follow-up change through the same tool (a delete on a tag_temp_* ref drops the staged create). Takes --chat <id> to read an earlier chat's staged changes instead."
@@ -49608,7 +50710,7 @@ var draftCommand5 = defineCommand202({
     await listDraft3(args.chat);
   }
 });
-var tagsCommand4 = defineCommand202({
+var tagsCommand4 = defineCommand204({
   meta: {
     name: "tags",
     description: `Read the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, \u2026) \u2014 production tags plus the changes staged in this chat.
@@ -49637,10 +50739,10 @@ Full guide: __tooling__/docs/tools/baker/tags.md`
 });
 
 // src/commands/testimonials/index.ts
-import { defineCommand as defineCommand206 } from "citty";
+import { defineCommand as defineCommand208 } from "citty";
 
 // src/commands/testimonials/get.ts
-import { defineCommand as defineCommand203 } from "citty";
+import { defineCommand as defineCommand205 } from "citty";
 registerSchema({
   command: "testimonials.get",
   description: "Get a single testimonial by ID",
@@ -49648,7 +50750,7 @@ registerSchema({
     id: { type: "string", description: "Testimonial ID", required: true }
   }
 });
-var getCommand6 = defineCommand203({
+var getCommand6 = defineCommand205({
   meta: { name: "get", description: "Get a single testimonial by ID. Example: baker testimonials get j571abc123" },
   args: {
     id: { type: "positional", description: "Testimonial ID", required: false },
@@ -49685,7 +50787,7 @@ var getCommand6 = defineCommand203({
 });
 
 // src/commands/testimonials/list.ts
-import { defineCommand as defineCommand204 } from "citty";
+import { defineCommand as defineCommand206 } from "citty";
 
 // src/commands/testimonials/emptyCorpusHints.ts
 function resolveEmptyReason({
@@ -49820,7 +50922,7 @@ function buildListParams(args) {
   }
   return params;
 }
-var listCommand18 = defineCommand204({
+var listCommand18 = defineCommand206({
   meta: {
     name: "list",
     description: "List testimonials with optional filters. Example: baker testimonials list --source google --sentiment positive"
@@ -49872,7 +50974,7 @@ var listCommand18 = defineCommand204({
 });
 
 // src/commands/testimonials/search.ts
-import { defineCommand as defineCommand205 } from "citty";
+import { defineCommand as defineCommand207 } from "citty";
 var FILTER_FLAGS2 = ["source", "rating-min", "rating-max", "status", "sentiment", "language", "tags"];
 function languageBiasHint(results, requestedLanguage) {
   if (requestedLanguage) {
@@ -49951,7 +51053,7 @@ function buildSearchRequest(query, args) {
   }
   return body;
 }
-var searchCommand3 = defineCommand205({
+var searchCommand3 = defineCommand207({
   meta: {
     name: "search",
     description: "Semantic search testimonials by text query. Uses hybrid BM25 + vector + reranking. Example: baker testimonials search 'great service' --rating-min 4"
@@ -50015,7 +51117,7 @@ var searchCommand3 = defineCommand205({
 var tagsCommand5 = makeTagsCommand("testimonials", "testimonial", "/api/testimonials/tags");
 
 // src/commands/testimonials/index.ts
-var testimonialsCommand = defineCommand206({
+var testimonialsCommand = defineCommand208({
   meta: {
     name: "testimonials",
     description: `Find and browse testimonials in Baker. Subcommands: search, get, list, tags.
@@ -50037,10 +51139,10 @@ Full guide: __tooling__/docs/tools/baker/testimonials.md`
 });
 
 // src/commands/videos/index.ts
-import { defineCommand as defineCommand213 } from "citty";
+import { defineCommand as defineCommand215 } from "citty";
 
 // src/commands/videos/delete.ts
-import { defineCommand as defineCommand207 } from "citty";
+import { defineCommand as defineCommand209 } from "citty";
 registerSchema({
   command: "videos.delete",
   description: "Delete a video by ID",
@@ -50054,7 +51156,7 @@ registerSchema({
     }
   }
 });
-var deleteCommand4 = defineCommand207({
+var deleteCommand4 = defineCommand209({
   meta: {
     name: "delete",
     description: "Delete a video by ID. Use --dry-run to preview. Example: baker videos delete j571abc123 --dry-run"
@@ -50095,7 +51197,7 @@ var deleteCommand4 = defineCommand207({
 });
 
 // src/commands/videos/get.ts
-import { defineCommand as defineCommand208 } from "citty";
+import { defineCommand as defineCommand210 } from "citty";
 registerSchema({
   command: "videos.get",
   description: "Get a single video by ID",
@@ -50103,7 +51205,7 @@ registerSchema({
     id: { type: "string", description: "Video ID", required: true }
   }
 });
-var getCommand7 = defineCommand208({
+var getCommand7 = defineCommand210({
   meta: { name: "get", description: "Get a single video by ID. Example: baker videos get j571abc123" },
   args: {
     id: { type: "positional", description: "Video ID", required: false },
@@ -50140,7 +51242,7 @@ var getCommand7 = defineCommand208({
 });
 
 // src/commands/videos/group.ts
-import { defineCommand as defineCommand209 } from "citty";
+import { defineCommand as defineCommand211 } from "citty";
 registerSchema({
   command: "videos.group",
   description: "List every clip and image that arrived in the same set as this video (carousel slides, one page)",
@@ -50149,7 +51251,7 @@ registerSchema({
     "group-key": { type: "string", description: "The set key directly, when you already have it", required: false }
   }
 });
-var groupCommand2 = defineCommand209({
+var groupCommand2 = defineCommand211({
   meta: {
     name: "group",
     description: "List every asset that arrived in the same set as this clip \u2014 the other slides of the Instagram post it came from, stills included. A carousel is authored to be read in order, so a clip pulled out of one is usually missing half its meaning. Example: baker videos group <videoId>"
@@ -50169,10 +51271,10 @@ var groupCommand2 = defineCommand209({
 });
 
 // src/commands/videos/ingest.ts
-import { mkdtemp as mkdtemp2, rm as rm7, stat as stat7 } from "fs/promises";
+import { mkdtemp as mkdtemp2, rm as rm7, stat as stat8 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import path37 from "path";
-import { defineCommand as defineCommand210 } from "citty";
+import path40 from "path";
+import { defineCommand as defineCommand212 } from "citty";
 
 // src/lib/streamUpload.ts
 import { createHash as createHash2 } from "crypto";
@@ -50336,7 +51438,7 @@ registerSchema({
     "dry-run": { type: "boolean", description: "Preview the operation without executing", required: false }
   }
 });
-var ingestCommand2 = defineCommand210({
+var ingestCommand2 = defineCommand212({
   meta: {
     name: "ingest",
     description: "Add a video to the library from a URL. A direct file URL is handed straight to Baker, which fetches it. A page URL (YouTube, TikTok, Vimeo, Instagram) is downloaded here first, then uploaded \u2014 and a direct URL that Baker cannot fetch falls back to that same path automatically.\n\nExample: baker videos ingest https://www.youtube.com/watch?v=abc123"
@@ -50452,35 +51554,35 @@ async function ingestByRoute(args, direct, country) {
 function reportYtDlpFailure(err) {
   const detail = `${err.stderrTail} ${err.message}`;
   if (isProxyFailure(ytDlpBlockSignal(detail))) {
-    fail7(
+    fail9(
       "Couldn't download that video: our connection to the internet was refused.",
       "This is Baker's egress proxy, not the link \u2014 its credentials look wrong or expired. The link is probably fine. Report it; retrying won't help until the proxy is fixed."
     );
   }
   if (isDrmProtected(detail)) {
-    fail7(
+    fail9(
       "That video is copy-protected, so it can't be added to the library.",
       "The publisher encrypted this one against downloading. Nothing will change that \u2014 not retrying, not a different region. Ask whoever owns the video for the original file and add it with `baker videos upload <file>`."
     );
   }
   if (isVimeoAuthFailure(detail)) {
-    fail7(
+    fail9(
       "Vimeo wouldn't hand over that video \u2014 Baker isn't signed in to Vimeo.",
       "Vimeo now refuses anonymous downloads entirely, so this needs a signed-in session and the one Baker holds has either expired or was never set. Nothing is wrong with the link. Report it so the Vimeo cookie can be refreshed; meanwhile download the file and use `baker videos upload <file>`."
     );
   }
   if (isRegionBlocked(detail)) {
-    fail7(
+    fail9(
       `That video isn't available in the region we're fetching from. ${err.stderrTail || err.message}`,
       "Re-run with `--country <two-letter code>` for a country where the video plays \u2014 e.g. `--country US`. Pick the one the video belongs to (the uploader's country is the usual answer); each attempt costs a paid connection, so choose rather than work through the list."
     );
   }
-  fail7(
+  fail9(
     `Couldn't download that video. ${err.stderrTail || err.message}`,
     isToolingOrBlockFailure(detail) ? "The site wouldn't hand over the video \u2014 usually the downloader being out of date against a site that changed, or the request being blocked. Retrying won't help, and the link is probably fine. Report it so the tool can be updated; meanwhile download the file and use `baker videos upload <file>`." : "Check the link is public and playable. Private or age-restricted videos can't be downloaded \u2014 download the file yourself and use `baker videos upload <file>`."
   );
 }
-function fail7(message, fix, code = "INGEST_FAILED") {
+function fail9(message, fix, code = "INGEST_FAILED") {
   writeJson({ ok: false, error: { code, message, fix } });
   process.exit(1);
 }
@@ -50492,13 +51594,13 @@ function reportIngestFailure(err) {
   if (err instanceof YtDlpError) reportYtDlpFailure(err);
   const detail = err instanceof Error ? err.message : String(err);
   if (detail.includes("timed out after")) {
-    fail7(
+    fail9(
       "That video took too long to download and was stopped part-way.",
       "Long or slow-serving videos can outrun the download window. Try a shorter clip, or download this one yourself and use `baker videos upload <file>`.",
       "INTERNAL_ERROR"
     );
   }
-  fail7(
+  fail9(
     `Couldn't add that video. ${detail}`,
     "This is a fault on Baker's side, not a problem with the link. Report it.",
     "INTERNAL_ERROR"
@@ -50522,7 +51624,7 @@ function ingestUrl(args) {
 }
 async function downloadThenIngest(args, country) {
   const vimeoCookie = captureVimeoCookie();
-  const workDir = await mkdtemp2(path37.join(tmpdir3(), "videos-ingest-"));
+  const workDir = await mkdtemp2(path40.join(tmpdir3(), "videos-ingest-"));
   try {
     const probe = await probeYtDlp({ url: args.url, country, vimeoCookie, cookieDir: workDir });
     if (isAudioOnly(probe.info)) {
@@ -50553,7 +51655,7 @@ async function downloadThenIngest(args, country) {
       // we allow to fetch it cannot drift apart.
       timeoutMs: downloadTimeoutMs(durationSeconds(probe.info))
     });
-    const stats = await stat7(filePath);
+    const stats = await stat8(filePath);
     if (stats.size > MAX_VIDEO_INGEST_BYTES) {
       throw new ApiError(
         "VALIDATION_ERROR",
@@ -50598,7 +51700,7 @@ async function uploadToAssetStore(filePath, sizeBytes) {
 }
 
 // src/commands/videos/search.ts
-import { defineCommand as defineCommand211 } from "citty";
+import { defineCommand as defineCommand213 } from "citty";
 registerSchema({
   command: "videos.search",
   description: "Search videos by text query. Only returns ready videos.",
@@ -50608,7 +51710,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand4 = defineCommand211({
+var searchCommand4 = defineCommand213({
   meta: {
     name: "search",
     description: "Semantic search videos by text query. Uses hybrid BM25 + vector + reranking. Example: baker videos search 'product demo' --tags tutorial"
@@ -50658,9 +51760,9 @@ var searchCommand4 = defineCommand211({
 var tagsCommand6 = makeTagsCommand("videos", "video", "/api/videos/tags");
 
 // src/commands/videos/upload.ts
-import { readFile as readFile23, stat as stat8 } from "fs/promises";
+import { readFile as readFile25, stat as stat9 } from "fs/promises";
 import { basename as basename3, extname as extname4 } from "path";
-import { defineCommand as defineCommand212 } from "citty";
+import { defineCommand as defineCommand214 } from "citty";
 var MIME_MAP = {
   ".mp4": "video/mp4",
   ".mov": "video/quicktime",
@@ -50702,7 +51804,7 @@ function detectContentType(filePath) {
 function isRemoteUrl3(value) {
   return /^https?:\/\//i.test(value);
 }
-var uploadCommand2 = defineCommand212({
+var uploadCommand2 = defineCommand214({
   meta: {
     name: "upload",
     description: "Upload a video to Baker \u2014 accepts a local file path OR a remote http(s) URL.\n\nLocal: auto-detects content type and uploads via Mux direct upload.\nRemote: hands off to `videos ingest` (direct fetch, or download-then-upload for a YouTube/TikTok/Vimeo page).\n\nExamples:\n  baker videos upload ./demo.mp4\n  baker videos upload https://www.youtube.com/watch?v=abc123"
@@ -50742,7 +51844,7 @@ var uploadCommand2 = defineCommand212({
       const originalFilename = basename3(filePath);
       const descriptionContext = args.context;
       if (args["dry-run"]) {
-        const fileStats = await stat8(filePath);
+        const fileStats = await stat9(filePath);
         writeJson({
           ok: true,
           dryRun: true,
@@ -50755,7 +51857,7 @@ var uploadCommand2 = defineCommand212({
         originalFilename,
         descriptionContext
       });
-      const fileBuffer = await readFile23(filePath);
+      const fileBuffer = await readFile25(filePath);
       const uploadResponse = await fetch(uploadUrl, {
         method: "PUT",
         headers: { "Content-Type": contentType },
@@ -50786,7 +51888,7 @@ var uploadCommand2 = defineCommand212({
 });
 
 // src/commands/videos/index.ts
-var videosCommand = defineCommand213({
+var videosCommand = defineCommand215({
   meta: {
     name: "videos",
     description: `Find and manage videos in Baker. Subcommands: search, get, upload, ingest, delete, tags.
@@ -50813,10 +51915,10 @@ Full guide: __tooling__/docs/tools/baker/videos.md`
 });
 
 // src/commands/winning-ads/index.ts
-import { defineCommand as defineCommand226 } from "citty";
+import { defineCommand as defineCommand228 } from "citty";
 
 // src/commands/winning-ads/advertisers.ts
-import { defineCommand as defineCommand214 } from "citty";
+import { defineCommand as defineCommand216 } from "citty";
 
 // src/commands/winning-ads/shared.ts
 function splitList2(value) {
@@ -50869,7 +51971,7 @@ function advertiserNormalizer(record, full) {
     last_synced_at: record.last_synced_at ?? null
   };
 }
-var advertisersCommand2 = defineCommand214({
+var advertisersCommand2 = defineCommand216({
   meta: {
     name: "advertisers",
     description: 'List corpus advertisers by name or domain. Find your own advertiser for --exclude-advertiser, or a competitor for --advertiser-id / winners. Example: baker winning-ads advertisers "Deel" --output md'
@@ -50927,7 +52029,7 @@ var advertisersCommand2 = defineCommand214({
 });
 
 // src/commands/winning-ads/brief.ts
-import { defineCommand as defineCommand215 } from "citty";
+import { defineCommand as defineCommand217 } from "citty";
 registerSchema({
   command: "winning-ads.brief",
   description: "Generate a creative brief grounded in strategically-similar winning ads. Optionally describe the target creative with --dna (JSON) and steer with --notes.",
@@ -50973,7 +52075,7 @@ function parseDna(raw) {
   }
   return parsed;
 }
-var briefCommand = defineCommand215({
+var briefCommand = defineCommand217({
   meta: {
     name: "brief",
     description: `Generate a creative brief from winning references. Example: baker winning-ads brief --dna '{"angle":"cost savings"}' --notes "B2B, LinkedIn video" --k 8`
@@ -51009,7 +52111,7 @@ var briefCommand = defineCommand215({
 });
 
 // src/commands/winning-ads/content.ts
-import { defineCommand as defineCommand216 } from "citty";
+import { defineCommand as defineCommand218 } from "citty";
 registerSchema({
   command: "winning-ads.content",
   description: "Read what's INSIDE one winning ad: the spoken transcript, the on-screen text, and the ad copy. Use this after `search`/`winners`/`feed` return a shortlist \u2014 pass an ad_id to understand a reference before reproducing it. Add --full for speech, pacing, and soundtrack detail. Video ads carry the transcript/on-screen text; static ads carry only the copy.",
@@ -51022,7 +52124,7 @@ registerSchema({
     }
   }
 });
-var contentCommand = defineCommand216({
+var contentCommand = defineCommand218({
   meta: {
     name: "content",
     description: "Read the transcript + on-screen text + copy of one winning ad. Example: baker winning-ads content adg_123 --platform meta --full --output md"
@@ -51071,7 +52173,7 @@ var contentCommand = defineCommand216({
 });
 
 // src/commands/winning-ads/feed.ts
-import { defineCommand as defineCommand217 } from "citty";
+import { defineCommand as defineCommand219 } from "citty";
 function buildFeedParams(input) {
   const params = {};
   const advertiser = splitList2(input.advertiser);
@@ -51123,7 +52225,7 @@ registerSchema({
     format: { type: "string", description: "Comma-separated formats to include (e.g. static,video)", required: false }
   }
 });
-var feedCommand = defineCommand217({
+var feedCommand = defineCommand219({
   meta: {
     name: "feed",
     description: "Winners across every brand you follow (browse, then trim per advertiser). Example: baker winning-ads feed --per-advertiser 5 --output md"
@@ -51208,7 +52310,7 @@ var feedCommand = defineCommand217({
 });
 
 // src/commands/winning-ads/follow.ts
-import { defineCommand as defineCommand218 } from "citty";
+import { defineCommand as defineCommand220 } from "citty";
 var PLATFORMS = ["meta", "linkedin"];
 registerSchema({
   command: "winning-ads.follow",
@@ -51223,7 +52325,7 @@ registerSchema({
     label: { type: "string", description: "Optional display label (defaults to the resolved name)", required: false }
   }
 });
-var followCommand = defineCommand218({
+var followCommand = defineCommand220({
   meta: {
     name: "follow",
     description: 'Follow a brand to track ALL its ads \u2014 every platform and country. --platform is how we read your input, not a limit. A domain tracks both Meta + LinkedIn. Example: baker winning-ads follow "deel.com" --platform meta'
@@ -51270,7 +52372,7 @@ var followCommand = defineCommand218({
 });
 
 // src/commands/winning-ads/follow-competitors.ts
-import { defineCommand as defineCommand219 } from "citty";
+import { defineCommand as defineCommand221 } from "citty";
 var PLATFORMS2 = ["meta", "linkedin"];
 var BATCH_TIMEOUT_MS = 3e5;
 function buildFollowBatchBody(input) {
@@ -51303,7 +52405,7 @@ registerSchema({
     }
   }
 });
-var followCompetitorsCommand = defineCommand219({
+var followCompetitorsCommand = defineCommand221({
   meta: {
     name: "follow-competitors",
     description: 'Follow many brands at once by domain \u2014 add every competitor in one call. Example: baker winning-ads follow-competitors "deel.com,notion.so,hubspot.com"'
@@ -51378,7 +52480,7 @@ var followCompetitorsCommand = defineCommand219({
 });
 
 // src/commands/winning-ads/following.ts
-import { defineCommand as defineCommand220 } from "citty";
+import { defineCommand as defineCommand222 } from "citty";
 registerSchema({
   command: "winning-ads.following",
   description: "List the brands you follow in your ad-dna library, with each one's status (ready vs still adding) and cached ad counts. A brand still adding has counts that are a lie in progress; one with `discovery_failed` has counts that are short because we couldn't finish looking, which is not the same as it running no ads.",
@@ -51432,7 +52534,7 @@ function followingNormalizer(record, full) {
     platforms: Array.isArray(record.platforms) ? record.platforms : []
   };
 }
-var followingCommand = defineCommand220({
+var followingCommand = defineCommand222({
   meta: {
     name: "following",
     description: "List brands you follow, with status (ready / adding\u2026) and cached counts. A brand's counts are only final once it is ready. Example: baker winning-ads following --output md"
@@ -51468,7 +52570,7 @@ var followingCommand = defineCommand220({
 });
 
 // src/commands/winning-ads/patterns.ts
-import { defineCommand as defineCommand221 } from "citty";
+import { defineCommand as defineCommand223 } from "citty";
 registerSchema({
   command: "winning-ads.patterns",
   description: "Mine what separates two cohorts of ads: pass a comma-list of winning ad ids (--winners) and a comma-list of weaker ad ids (--duds). Returns the discriminating DNA fields.",
@@ -51507,7 +52609,7 @@ function discriminatorRow(record) {
     top_values_duds: Array.isArray(record.top_values_b) ? record.top_values_b.join(", ") : ""
   };
 }
-var patternsCommand = defineCommand221({
+var patternsCommand = defineCommand223({
   meta: {
     name: "patterns",
     description: "Discover what separates winning ads from weak ones. Example: baker winning-ads patterns --winners a_1,a_2,a_3 --duds a_9,a_8 --output md"
@@ -51563,7 +52665,7 @@ var patternsCommand = defineCommand221({
 });
 
 // src/commands/winning-ads/search.ts
-import { defineCommand as defineCommand222 } from "citty";
+import { defineCommand as defineCommand224 } from "citty";
 registerSchema({
   command: "winning-ads.search",
   description: "Search the ad-dna corpus of scored winning ads. Returns a lean shortlist (advertiser, summary, scores, media_url) to pick a reference to reproduce.",
@@ -51671,7 +52773,7 @@ function buildSearchBody2(args) {
   }
   return body;
 }
-var searchCommand5 = defineCommand222({
+var searchCommand5 = defineCommand224({
   meta: {
     name: "search",
     description: "Search winning reference ads. Example: baker winning-ads search 'B2B SaaS before/after AI automation' --platform meta --format static --winner-category winner --exclude-advertiser adv_123 --output md"
@@ -51786,7 +52888,7 @@ var searchCommand5 = defineCommand222({
 });
 
 // src/commands/winning-ads/seeds.ts
-import { defineCommand as defineCommand223 } from "citty";
+import { defineCommand as defineCommand225 } from "citty";
 function leanRow(r) {
   return {
     key: r.key,
@@ -51814,7 +52916,7 @@ function makeSeedCommand(opts) {
       limit: { type: "number", description: "Max keys 1-100 (default 20)", required: false, default: 20 }
     }
   });
-  return defineCommand223({
+  return defineCommand225({
     meta: { name: opts.name, description: opts.description },
     args: {
       platform: { type: "string", description: "Single platform to segment on", required: false },
@@ -51863,7 +52965,7 @@ var formatsCommand = makeSeedCommand({
 });
 
 // src/commands/winning-ads/unfollow.ts
-import { defineCommand as defineCommand224 } from "citty";
+import { defineCommand as defineCommand226 } from "citty";
 registerSchema({
   command: "winning-ads.unfollow",
   description: "Stop following a brand \u2014 removes it from your ad-dna library by advertiser id.",
@@ -51871,7 +52973,7 @@ registerSchema({
     advertiser: { type: "string", description: "Advertiser id to unfollow", required: true }
   }
 });
-var unfollowCommand = defineCommand224({
+var unfollowCommand = defineCommand226({
   meta: {
     name: "unfollow",
     description: "Stop following a brand by advertiser id. Example: baker winning-ads unfollow adv_123"
@@ -51892,7 +52994,7 @@ var unfollowCommand = defineCommand224({
 });
 
 // src/commands/winning-ads/winners.ts
-import { defineCommand as defineCommand225 } from "citty";
+import { defineCommand as defineCommand227 } from "citty";
 registerSchema({
   command: "winning-ads.winners",
   description: "Top winning ads for one advertiser id (from `advertisers` or `following`). Returns lean winner cards; add --full for DNA + longevity.",
@@ -51902,7 +53004,7 @@ registerSchema({
     platform: { type: "string", description: "Filter to a single platform: meta|linkedin", required: false }
   }
 });
-var winnersCommand = defineCommand225({
+var winnersCommand = defineCommand227({
   meta: {
     name: "winners",
     description: "Top winning ads for a specific advertiser id. Example: baker winning-ads winners adv_123 --top 15 --output md"
@@ -51952,7 +53054,7 @@ var winnersCommand = defineCommand225({
 });
 
 // src/commands/winning-ads/index.ts
-var winningAdsCommand = defineCommand226({
+var winningAdsCommand = defineCommand228({
   meta: {
     name: "winning-ads",
     description: `Search the ad-dna corpus of scored "winning" ads for reference creatives to reproduce, and manage the brands your library tracks. Proxied through the Baker backend (BAKER_API_KEY) \u2014 no separate token needed.
@@ -52142,7 +53244,7 @@ function unknownFlagEnvelope(unknown, commandPath, suggestion) {
   };
 }
 function commandPathOf(root, argv) {
-  const path38 = [];
+  const path41 = [];
   let command = root;
   for (const token of argv) {
     if (token === "--" || token.startsWith("-")) {
@@ -52153,10 +53255,10 @@ function commandPathOf(root, argv) {
     if (next === void 0 || typeof next !== "object") {
       break;
     }
-    path38.push(token);
+    path41.push(token);
     command = next;
   }
-  return path38.join(" ");
+  return path41.join(" ");
 }
 function refuseUnknownFlags(root, argv) {
   const unknown = findUnknownFlags(root, argv);
@@ -52190,7 +53292,7 @@ function getCliVersion() {
 }
 
 // src/cli.ts
-var main = defineCommand227({
+var main = defineCommand229({
   meta: {
     name: "baker",
     version: getCliVersion(),
@@ -52209,6 +53311,7 @@ Introspection: Run 'baker schema <command>' to inspect argument schemas.`
     ads: adsCommand2,
     brand: brandCommand,
     analytics: analyticsCommand2,
+    experiment: experimentCommand,
     ga4: ga4Command,
     gsc: gscCommand,
     research: researchCommand,