@koda-sl/baker-cli 0.286.0-dev.93be96120 → 0.290.1

package/dist/cli.js

@@ -58,7 +58,7 @@ import {
   ulid,
   validateCanvasDeep,
   ytDlpBlockSignal
-} from "./chunk-LN5O53BG.js";
+} from "./chunk-V7BIRLPU.js";
 import {
   csvOrJson,
   daysAgoIso,
@@ -10509,14 +10509,14 @@ function collectionLine(collection) {
 }
 function accountsInTree(nodes) {
   const accounts = /* @__PURE__ */ new Set();
-  const walk = (node) => {
+  const walk2 = (node) => {
     accounts.add(node.customerId);
     for (const child of node.children) {
-      walk(child);
+      walk2(child);
     }
   };
   for (const node of nodes) {
-    walk(node);
+    walk2(node);
   }
   return accounts;
 }
@@ -10683,11 +10683,11 @@ function parseKeywordEntry(raw, defaultMatch) {
 function rawTextEntries(value, rawArgs) {
   return repeatedValues(rawArgs, "text", value).flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
 }
-function rawFileEntries(path42) {
-  if (typeof path42 !== "string" || path42.length === 0) {
+function rawFileEntries(path44) {
+  if (typeof path44 !== "string" || path44.length === 0) {
     return [];
   }
-  return readFileSync2(path42, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return readFileSync2(path44, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function keywordEntries(args, rawArgs) {
   const defaultMatch = typeof args["match-type"] === "string" ? args["match-type"].toUpperCase() : void 0;
@@ -10710,14 +10710,14 @@ function keywordEntries(args, rawArgs) {
   }
   return entries;
 }
-function loadJsonFileArg(path42) {
-  if (typeof path42 !== "string" || path42.length === 0) {
+function loadJsonFileArg(path44) {
+  if (typeof path44 !== "string" || path44.length === 0) {
     return {};
   }
-  const inline = path42.trimStart().startsWith("{");
-  const source = inline ? "inline JSON" : path42;
+  const inline = path44.trimStart().startsWith("{");
+  const source = inline ? "inline JSON" : path44;
   try {
-    const parsed = JSON.parse(inline ? path42 : readFileSync2(path42, "utf8"));
+    const parsed = JSON.parse(inline ? path44 : readFileSync2(path44, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       failWriteValidation(`${source} must contain a JSON object`);
     }
@@ -10854,10 +10854,10 @@ async function stageUpdate(kind, customerId, target, payload, hints2) {
 async function stageTarget(kind, customerId, target, hints2) {
   await stageGoogleOp({ kind, customerId, target }, hints2);
 }
-async function draftAction(path42, body, chat) {
+async function draftAction(path44, body, chat) {
   try {
     const chatId = resolveChatId(chat);
-    const response = await apiPost(path42, { chatId, ...body });
+    const response = await apiPost(path44, { chatId, ...body });
     writeJsonEnvelope(response);
   } catch (err) {
     handleGoogleError(err);
@@ -12799,6 +12799,25 @@ var CAPTURED_WITHOUT_ROLE = [
   "targetid"
 ].sort();
 
+// ../api/src/analytics/conversionNames.ts
+function normalizeConversionName(name) {
+  return name.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(" ").filter((word) => word !== "").map((word) => word.length > 3 && word.endsWith("s") ? word.slice(0, -1) : word).join(" ");
+}
+function findNameCollision(name, existing) {
+  const normalized = normalizeConversionName(name);
+  return existing.find((candidate) => candidate !== name && normalizeConversionName(candidate) === normalized) ?? null;
+}
+var STANDARD_CONVERSION_NAMES = [
+  { name: "Lead", meaning: "Somebody handed over contact details" },
+  { name: "Booked a call", meaning: "A meeting or demo was scheduled" },
+  { name: "Quote requested", meaning: "Somebody asked what it would cost" },
+  { name: "Purchase", meaning: "Money changed hands" },
+  { name: "Signed up", meaning: "An account or trial was created" },
+  { name: "Subscribed", meaning: "Somebody opted in to hear from them again" },
+  { name: "Downloaded", meaning: "A guide, price list or asset was taken" },
+  { name: "Contacted us", meaning: "A call, WhatsApp or email started from the page" }
+];
+
 // ../api/src/analytics/conversions.ts
 var CONVERSION_COUNT_MODES = ["once_per_visit", "every_time"];
 var PRIMARY_CONVERSION_TRIGGER = {
@@ -12820,6 +12839,9 @@ var MAX_CONVERSION_NAME = 80;
 
 // ../api/src/analytics/eventKey.ts
 var SEP = ":";
+function formEventKey(flowSlug, nodeId, triggerId) {
+  return ["form", flowSlug, nodeId, triggerId].join(SEP);
+}
 function parseEventKey(key) {
   const cut = key.indexOf(SEP);
   if (cut <= 0) return null;
@@ -14363,6 +14385,19 @@ var analyticsTimelineRowSchema = z28.object({
    * what made the server-sent half of the feed look unattached to the rest.
    */
   knownBy: z28.string().default(""),
+  /**
+   * What this row counts as under the company's own conversion definitions, or
+   * empty when it counts as nothing.
+   *
+   * The store's own key, projected rather than rebuilt here, so the feed and
+   * the reports cannot disagree about what one event was. Two rows carrying the
+   * same non-empty key are **one** conversion — the second is stored, listed,
+   * and marked as already counted rather than hidden, because a sender who
+   * posted a deal twice needs to see that the second request arrived.
+   *
+   * Only `event_stream` fills it; empty everywhere else.
+   */
+  conversionKey: z28.string().default(""),
   /**
    * `email` | `phone` — which of the two they gave.
    *
@@ -14403,6 +14438,17 @@ var analyticsTimelineRowSchema = z28.object({
   runId: z28.string(),
   engagementMs: z28.number().int().nonnegative(),
   scrollDepth: z28.number().int().nonnegative(),
+  /**
+   * The A/B test this row was stamped into, and which side the edge served —
+   * `a` for the page as it is, `b` for the new variant.
+   *
+   * Set only on rows a page under test produced, which is how a person's story
+   * can say which version they were shown. Empty on a server-sent row: a CRM
+   * knows nothing about the split, and the conversion it posts is attributed
+   * to a side by WHO did it (see `experiment_conversions`), never by a stamp.
+   */
+  experimentId: z28.string().default(""),
+  variant: z28.string().default(""),
   /** `success` | `failed` | `""` for a dispatch that has not settled yet. */
   outcome: z28.string(),
   /** What the destination said when it refused. Empty on success. */
@@ -15227,17 +15273,17 @@ function ignoredColumnHints(columns) {
     `Ignored ${columns.length} column(s) that are not part of a conversion: ${columns.join(", ")}. A conversion carries an order id, a date, and something to match on: a click id (gclid / gbraid / wbraid), an email, a phone, or all four of givenName + familyName + country + postalCode. Optionally a value + currency, conversionCount, and eventSource (WEB / APP / IN_STORE / PHONE / OTHER). A column named just \`Name\` is ignored on purpose \u2014 Google needs the first and last name separately, so split it before re-running.`
   ];
 }
-function readRowsFile(path42) {
-  const inline = path42.trimStart().startsWith("[") || path42.trimStart().startsWith("{");
+function readRowsFile(path44) {
+  const inline = path44.trimStart().startsWith("[") || path44.trimStart().startsWith("{");
   let text2;
   try {
-    text2 = inline ? path42 : readFileSync4(path42, "utf8");
+    text2 = inline ? path44 : readFileSync4(path44, "utf8");
   } catch (err) {
-    failWriteValidation(`could not read ${path42}: ${err instanceof Error ? err.message : String(err)}`);
+    failWriteValidation(`could not read ${path44}: ${err instanceof Error ? err.message : String(err)}`);
   }
   const parsed = parseConversionRowsText(text2);
   if (!parsed.ok) {
-    failWriteValidation(`${inline ? "the conversions passed inline" : path42}: ${parsed.error}`);
+    failWriteValidation(`${inline ? "the conversions passed inline" : path44}: ${parsed.error}`);
   }
   return { rows: parsed.rows, ignoredColumns: parsed.ignoredColumns };
 }
@@ -17076,19 +17122,19 @@ function failWriteValidation2(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg2(path42) {
-  if (typeof path42 !== "string" || path42.length === 0) {
+function loadJsonFileArg2(path44) {
+  if (typeof path44 !== "string" || path44.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync5(path42, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path44, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation2(`${path42} must contain a JSON object`);
+      failWriteValidation2(`${path44} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation2(`${path42} is not valid JSON: ${err.message}`);
+      failWriteValidation2(`${path44} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -17173,15 +17219,15 @@ function parseLocaleFlag(value) {
   }
   return { language: match[1], country: match[2].toUpperCase() };
 }
-function loadTargetingFileArg(path42) {
-  if (typeof path42 !== "string" || path42.length === 0) {
+function loadTargetingFileArg(path44) {
+  if (typeof path44 !== "string" || path44.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg2(path42);
+  const parsed = loadJsonFileArg2(path44);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
     failWriteValidation2(
-      `${path42} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+      `${path44} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
   return criteria;
@@ -17216,14 +17262,14 @@ function parseCsvLine(line) {
   cells.push(current);
   return cells.map((cell3) => cell3.trim());
 }
-function parseListFileArg(path42, maxRows) {
-  if (typeof path42 !== "string" || path42.length === 0) {
+function parseListFileArg(path44, maxRows) {
+  if (typeof path44 !== "string" || path44.length === 0) {
     return void 0;
   }
-  const raw = readFileSync5(path42, "utf8");
+  const raw = readFileSync5(path44, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation2(`${path42} needs a header row and at least one data row`);
+    failWriteValidation2(`${path44} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -17242,7 +17288,7 @@ function parseListFileArg(path42, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation2(`${path42} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation2(`${path44} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -17338,11 +17384,11 @@ function readPositionals(args) {
 function splitIdList(raw) {
   return raw.split(",").map((id) => id.trim()).filter(Boolean);
 }
-function idsFileEntries(path42) {
-  if (typeof path42 !== "string" || path42.length === 0) {
+function idsFileEntries(path44) {
+  if (typeof path44 !== "string" || path44.length === 0) {
     return [];
   }
-  return readFileSync5(path42, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+  return readFileSync5(path44, "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);
@@ -20062,9 +20108,9 @@ function compactRow(row) {
     ...destination.postUrn ? { postUrn: destination.postUrn } : {}
   };
 }
-function readPath(row, path42) {
+function readPath(row, path44) {
   let current = row;
-  for (const segment of path42.split(".")) {
+  for (const segment of path44.split(".")) {
     const record = asRecord2(current);
     if (!record) return void 0;
     current = record[segment];
@@ -20074,10 +20120,10 @@ function readPath(row, path42) {
 function projectFields(rows, paths) {
   return rows.map((row) => {
     const projected = {};
-    for (const path42 of paths) {
-      const value = readPath(row, path42);
+    for (const path44 of paths) {
+      const value = readPath(row, path44);
       if (value !== void 0) {
-        projected[path42] = value;
+        projected[path44] = value;
       }
     }
     return projected;
@@ -20332,14 +20378,14 @@ function collectionLine2(collection) {
 }
 function accountsInTree2(nodes) {
   const accounts = /* @__PURE__ */ new Set();
-  const walk = (node) => {
+  const walk2 = (node) => {
     accounts.add(node.accountId);
     for (const child of node.children) {
-      walk(child);
+      walk2(child);
     }
   };
   for (const node of nodes) {
-    walk(node);
+    walk2(node);
   }
   return accounts;
 }
@@ -21673,11 +21719,11 @@ var updateStatusSchema = z29.enum(UPDATE_STATUSES);
 function currencyMinimums2(currencyCode) {
   return CURRENCY_MINIMUMS2[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM2;
 }
-function validateDailyBudgetFloor(money, ctx, path42) {
+function validateDailyBudgetFloor(money, ctx, path44) {
   if (money?.currencyCode) {
     const min = currencyMinimums2(money.currencyCode).dailyBudgetMin;
     if (Number(money.amount) < min) {
-      ctx.addIssue({ code: "custom", path: path42, message: `below the ${min} ${money.currencyCode} daily minimum` });
+      ctx.addIssue({ code: "custom", path: path44, message: `below the ${min} ${money.currencyCode} daily minimum` });
     }
   }
 }
@@ -22437,19 +22483,19 @@ function failWriteValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg3(path42) {
-  if (typeof path42 !== "string" || path42.length === 0) {
+function loadJsonFileArg3(path44) {
+  if (typeof path44 !== "string" || path44.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync9(path42, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path44, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation3(`${path42} must contain a JSON object`);
+      failWriteValidation3(`${path44} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation3(`${path42} is not valid JSON: ${err.message}`);
+      failWriteValidation3(`${path44} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -25362,14 +25408,14 @@ function collectionLine3(collection) {
 }
 function accountsInTree3(nodes) {
   const accounts = /* @__PURE__ */ new Set();
-  const walk = (node) => {
+  const walk2 = (node) => {
     accounts.add(node.accountId);
     for (const child of node.children) {
-      walk(child);
+      walk2(child);
     }
   };
   for (const node of nodes) {
-    walk(node);
+    walk2(node);
   }
   return accounts;
 }
@@ -27184,6 +27230,9 @@ Full guides: __tooling__/docs/tools/baker/ads-<platform>.md (google|meta|linkedi
   }
 });
 
+// src/commands/analytics/index.ts
+import { readFileSync as readFileSync12 } from "fs";
+
 // ../api/src/event-ingest/arrivals.ts
 import { z as z31 } from "zod";
 
@@ -27997,50 +28046,325 @@ var ingestEnvelopeSchema = z32.object({ ok: z32.literal(true), data: ingestRespo
 // src/commands/analytics/index.ts
 import { defineCommand as defineCommand95 } from "citty";
 
+// src/commands/flows/shared.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
+import { join as join2 } from "path";
+var FLOWS_DIR = "src/lib/flow-engine/flows";
+function flowsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 6; i++) {
+    const candidate = join2(dir, FLOWS_DIR);
+    if (existsSync3(candidate)) {
+      return candidate;
+    }
+    const parent = join2(dir, "..");
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return join2(process.cwd(), FLOWS_DIR);
+}
+function failLocal(message) {
+  writeJson({ ok: false, error: { code: "NOT_FOUND", message } });
+  process.exit(1);
+}
+function listFlowSlugs() {
+  const dir = flowsDir();
+  if (!existsSync3(dir)) {
+    return [];
+  }
+  return readdirSync2(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && entry.name !== ".gitkeep").map((entry) => entry.name).sort();
+}
+function flowDataPath(slug) {
+  return join2(flowsDir(), slug, "_data.json");
+}
+function writeFlowTree(slug, tree) {
+  writeFileSync3(flowDataPath(slug), `${JSON.stringify(tree, null, 2)}
+`, "utf-8");
+}
+function walkNodes(node, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  acc.push(node);
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) walkNodes(child, acc);
+  }
+  return acc;
+}
+function collectSideEffects(tree) {
+  return walkNodes(tree).flatMap(
+    (node) => Array.isArray(node.sideEffects) ? node.sideEffects.filter((sideEffect) => Boolean(sideEffect) && typeof sideEffect === "object").map((sideEffect) => ({ node, sideEffect })) : []
+  );
+}
+function flowExists(slug) {
+  return existsSync3(join2(flowsDir(), slug, "_data.json"));
+}
+function readFlowTree(slug) {
+  const path44 = join2(flowsDir(), slug, "_data.json");
+  if (!existsSync3(path44)) {
+    failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
+  }
+  try {
+    return JSON.parse(readFileSync11(path44, "utf-8"));
+  } catch (error) {
+    failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function isConfigured(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function nodeMeta(record) {
+  const nodeId = typeof record.id === "string" ? record.id : "";
+  const nodeName = typeof record.name === "string" ? record.name : void 0;
+  return { nodeId, ...nodeName ? { nodeName } : {} };
+}
+function widgetNodeStatus(record, meta) {
+  const nodeData = record.nodeData;
+  const nodeType = nodeData?.type;
+  if (typeof nodeType !== "string" || !FLOW_RESOURCE_NODE_TYPES.includes(nodeType)) {
+    return null;
+  }
+  const external = nodeData?.form?.external;
+  const selected = external != null && typeof external === "object";
+  const name = selected ? external.name : void 0;
+  return {
+    ...meta,
+    target: "node",
+    kind: nodeType,
+    status: selected ? `${nodeType} \u2014 selected${typeof name === "string" ? ` "${name}"` : ""}` : `${nodeType} \u2014 not selected`,
+    needsInput: !selected
+  };
+}
+function sideEffectNeedsInput(raw) {
+  const effect = raw;
+  const type = effect?.type;
+  if (typeof type !== "string" || !FLOW_SECRET_SIDE_EFFECT_TYPES.includes(type)) {
+    return false;
+  }
+  const configured = isConfigured(effect?.encryptedConfig);
+  if (!isFlowOauthSideEffect(type)) return !configured;
+  return !isConfigured(effect?.oauthProviderId) || !configured;
+}
+function sideEffectStatus(raw, meta) {
+  const effect = raw;
+  const type = effect?.type;
+  if (typeof type !== "string" || !FLOW_SECRET_SIDE_EFFECT_TYPES.includes(type)) {
+    return null;
+  }
+  const configured = isConfigured(effect?.encryptedConfig);
+  const oauth = isFlowOauthSideEffect(type);
+  const connected = isConfigured(effect?.oauthProviderId);
+  const needs = FLOW_SECRET_FIELDS[type];
+  const status = oauth ? `${type} \u2014 connection ${connected ? "[connected]" : "[needs connection]"}, config ${configured ? "[set]" : "[missing]"}` : configured ? `${type} \u2014 [configured]` : `${type} \u2014 [missing]${needs.length > 0 ? ` (needs: ${needs.join(", ")})` : ""}`;
+  return {
+    ...meta,
+    target: "sideEffect",
+    ...typeof effect?.id === "string" ? { sideEffectId: effect.id } : {},
+    kind: type,
+    status,
+    needsInput: sideEffectNeedsInput(effect)
+  };
+}
+function requestFlowInputCall(slug, status) {
+  const args = status.target === "node" ? `{ target: "node", flowSlug: "${slug}", nodeId: "${status.nodeId}", nodeType: "${status.kind}" }` : `{ target: "sideEffect", flowSlug: "${slug}", nodeId: "${status.nodeId}", sideEffectId: "${status.sideEffectId}", sideEffectType: "${status.kind}" }`;
+  return `request_flow_input with ${args}`;
+}
+function collectConfigStatus(node, acc) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const record = node;
+  const meta = nodeMeta(record);
+  const widget = widgetNodeStatus(record, meta);
+  if (widget) {
+    acc.push(widget);
+  }
+  if (Array.isArray(record.sideEffects)) {
+    for (const raw of record.sideEffects) {
+      const status = sideEffectStatus(raw, meta);
+      if (status) {
+        acc.push(status);
+      }
+    }
+  }
+  if (Array.isArray(record.children)) {
+    for (const child of record.children) {
+      collectConfigStatus(child, acc);
+    }
+  }
+}
+function redactTree(node) {
+  if (Array.isArray(node)) {
+    return node.map(redactTree);
+  }
+  if (!node || typeof node !== "object") {
+    return node;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "encryptedConfig") {
+      out[key] = isConfigured(value) ? "[configured]" : value;
+    } else {
+      out[key] = redactTree(value);
+    }
+  }
+  return out;
+}
+function stepNameKey(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toUpperCase();
+}
+function isUsableStepNameKey(key) {
+  return /^[\p{ID_Start}$_][\p{ID_Continue}$‌‍]*$/u.test(key);
+}
+
 // src/commands/analytics/conversionArgs.ts
 var ConversionArgsError = class extends Error {
 };
+function allValues(flag, argv) {
+  const values = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === flag) {
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) values.push(next);
+      continue;
+    }
+    if (arg.startsWith(`${flag}=`)) values.push(arg.slice(flag.length + 1));
+  }
+  return values.map((value) => value.trim()).filter((value) => value !== "");
+}
 function onlyOnce(value, flag, argv) {
   if (value === void 0) return void 0;
   const given = argv.filter((arg) => arg === flag || arg.startsWith(`${flag}=`)).length;
   if (given > 1) {
     throw new ConversionArgsError(
-      `${flag} was given ${given} times and only the last would have been used. Count one outcome per call.`
+      `${flag} was given ${given} times and only the last would have been used. It takes one value.`
     );
   }
   const trimmed = String(value).trim();
   return trimmed === "" ? void 0 : trimmed;
 }
-function parseConversionsArgs(raw, argv) {
-  const eventKey = onlyOnce(raw.event, "--event", argv);
-  const name = onlyOnce(raw.name, "--name", argv);
-  const countMode = onlyOnce(raw["count-mode"], "--count-mode", argv);
-  const remove = onlyOnce(raw.remove, "--remove", argv);
-  if (eventKey !== void 0 && name === void 0) {
-    throw new ConversionArgsError("--event needs --name: a conversion nobody named is a row labelled with a UUID.");
+function repeatable(flag, cittyValue, argv) {
+  const fromArgv = allValues(flag, argv);
+  if (fromArgv.length > 0) return fromArgv;
+  if (cittyValue === void 0) return [];
+  const trimmed = String(cittyValue).trim();
+  return trimmed === "" ? [] : [trimmed];
+}
+function checkFlagShape(args) {
+  if (args.eventKeys.length > 0 && args.name === void 0 && args.countMode === void 0) {
+    throw new ConversionArgsError(
+      "--event needs --name: a conversion nobody named is a row labelled with a UUID. (--event with only --count-mode changes how an event already counted is counted.)"
+    );
   }
-  if (name !== void 0 && eventKey === void 0 && remove === void 0) {
+  if (args.name !== void 0 && args.eventKeys.length === 0 && args.renameTo === void 0) {
     throw new ConversionArgsError("--name needs --event, naming which event to count.");
   }
-  if (eventKey !== void 0 && parseEventKey(eventKey) === null) {
+  if (args.renameFrom !== void 0 && args.renameTo === void 0) {
+    throw new ConversionArgsError('--rename needs --to: `--rename "Lead form" --to "Lead"`.');
+  }
+  if (args.renameTo !== void 0 && args.renameFrom === void 0) {
     throw new ConversionArgsError(
-      `"${eventKey}" is not an event key. Run with --candidates and copy one; they look like form:<form>:<step>:<trigger>, submit:<form>, page:<name> or exit:<host>.`
+      '--to needs --rename, naming which outcome to rename: `--rename "Lead form" --to "Lead"`.'
     );
   }
+}
+function checkEventKeys(eventKeys) {
+  for (const eventKey of eventKeys) {
+    if (parseEventKey(eventKey) === null) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is not an event key. Run with --candidates (or --flow <slug> for one Form) and copy one; they look like form:<form>:<step>:<trigger>, submit:<form>, page:<name> or exit:<host>.`
+      );
+    }
+  }
+}
+function readDays(raw) {
+  if (raw === void 0) return void 0;
+  const days = Number(raw);
+  if (!Number.isFinite(days) || days <= 0) {
+    throw new ConversionArgsError("--days must be a positive number of days.");
+  }
+  return days;
+}
+function parseConversionsArgs(raw, argv) {
+  const countMode = onlyOnce(raw["count-mode"], "--count-mode", argv);
   if (countMode !== void 0 && !CONVERSION_COUNT_MODES.includes(countMode)) {
     throw new ConversionArgsError(`--count-mode must be one of ${CONVERSION_COUNT_MODES.join(", ")}.`);
   }
-  const days = raw.days === void 0 ? void 0 : Number(raw.days);
-  if (days !== void 0 && (!Number.isFinite(days) || days <= 0)) {
-    throw new ConversionArgsError("--days must be a positive number of days.");
+  const args = {
+    eventKeys: repeatable("--event", raw.event, argv),
+    removeKeys: repeatable("--remove", raw.remove, argv),
+    name: onlyOnce(raw.name, "--name", argv),
+    countMode,
+    renameFrom: onlyOnce(raw.rename, "--rename", argv),
+    renameTo: onlyOnce(raw.to, "--to", argv),
+    removeName: onlyOnce(raw["remove-name"], "--remove-name", argv),
+    flowSlug: onlyOnce(raw.flow, "--flow", argv),
+    candidates: raw.candidates === true,
+    days: readDays(raw.days)
+  };
+  checkFlagShape(args);
+  checkEventKeys(args.eventKeys);
+  return args;
+}
+function existingNames(existing) {
+  return [...new Set(existing.map((row) => row.name))];
+}
+function checkNameCollision(name, existing) {
+  const collision = findNameCollision(name, existingNames(existing));
+  if (collision === null) return;
+  throw new ConversionArgsError(
+    `This company already counts "${collision}", and "${name}" would be a second row for the same outcome \u2014 Baker groups by exact name, so the number would be split in two. Use "${collision}" to make them one number, or pick a name that means something different.`
+  );
+}
+function under(name, existing) {
+  const rows = existing.filter((row) => row.name === name);
+  if (rows.length === 0) {
+    throw new ConversionArgsError(
+      `Nothing is counted under "${name}". This company counts: ${existingNames(existing).join(", ") || "nothing yet"}.`
+    );
   }
-  return { eventKey, name, countMode, remove, candidates: raw.candidates === true, days };
+  return rows;
 }
-function conversionsWrite(args) {
-  const set = args.eventKey !== void 0 && args.name !== void 0 ? [{ eventKey: args.eventKey, name: args.name, ...args.countMode ? { countMode: args.countMode } : {} }] : void 0;
-  const remove = args.remove !== void 0 ? [args.remove] : void 0;
-  if (!set && !remove) return null;
-  return { ...set ? { set } : {}, ...remove ? { remove } : {} };
+function setFromEvents(args, existing) {
+  if (args.eventKeys.length === 0) return [];
+  if (args.name !== void 0) {
+    checkNameCollision(args.name, existing);
+    const name = args.name;
+    return args.eventKeys.map((eventKey) => ({
+      eventKey,
+      name,
+      ...args.countMode ? { countMode: args.countMode } : {}
+    }));
+  }
+  return args.eventKeys.map((eventKey) => {
+    const current = existing.find((row) => row.eventKey === eventKey);
+    if (!current) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is not counted, so there is no count mode to change. Add it with --event "${eventKey}" --name "<what a person calls it>" --count-mode ${args.countMode}.`
+      );
+    }
+    return { eventKey, name: current.name, countMode: args.countMode };
+  });
+}
+function setFromRename(args, existing) {
+  if (args.renameFrom === void 0 || args.renameTo === void 0) return [];
+  const renameTo = args.renameTo;
+  checkNameCollision(renameTo, existing);
+  return under(args.renameFrom, existing).map((row) => ({
+    eventKey: row.eventKey,
+    name: renameTo,
+    countMode: row.countMode
+  }));
+}
+function conversionsWrite(args, existing) {
+  const set = [...setFromEvents(args, existing), ...setFromRename(args, existing)];
+  const remove = [
+    ...args.removeKeys,
+    ...args.removeName === void 0 ? [] : under(args.removeName, existing).map((row) => row.eventKey)
+  ];
+  if (set.length === 0 && remove.length === 0) return null;
+  return { ...set.length > 0 ? { set } : {}, ...remove.length > 0 ? { remove } : {} };
 }
 
 // src/commands/analytics/conversionHints.ts
@@ -28078,6 +28402,163 @@ function conversionHints(definitions, candidates, askedForCandidates) {
   }
   return hints2;
 }
+function namingHints(definitions) {
+  const names = [...new Set(definitions.map((row) => row.name))];
+  if (names.length === 0) {
+    return [
+      `Nothing is named yet, so the first name sets the vocabulary for this company. Start from the standard set \u2014 ${STANDARD_CONVERSION_NAMES.map((entry) => entry.name).join(", ")} \u2014 and stay in the company's own language once one exists.`
+    ];
+  }
+  return [
+    `Names in use here: ${names.join(", ")}. Reuse one EXACTLY when another Form produces the same outcome \u2014 that is what makes them one number \u2014 and use \`--rename "<old>" --to "<existing>"\` to merge two that should always have been one.`
+  ];
+}
+
+// src/commands/analytics/conversionList.ts
+function mergeStoredWithCounts(stored, reported) {
+  const counts = new Map(reported.map((row) => [row.name, row]));
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of stored) {
+    const group = groups.get(row.name) ?? [];
+    group.push(row);
+    groups.set(row.name, group);
+  }
+  return [...groups.entries()].map(([name, rows]) => {
+    const modes = new Set(rows.map((row) => row.countMode));
+    const counted = counts.get(name);
+    return {
+      name,
+      eventKeys: rows.map((row) => row.eventKey).sort(),
+      // A real state and usually an editing accident, which is why it is said
+      // out loud rather than resolved to one of them.
+      countMode: modes.size === 1 ? [...modes][0] : "mixed",
+      // Zero rather than absent: an outcome that is counted and has never
+      // fired is the most actionable row on this report, and dropping it
+      // would make it indistinguishable from one nobody has named.
+      conversions: counted?.conversions ?? 0,
+      convertingVisits: counted?.convertingVisits ?? 0,
+      lastSeen: counted?.lastSeen ?? null
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/commands/analytics/flowConversionKeys.ts
+function walk(node, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  const record = node;
+  acc.push(record);
+  if (Array.isArray(record.children)) for (const child of record.children) walk(child, acc);
+  return acc;
+}
+function flowConversionCandidates(tree, slug) {
+  const primary = [];
+  const secondary = [];
+  for (const node of walk(tree)) {
+    const id = typeof node.id === "string" ? node.id : null;
+    if (!id) continue;
+    const triggers = flowNodeTriggers(node.nodeData);
+    for (const triggerId of triggers.available) {
+      const candidate = {
+        eventKey: formEventKey(slug, id, triggerId),
+        nodeId: id,
+        nodeName: typeof node.name === "string" ? node.name : id,
+        nodeType: triggers.type,
+        triggerId,
+        isCompletion: triggers.completion === triggerId
+      };
+      (candidate.isCompletion ? primary : secondary).push(candidate);
+    }
+  }
+  return [
+    ...primary,
+    ...secondary,
+    {
+      eventKey: `submit:${slug}`,
+      nodeId: null,
+      nodeName: "the Form ran out of steps",
+      nodeType: null,
+      triggerId: null,
+      // A Form reaching its last node is as primary as an outcome gets for a
+      // Form with no widget in it — but it never fires on one that ends in a
+      // booking widget or a redirect, so it does not lead the list.
+      isCompletion: false
+    }
+  ];
+}
+function formKeyRefusal(eventKey, tree, slug) {
+  const parsed = parseEventKey(eventKey);
+  if (!parsed || parsed.family !== "form" || parsed.flowSlug !== slug) return null;
+  const node = walk(tree).find((candidate) => candidate.id === parsed.nodeId);
+  if (!node) {
+    return {
+      message: `"${slug}" has no step with id "${parsed.nodeId}", so this key would be stored and count zero forever.`,
+      fix: `Steps in this Form: ${walk(tree).map((n) => `${String(n.id)} (${String(n.name ?? "unnamed")})`).join(", ")}. \`baker analytics conversions --flow ${slug}\` prints each one already spelled as an event key.`
+    };
+  }
+  const triggers = flowNodeTriggers(node.nodeData);
+  if (!triggers.known || triggers.available.includes(parsed.triggerId)) return null;
+  return {
+    message: `Step "${String(node.name ?? node.id)}" never raises \`${parsed.triggerId}\`, so counting it would score zero however many people reach that step.`,
+    fix: triggers.available.length > 0 ? `It raises: ${triggers.available.join(", ")}.` : triggers.why ?? "That step raises nothing a conversion could be counted on."
+  };
+}
+function joinFlowConversions(candidates, definitions) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    for (const key of definition.eventKeys) byKey.set(key, definition.name);
+  }
+  return candidates.map((candidate) => ({ ...candidate, countedAs: byKey.get(candidate.eventKey) ?? null }));
+}
+function flowConversionHints(slug, rows, noConversionReason) {
+  const counted = rows.filter((row) => row.countedAs !== null);
+  if (counted.length > 0) {
+    return [
+      `Baker counts ${counted.length} of this Form's endings: ${counted.map((row) => `${row.countedAs} (${row.nodeName})`).join(
+        ", "
+      )}. Every other ending here scores nothing \u2014 count another with \`--event <key> --name <outcome>\`, reusing the SAME name to make two Forms one number.`
+    ];
+  }
+  if (noConversionReason) {
+    return [
+      `Nothing here is counted, and that is on purpose: this Form declares no outcome \u2014 "${noConversionReason}". Leave it alone unless that has stopped being true.`
+    ];
+  }
+  const deepestFirst = [...rows].reverse();
+  const suggestion = deepestFirst.find((row) => row.isCompletion && row.nodeType !== "text") ?? deepestFirst.find((row) => row.isCompletion) ?? rows[rows.length - 1];
+  return [
+    `Nothing on "${slug}" is counted, so it converts nobody on every report however many people finish it \u2014 Baker never guesses which ending is the point of a Form.`,
+    ...suggestion ? [
+      `Name its outcome: \`baker analytics conversions --event "${suggestion.eventKey}" --name "<what a person calls it>"\` (that key is "${suggestion.nodeName}"). It applies at once and rescores the whole history; nothing is staged and there is nothing to publish.`
+    ] : [],
+    `If this Form has no outcome of its own \u2014 it hands the visitor to a shop, a portal or a funnel that converts them there \u2014 say so instead, with \`noConversion: { "reason": "\u2026" }\` on its first step.`
+  ];
+}
+function flowCoverage(forms, definitions) {
+  return forms.map(({ slug, tree }) => {
+    const rows = joinFlowConversions(flowConversionCandidates(tree, slug), definitions);
+    const declared = tree?.noConversion?.reason;
+    const seen = /* @__PURE__ */ new Set();
+    return {
+      slug,
+      counted: rows.filter((row) => row.countedAs !== null).filter((row) => {
+        const key = `${row.countedAs} ${row.nodeName}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      }).map((row) => ({ name: String(row.countedAs), step: row.nodeName })),
+      noConversion: typeof declared === "string" && declared.trim() !== "" ? declared.trim() : null
+    };
+  });
+}
+function flowCoverageHints(coverage) {
+  const unset = coverage.filter((row) => row.counted.length === 0 && row.noConversion === null);
+  if (unset.length === 0) return [];
+  return [
+    `${unset.length} of ${coverage.length} Form(s) here count nothing, so every report shows them converting nobody: ${unset.map((row) => row.slug).join(
+      ", "
+    )}. Read each one's endings with \`baker analytics conversions --flow <slug>\` and name the outcome, or declare on its first step why it has none.`
+  ];
+}
 
 // src/commands/analytics/hints.ts
 var SEVERE_STEP_DROP = 0.6;
@@ -28960,26 +29441,93 @@ Examples:
     }
   });
 })();
+function localFormKeyRefusal(eventKey) {
+  const parsed = parseEventKey(eventKey);
+  if (!parsed || parsed.family !== "form") return null;
+  if (!flowExists(parsed.flowSlug)) return null;
+  return formKeyRefusal(eventKey, readFlowTree(parsed.flowSlug), parsed.flowSlug);
+}
+function refuseUnmatchableKey(eventKey) {
+  const refusal = eventKey === void 0 ? null : localFormKeyRefusal(eventKey);
+  if (!refusal) return;
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message: refusal.message, fix: refusal.fix } });
+  process.exit(1);
+}
+function readWorkspaceFlows() {
+  return listFlowSlugs().flatMap((slug) => {
+    try {
+      return [{ slug, tree: JSON.parse(readFileSync12(flowDataPath(slug), "utf-8")) }];
+    } catch {
+      return [];
+    }
+  });
+}
+function readFlowConversions2(slug, definitions) {
+  const tree = readFlowTree(slug);
+  const declared = tree.noConversion;
+  const reason = declared && typeof declared === "object" && typeof declared.reason === "string" ? String(declared.reason) : null;
+  return {
+    slug,
+    noConversionReason: reason,
+    endings: joinFlowConversions(flowConversionCandidates(tree, slug), definitions)
+  };
+}
+function conversionsEnvelope(args, definitions, candidates) {
+  const flow = args.flowSlug === void 0 ? null : readFlowConversions2(args.flowSlug, definitions);
+  const forms = flow === null ? readWorkspaceFlows() : [];
+  const coverage = flowCoverage(forms, definitions);
+  const hints2 = [
+    ...flow ? flowConversionHints(flow.slug, flow.endings, flow.noConversionReason) : [],
+    ...flowCoverageHints(coverage),
+    ...conversionHints(definitions, candidates, args.candidates),
+    ...namingHints(definitions)
+  ];
+  return {
+    ok: true,
+    data: {
+      definitions,
+      ...flow ? { flow } : {},
+      ...coverage.length > 0 ? { flows: coverage } : {},
+      ...args.candidates ? { candidates } : {}
+    },
+    ...hints2.length > 0 ? { hints: hints2 } : {}
+  };
+}
 var conversionsCommand3 = (() => {
   const args = {
     event: {
       type: "string",
-      description: "The event to start counting, from the `candidates` list: form:<form>:<step>:<trigger>, submit:<form>, page:<name>, or exit:<host>. Requires --name. Applies immediately and scores the WHOLE history, not just from now on \u2014 so counting the right event today also corrects last month's reports",
+      description: "The event to start counting, from the `candidates` or `--flow` list: form:<form>:<step>:<trigger>, submit:<form>, page:<name>, or exit:<host>. Requires --name. REPEATABLE \u2014 pass it several times with one --name to count all of them as that single outcome, which is the whole point of the name. Applies immediately and scores the WHOLE history, not just from now on, so counting the right event today also corrects last month's reports",
       required: false
     },
     name: {
       type: "string",
-      description: "What to call this outcome on every report \u2014 'Booked a call', 'Quote requested'. Reuse the SAME name on two events and they become one row and one number, which is how a call booked on three different Forms reads as one outcome rather than three",
+      description: "What to call this outcome on every report \u2014 'Booked a call', 'Quote requested'. Baker groups by EXACT name: reuse one this company already counts and the two become one row and one number, which is how a call booked on three Forms reads as one outcome. Read the existing names first (run with no flags) and reuse one before inventing another; a name that only differs by case, accent, punctuation or a plural is refused, because it would split the number in two",
+      required: false
+    },
+    rename: {
+      type: "string",
+      description: "An outcome's current name. With --to, renames every event counted under it. Renaming ONTO a name that already exists MERGES them into one row and one number \u2014 the way to fix a company whose Forms each invented their own word for the same outcome",
+      required: false
+    },
+    to: {
+      type: "string",
+      description: "The new name for --rename",
+      required: false
+    },
+    "remove-name": {
+      type: "string",
+      description: "Stop counting an outcome entirely, by name \u2014 removes every event counted under it. Use --remove for a single event key instead",
       required: false
     },
     "count-mode": {
       type: "string",
-      description: "once_per_visit (default) or every_time. Ask whether doing it twice in one visit is one outcome or two: a booking clicked twice is one booking, a guide downloaded twice is two downloads. Getting this wrong inflates the rate every budget is set by",
+      description: "once_per_visit (default) or every_time. Ask whether doing it twice in one visit is one outcome or two: a booking clicked twice is one booking, a guide downloaded twice is two downloads. Getting this wrong inflates the rate every budget is set by. Pass it with --event and no --name to change the mode of something already counted, keeping its name",
       required: false
     },
     remove: {
       type: "string",
-      description: "An event key to stop counting. Removes it from the history too, for the same reason adding it fills the history in",
+      description: "An event key to stop counting. REPEATABLE. Removes it from the history too, for the same reason adding it fills the history in",
       required: false
     },
     candidates: {
@@ -28987,6 +29535,11 @@ var conversionsCommand3 = (() => {
       description: "Also list every event these pages actually produced, ranked by volume, with whether it is already counted. This is where an event key comes from \u2014 do not invent one. Off by default because a busy company produces hundreds of rows",
       required: false
     },
+    flow: {
+      type: "string",
+      description: "A Form slug. Lists that Form's own endings already spelled as event keys, each with the name Baker counts it under or nothing \u2014 read off the Form's file, so it works on a Form built minutes ago that has never been visited, which is exactly when --candidates is empty. Use it whenever you create or edit a Form: it is the only way to see that the Form counts nothing before it is published counting nothing",
+      required: false
+    },
     days: {
       type: "string",
       description: "Lookback for the counts and for --candidates. Default 30",
@@ -28995,34 +29548,33 @@ var conversionsCommand3 = (() => {
   };
   registerSchema({
     command: "analytics.conversions",
-    description: "Read or change what this company counts as a conversion",
+    description: "Read or change what this company counts as a conversion. Also `--flow <slug>` for one Form's own endings as event keys, whether or not any of them has fired.",
     args
   });
   return defineCommand95({
     meta: {
       name: "conversions",
-      description: "What this company counts as a conversion, and what each one produced. Run with no flags first: an empty `definitions` list means every conversion number in every other report is zero \u2014 not because nobody converted, but because nothing is marked as converting, and Baker never guesses. Add `--candidates` to see everything these pages actually do (every Form step, every data-baker-* event, every outbound destination) with counts and whether it is already counted; that list is where an event key comes from, so never invent one. Then `--event <key> --name 'Booked a call'` to count it. It applies IMMEDIATELY and retroactively \u2014 the whole history is rescored, so a company that has been running for a month gets a month of correct numbers the moment you name the right event. Nothing here is staged and publishing is not involved. Two events given the SAME --name are one row and one number. `--remove <key>` stops counting one."
+      description: "What this company counts as a conversion, and what each one produced. Run with no flags first: an empty `definitions` list means every conversion number in every other report is zero \u2014 not because nobody converted, but because nothing is marked as converting, and Baker never guesses. Add `--candidates` to see everything these pages actually do (every Form step, every data-baker-* event, every outbound destination) with counts and whether it is already counted; that list is where an event key comes from, so never invent one. Then `--event <key> --name 'Booked a call'` to count it. It applies IMMEDIATELY and retroactively \u2014 the whole history is rescored, so a company that has been running for a month gets a month of correct numbers the moment you name the right event. Nothing here is staged and publishing is not involved. Two events given the SAME --name are one row and one number. `--remove <key>` stops counting one. `--flow <slug>` answers the other direction \u2014 what one Form counts, with every ending it has already spelled as an event key, read from the Form itself so it works before a single visitor has seen it. Run it whenever you create or edit a Form: a Form nobody named an outcome for is published converting nobody, and no report says so."
     },
     args,
     run: async ({ args: raw }) => {
       try {
         const args2 = parseConversionsArgs(raw, process.argv);
-        const write2 = conversionsWrite(args2);
-        if (write2) {
-          await apiPost("/api/analytics/conversions", write2);
-        }
+        for (const eventKey of args2.eventKeys) refuseUnmatchableKey(eventKey);
+        const before = await apiPost("/api/analytics/conversions", {});
+        const write2 = conversionsWrite(args2, before.data.definitions);
+        const stored = write2 ? (await apiPost("/api/analytics/conversions", write2)).data.definitions : before.data.definitions;
         const report = await apiPost("/api/analytics/query", {
           preset: "conversions",
           days: args2.days
         });
-        const definitions = report.data.conversions ?? [];
-        const candidates = report.data.eventCatalog ?? [];
-        const hints2 = conversionHints(definitions, candidates, args2.candidates);
-        writeJsonEnvelope({
-          ok: true,
-          data: { definitions, ...args2.candidates ? { candidates } : {} },
-          ...hints2.length > 0 ? { hints: hints2 } : {}
-        });
+        writeJsonEnvelope(
+          conversionsEnvelope(
+            args2,
+            mergeStoredWithCounts(stored, report.data.conversions ?? []),
+            report.data.eventCatalog ?? []
+          )
+        );
       } catch (err) {
         if (err instanceof ConversionArgsError) {
           handleError(new ApiError("VALIDATION_ERROR", err.message));
@@ -29460,11 +30012,11 @@ function unwrap(response) {
   }
   return response.data;
 }
-async function readAvatars(path42, params) {
-  return unwrap(await apiGet(path42, params));
+async function readAvatars(path44, params) {
+  return unwrap(await apiGet(path44, params));
 }
-async function writeAvatars(path42, body) {
-  return unwrap(await apiPost(path42, body));
+async function writeAvatars(path44, body) {
+  return unwrap(await apiPost(path44, body));
 }
 
 // src/commands/avatars/create.ts
@@ -30298,12 +30850,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: path42, source } of sources) {
-    const dir = posix.dirname(path42);
+  for (const { path: path44, source } of sources) {
+    const dir = posix.dirname(path44);
     for (const face of declaredFontFaces(source)) {
       if (!wanted.has(face.family)) continue;
       const perFile = byFamily.get(face.family) ?? /* @__PURE__ */ new Map();
-      perFile.set(path42, [...perFile.get(path42) ?? [], rebaseFontFaceSrc(face.block, dir)]);
+      perFile.set(path44, [...perFile.get(path44) ?? [], rebaseFontFaceSrc(face.block, dir)]);
       byFamily.set(face.family, perFile);
     }
   }
@@ -31324,10 +31876,10 @@ import path15 from "path";
 import { defineCommand as defineCommand107 } from "citty";
 
 // src/commands/canvas/normalize-paths.ts
-import { existsSync as existsSync3, realpathSync } from "fs";
+import { existsSync as existsSync4, realpathSync } from "fs";
 import { writeFile as writeFile2 } from "fs/promises";
 import path5 from "path";
-function findWorkspaceRoot(startDir, exists2 = existsSync3, maxDepth = 12) {
+function findWorkspaceRoot(startDir, exists2 = existsSync4, maxDepth = 12) {
   let dir = path5.resolve(startDir);
   for (let i = 0; i < maxDepth; i++) {
     if (exists2(path5.join(dir, "package.json"))) return dir;
@@ -35277,10 +35829,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: readdir12 } = await import("fs/promises");
+  const { readdir: readdir14 } = await import("fs/promises");
   let entries;
   try {
-    entries = await readdir12(outputsDir);
+    entries = await readdir14(outputsDir);
   } catch {
     return;
   }
@@ -36972,7 +37524,7 @@ function routeVideoModel(input) {
 import { execFile as execFile2 } from "child_process";
 import { mkdtemp, readdir as readdir7, readFile as readFile14, rm as rm5 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 var PYSCENEDETECT_THRESHOLD = 18;
@@ -37025,7 +37577,7 @@ function parsePySceneDetectCsvCuts(csv) {
   return [...new Set(cuts)].sort((a, b) => a - b);
 }
 async function runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs) {
-  const outDir = await mkdtemp(join2(tmpdir(), "baker-scenedetect-"));
+  const outDir = await mkdtemp(join3(tmpdir(), "baker-scenedetect-"));
   try {
     await execFileAsync2(
       "scenedetect",
@@ -37046,7 +37598,7 @@ async function runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs)
     );
     const csvName = (await readdir7(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
     if (!csvName) return [];
-    return parsePySceneDetectCsvCuts(await readFile14(join2(outDir, csvName), "utf-8"));
+    return parsePySceneDetectCsvCuts(await readFile14(join3(outDir, csvName), "utf-8"));
   } finally {
     await rm5(outDir, { recursive: true, force: true });
   }
@@ -37070,9 +37622,9 @@ async function detectSceneCutsPySceneDetect(filePath, opts = {}) {
 }
 
 // src/commands/canvas/composition-path.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import path21 from "path";
-function resolveShippedCanvasDir(name, startDir, exists2 = existsSync4, maxDepth = 8) {
+function resolveShippedCanvasDir(name, startDir, exists2 = existsSync5, maxDepth = 8) {
   const rel = path21.join("canvas", name);
   let dir = startDir;
   for (let i = 0; i < maxDepth; i++) {
@@ -38457,6 +39009,10 @@ Full guide: __tooling__/docs/tools/baker/creatives.md`
 // src/commands/experiment/index.ts
 import { defineCommand as defineCommand119 } from "citty";
 
+// src/commands/experiment/composition.ts
+import { readdir as readdir9, readFile as readFile21 } from "fs/promises";
+import path27 from "path";
+
 // src/commands/landing/import-graph.ts
 import { readdir as readdir8, readFile as readFile20, stat as stat4 } from "fs/promises";
 import path26 from "path";
@@ -38566,10 +39122,51 @@ async function readComposition(root, controlSlug, variantSlug2) {
     return void 0;
   }
 }
+var FLOW_REFERENCE_RES = [
+  /["'][^"']*flow-engine\/flows\/([A-Za-z0-9._-]+)/g,
+  /data-flow-form\s*=\s*["']([^"']+)["']/g,
+  /flowName\s*=\s*["']([^"']+)["']/g
+];
+function formsReferenced(texts, knownFlows2) {
+  const found = /* @__PURE__ */ new Set();
+  for (const text2 of texts) {
+    for (const re2 of FLOW_REFERENCE_RES) {
+      for (const match of text2.matchAll(re2)) {
+        const flow = match[1];
+        if (flow && knownFlows2.has(flow)) found.add(flow);
+      }
+    }
+  }
+  return [...found].sort();
+}
+function formsOnlyIn(these, those) {
+  const other = new Set(those);
+  return these.filter((flow) => !other.has(flow));
+}
+async function knownFlows(root) {
+  try {
+    const entries = await readdir9(path27.join(root, "src/lib/flow-engine/flows"), { withFileTypes: true });
+    return new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function readForms(root, slug) {
+  try {
+    const [files, flows] = await Promise.all([landingGraphFiles(root, slug), knownFlows(root)]);
+    if (flows.size === 0) return [];
+    const texts = await Promise.all(
+      [...files].filter((file) => /\.(astro|ts|tsx|js|mjs)$/.test(file)).map((file) => readFile21(path27.join(root, file), "utf8"))
+    );
+    return formsReferenced(texts, flows);
+  } catch {
+    return [];
+  }
+}
 
 // src/commands/experiment/fold.ts
-import { cp as cp2, mkdir as mkdir8, readdir as readdir9, readFile as readFile21, rm as rm7, stat as stat5, writeFile as writeFile11 } from "fs/promises";
-import path28 from "path";
+import { cp as cp2, mkdir as mkdir8, readdir as readdir10, readFile as readFile22, rm as rm7, stat as stat5, writeFile as writeFile11 } from "fs/promises";
+import path29 from "path";
 
 // ../api/src/experiments/variants.ts
 var VARIANT_SEPARATOR = "--";
@@ -38594,21 +39191,21 @@ function nextVariantNumber(page, existingSlugs, archived) {
 }
 
 // src/commands/landing/repoint.ts
-import path27 from "path";
+import path28 from "path";
 var QUOTED_RELATIVE = /(['"])(\.\.?\/[^'"]*)\1/g;
 function isInside3(abs, dir) {
-  return abs === dir || abs.startsWith(dir + path27.sep);
+  return abs === dir || abs.startsWith(dir + path28.sep);
 }
 function toSpecifier(from, to) {
-  const rel = path27.relative(from, to).split(path27.sep).join("/");
+  const rel = path28.relative(from, to).split(path28.sep).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
 function repointSpecifier(spec, opts) {
   if (!spec.startsWith(".")) return spec;
-  const abs = path27.resolve(opts.fromDir, spec);
+  const abs = path28.resolve(opts.fromDir, spec);
   if (opts.forkedTargets?.has(abs)) {
-    const withinControl = path27.relative(opts.controlDir, abs);
-    return toSpecifier(opts.toDir, path27.resolve(opts.variantDir, withinControl));
+    const withinControl = path28.relative(opts.controlDir, abs);
+    return toSpecifier(opts.toDir, path28.resolve(opts.variantDir, withinControl));
   }
   if (!isInside3(abs, opts.controlDir)) return spec;
   return toSpecifier(opts.toDir, abs);
@@ -38620,9 +39217,9 @@ function repointFile(text2, opts) {
 }
 function repointMoved(text2, opts) {
   return text2.replace(QUOTED_RELATIVE, (_match, quote, spec) => {
-    const abs = path27.resolve(opts.fromDir, spec);
-    const within = path27.relative(opts.movedFrom, abs);
-    const target = within.startsWith("..") || path27.isAbsolute(within) ? abs : path27.resolve(opts.movedTo, within);
+    const abs = path28.resolve(opts.fromDir, spec);
+    const within = path28.relative(opts.movedFrom, abs);
+    const target = within.startsWith("..") || path28.isAbsolute(within) ? abs : path28.resolve(opts.movedTo, within);
     return `${quote}${toSpecifier(opts.toDir, target)}${quote}`;
   });
 }
@@ -38631,7 +39228,7 @@ function repointMoved(text2, opts) {
 var ARCHIVE_ROOT = "src/_variants";
 var QUOTED_RELATIVE2 = /(['"])(\.\.?\/[^'"]*)\1/g;
 function posix2(p) {
-  return p.split(path28.sep).join("/");
+  return p.split(path29.sep).join("/");
 }
 async function isDir(p) {
   try {
@@ -38643,46 +39240,46 @@ async function isDir(p) {
 async function filesUnder(dir, prefix = "") {
   let entries;
   try {
-    entries = await readdir9(dir, { withFileTypes: true });
+    entries = await readdir10(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const entry of entries) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) out.push(...await filesUnder(path28.join(dir, entry.name), rel));
+    if (entry.isDirectory()) out.push(...await filesUnder(path29.join(dir, entry.name), rel));
     else out.push(rel);
   }
   return out.sort();
 }
 var TEXT_EXT = /\.(astro|ts|tsx|js|jsx|mjs|cjs|vue|svelte|md|json|css)$/;
 function archiveRelPath(abs, base) {
-  if (!abs.startsWith(base + path28.sep)) return null;
-  return posix2(path28.relative(base, abs));
+  if (!abs.startsWith(base + path29.sep)) return null;
+  return posix2(path29.relative(base, abs));
 }
 async function archiveArm(opts) {
   const { root, armDir, pageDir, archiveDir, armSlug } = opts;
   const targets = await archiveContents({ root, armDir, pageDir, armSlug });
-  const archivedBySource = new Map([...targets].map(([rel, abs]) => [abs, path28.join(archiveDir, rel)]));
+  const archivedBySource = new Map([...targets].map(([rel, abs]) => [abs, path29.join(archiveDir, rel)]));
   const written = [];
   for (const [rel, abs] of [...targets].sort()) {
-    const dest = path28.join(archiveDir, rel);
-    await mkdir8(path28.dirname(dest), { recursive: true });
+    const dest = path29.join(archiveDir, rel);
+    await mkdir8(path29.dirname(dest), { recursive: true });
     if (!TEXT_EXT.test(rel)) {
       await cp2(abs, dest);
     } else {
-      const text2 = await readFile21(abs, "utf8");
+      const text2 = await readFile22(abs, "utf8");
       await writeFile11(dest, repointIntoArchive(text2, abs, dest, archivedBySource), "utf8");
     }
-    written.push(posix2(path28.relative(root, dest)));
+    written.push(posix2(path29.relative(root, dest)));
   }
   return written;
 }
 async function archiveContents(opts) {
   const { root, armDir, pageDir, armSlug } = opts;
   const graph = await landingGraphFiles(root, armSlug);
-  const reachable = new Set([...graph].map((rel) => path28.resolve(root, rel)));
-  for (const rel of await filesUnder(armDir)) reachable.add(path28.join(armDir, rel));
+  const reachable = new Set([...graph].map((rel) => path29.resolve(root, rel)));
+  for (const rel of await filesUnder(armDir)) reachable.add(path29.join(armDir, rel));
   const sorted = [...reachable].sort();
   const targets = /* @__PURE__ */ new Map();
   for (const base of [pageDir, armDir]) {
@@ -38696,9 +39293,9 @@ async function archiveContents(opts) {
 }
 function repointIntoArchive(text2, sourceAbs, destAbs, archivedBySource) {
   return text2.replace(QUOTED_RELATIVE2, (match, quote, spec) => {
-    const resolved = resolveWithExtensions(path28.resolve(path28.dirname(sourceAbs), spec), archivedBySource);
+    const resolved = resolveWithExtensions(path29.resolve(path29.dirname(sourceAbs), spec), archivedBySource);
     if (resolved === null) return match;
-    const rel = posix2(path28.relative(path28.dirname(destAbs), resolved));
+    const rel = posix2(path29.relative(path29.dirname(destAbs), resolved));
     return `${quote}${rel.startsWith(".") ? rel : `./${rel}`}${quote}`;
   });
 }
@@ -38714,25 +39311,25 @@ async function promoteVariantFiles(opts) {
   const written = [];
   for (const rel of await filesUnder(variantDir)) {
     if (rel === "_definition.md") continue;
-    const from = path28.join(variantDir, rel);
-    const to = path28.join(pageDir, rel);
-    await mkdir8(path28.dirname(to), { recursive: true });
+    const from = path29.join(variantDir, rel);
+    const to = path29.join(pageDir, rel);
+    await mkdir8(path29.dirname(to), { recursive: true });
     if (!TEXT_EXT.test(rel)) {
       await cp2(from, to);
     } else {
-      const text2 = await readFile21(from, "utf8");
+      const text2 = await readFile22(from, "utf8");
       await writeFile11(
         to,
         repointMoved(text2, {
-          fromDir: path28.dirname(from),
-          toDir: path28.dirname(to),
+          fromDir: path29.dirname(from),
+          toDir: path29.dirname(to),
           movedFrom: variantDir,
           movedTo: pageDir
         }),
         "utf8"
       );
     }
-    written.push(posix2(path28.relative(root, to)));
+    written.push(posix2(path29.relative(root, to)));
   }
   return written;
 }
@@ -38756,8 +39353,8 @@ function archiveRecord(target, variantNumber) {
 `;
 }
 async function foldExperiment(root, target) {
-  const pageDir = path28.resolve(root, "src/pages", target.landingSlug);
-  const variantDir = path28.resolve(root, "src/pages", target.variantSlug);
+  const pageDir = path29.resolve(root, "src/pages", target.landingSlug);
+  const variantDir = path29.resolve(root, "src/pages", target.variantSlug);
   const variantNumber = variantNumberOf(target.variantSlug);
   if (variantNumber === null) {
     return {
@@ -38771,7 +39368,7 @@ async function foldExperiment(root, target) {
     return { error: `src/pages/${target.variantSlug}/ is already gone \u2014 this test looks folded in already` };
   }
   const archiveKey = target.landingInternalId ?? target.landingSlug;
-  const archiveDir = path28.resolve(root, ARCHIVE_ROOT, archiveKey, String(variantNumber));
+  const archiveDir = path29.resolve(root, ARCHIVE_ROOT, archiveKey, String(variantNumber));
   await rm7(archiveDir, { recursive: true, force: true });
   await mkdir8(archiveDir, { recursive: true });
   const written = await archiveArm({
@@ -38781,8 +39378,8 @@ async function foldExperiment(root, target) {
     archiveDir,
     armSlug: target.survivor === "variant" ? target.landingSlug : target.variantSlug
   });
-  await writeFile11(path28.join(archiveDir, "_variant.json"), archiveRecord(target, variantNumber), "utf8");
-  written.push(posix2(path28.join(ARCHIVE_ROOT, archiveKey, String(variantNumber), "_variant.json")));
+  await writeFile11(path29.join(archiveDir, "_variant.json"), archiveRecord(target, variantNumber), "utf8");
+  written.push(posix2(path29.join(ARCHIVE_ROOT, archiveKey, String(variantNumber), "_variant.json")));
   if (target.survivor === "variant") {
     written.push(...await promoteVariantFiles({ root, pageDir, variantDir }));
   }
@@ -38790,59 +39387,48 @@ async function foldExperiment(root, target) {
   return {
     experimentId: target.experimentId,
     page: target.landingSlug,
-    archivedTo: posix2(path28.join(ARCHIVE_ROOT, archiveKey, String(variantNumber))),
+    archivedTo: posix2(path29.join(ARCHIVE_ROOT, archiveKey, String(variantNumber))),
     written,
     removed: [`src/pages/${target.variantSlug}`]
   };
 }
 
-// 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 = {
+var LIVE_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.`
+  winner: (row) => row.winner === "variant" ? `${row.experimentId} has a winner: the new variant. Run \`baker experiment finish --id ${row.experimentId} --keep variant\` to show it to everyone, then \`baker experiment fold\`.` : `${row.experimentId} has a winner: the page as it is. Run \`baker experiment finish --id ${row.experimentId} --keep original\` to put all the traffic back on it.`,
+  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. End it with \`--keep original\` 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 and is STILL being shown to visitors. Run \`baker experiment finish --id ${row.experimentId} --keep original\` now.`,
+  // Unreachable on a live test — only ending one produces it. The Record is
+  // exhaustive by type so a verdict added upstream fails to compile here rather
+  // than printing nothing.
+  inconclusive: (row) => `${row.experimentId} was ended 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"}. End it with \`--keep original\` 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.";
+    return "This page's traffic will not settle it at any point, so end it with `--keep original` 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 pausedNote(row) {
+  return row.status === "paused" ? `${row.experimentId} is paused \u2014 everyone sees the original. \`baker experiment resume --id ${row.experimentId}\` restarts the split with the same sides. ` : "";
+}
+function unlearnedHint(experiments) {
+  const unlearned = experiments.filter(
+    (row) => row.status === "finished" && row.learning === null && row.verdict !== "inconclusive"
+  );
+  if (unlearned.length === 0) return null;
+  const ids = unlearned.map((row) => row.experimentId).join(", ");
+  return `${unlearned.length === 1 ? "One finished test has" : `${unlearned.length} finished tests have`} no learning written down yet (${ids}). Say what it taught in one or two sentences \u2014 what the client should believe about this page now \u2014 with \`baker experiment update --id <id> --learning "\u2026"\`. It is what \`plan\` hands the next test.`;
+}
 function buildStatusHints(experiments) {
-  const hints2 = experiments.filter((row) => row.status === "running").map((row) => RUNNING_HINT[row.verdict](row));
+  const hints2 = experiments.filter((row) => row.status !== "finished").map((row) => pausedNote(row) + LIVE_HINT[row.verdict](row));
+  const unlearned = unlearnedHint(experiments);
+  if (unlearned) hints2.push(unlearned);
   if (experiments.length === 0) {
     hints2.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."
@@ -38853,40 +39439,122 @@ function buildStatusHints(experiments) {
 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);
+function horizonsHint(plan) {
+  const settled = plan.horizons.filter((horizon) => horizon.detectableLift !== null);
+  if (settled.length === 0) {
+    return "At this page's traffic no window up to 90 days would gather enough visitors to settle anything, at any size of change. The constraint is the traffic, not the test.";
+  }
+  const parts = settled.map((horizon) => `${horizon.days} days \u2192 ${asLift(horizon.detectableLift ?? 0)}`);
+  return `The smallest change each window could settle on this page's traffic: ${parts.join(", ")}. Design the alternative to be at least that different.`;
+}
+function conversionsHint(plan) {
+  if (plan.conversions.length <= 1) return null;
+  const others = plan.conversions.filter((entry) => entry.eventKey !== plan.goal);
+  return `This page's visitors also went on to: ${others.map((entry) => `\`${entry.eventKey}\`${entry.name ? ` (\u201C${entry.name}\u201D)` : ""} \u2014 ${entry.convertingVisitors}`).join(
+    ", "
+  )}. Any of them can be the goal (--goal <key>); the named ones are reported beside it on every result, and decide nothing.`;
+}
+function pastTestLine(test) {
+  const outcome = {
+    supported: "the idea held",
+    refuted_opposite: "the idea was WRONG \u2014 the change made it worse",
+    refuted_no_effect: "no difference \u2014 the change did not matter",
+    unanswered: "never answered"
+  };
+  const kept = test.survivor === "variant" ? "the new version was kept" : "the original was kept";
+  const learning = test.learning ? ` Learning: ${test.learning}` : "";
+  return `\u201C${test.hypothesis.change}\u201D (${test.experimentId}, ${test.ranForDays} days): ${outcome[test.hypothesisOutcome]}; ${kept}${test.againstVerdict ? " against the numbers" : ""}.${learning}`;
+}
+function pastTestsHint(plan) {
+  if (plan.pastTests.length === 0) return null;
+  const lines = plan.pastTests.slice(0, 5).map(pastTestLine);
+  const more = plan.pastTests.length > 5 ? ` \u2026and ${plan.pastTests.length - 5} more \u2014 \`baker experiment history --landing <slug>\` lists them all.` : "";
+  return `This page has been tested before \u2014 read this before choosing what to change, and build on it rather than repeating it: ${lines.join(" ")}${more}`;
+}
+function buildPlanHints(plan) {
+  const horizons = horizonsHint(plan);
+  const past = pastTestsHint(plan);
   if (!plan.canRun) {
     return [
       plan.reason ?? "This test cannot run on this page.",
-      ...window2 ? [window2] : [],
+      ...horizons && plan.visitors > 0 ? [horizons] : [],
+      ...past ? [past] : [],
       "A test that cannot conclude is worse than no test \u2014 it still produces a number, and somebody acts on it."
     ];
   }
   const hints2 = [
-    `This test measures ${plan.goalLabel}. That is fixed when it starts and cannot be changed later.`,
+    ...past ? [past] : [],
+    // First, because it changes how every number below should be read: a plan
+    // sized on a stand-in is a guide, and the agent must say so to the client
+    // rather than quote "about 70 days" as though it were measured.
+    ...plan.warning ? [plan.warning] : [],
+    `This test is read on \u201C${plan.goal}\u201D. 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.",
+    // test of a bad idea spends the page's traffic 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. 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."
   ];
+  const conversions = conversionsHint(plan);
+  if (conversions) hints2.push(conversions);
   if (plan.estimatedDays !== null && plan.estimatedDays > 60) {
     hints2.push(
-      `At this page's traffic it would take about ${plan.estimatedDays} days. Consider testing a bigger change, which needs less traffic to detect.`
+      `At this page's recent traffic it would take about ${plan.estimatedDays} days \u2014 a guide, not a limit: it ends when the numbers are clear, and more traffic (a campaign, ads) shortens it. If the traffic will stay as it is, test a bigger change, which needs fewer visitors to detect.`
+    );
+  }
+  if (horizons) hints2.push(horizons);
+  return hints2;
+}
+function buildHistoryHints(tests, landing) {
+  if (tests.length === 0) {
+    return [
+      landing ? `No finished test on \u201C${landing}\u201D yet \u2014 nothing to build on, and nothing to avoid repeating. \`baker experiment plan\` says whether the page can settle one.` : "No finished tests yet. `baker experiment plan --landing <slug> --variant <slug>` says whether a page can settle one."
+    ];
+  }
+  const hints2 = [];
+  const supported = tests.filter((test) => test.hypothesisOutcome === "supported");
+  const refuted = tests.filter((test) => test.hypothesisOutcome === "refuted_opposite");
+  const noEffect = tests.filter((test) => test.hypothesisOutcome === "refuted_no_effect");
+  if (supported.length > 0) {
+    hints2.push(
+      `Held: ${supported.map((test) => `\u201C${test.hypothesis.change}\u201D on ${test.landingSlug}`).join("; ")}. Build on these \u2014 the same insight usually has more in it.`
+    );
+  }
+  if (refuted.length > 0) {
+    hints2.push(
+      `Made it worse: ${refuted.map((test) => `\u201C${test.hypothesis.change}\u201D on ${test.landingSlug}`).join("; ")}. Do not propose these again as they were; the observation behind each may still be right, the change was not.`
+    );
+  }
+  if (noEffect.length > 0) {
+    hints2.push(
+      `Did not matter: ${noEffect.map((test) => `\u201C${test.hypothesis.change}\u201D on ${test.landingSlug}`).join("; ")}. The next change on these pages has to be bigger \u2014 a headline, an offer, the shape of the page.`
+    );
+  }
+  const unlearned = tests.filter((test) => test.learning === null && test.verdict !== "inconclusive");
+  if (unlearned.length > 0) {
+    hints2.push(
+      `${unlearned.length === 1 ? "One test has" : `${unlearned.length} tests have`} no learning written down (${unlearned.map((test) => test.experimentId).join(", ")}). Read its numbers and write one: \`baker experiment update --id <id> --learning "\u2026"\`.`
+    );
+  }
+  return hints2;
+}
+function buildStartHints(staged) {
+  const hints2 = [];
+  if (staged.composition && staged.composition.forked.length === 0) {
+    hints2.push(
+      `\u201C${staged.variant}\u201D does not have its own copy of any section \u2014 it renders exactly the same page as \u201C${staged.landing}\u201D, so this test cannot find anything. Fork the section you want to test (\`baker landing variant ${staged.landing} --fork Hero.astro\`) and edit only that file.`
+    );
+  }
+  if (staged.newForms.length > 0 && staged.variantGoal === void 0) {
+    const forms = staged.newForms.map((flow) => `\u201C${flow}\u201D`).join(", ");
+    hints2.push(
+      `\u201C${staged.variant}\u201D uses ${staged.newForms.length === 1 ? "a Form" : "Forms"} the page does not: ${forms}. The test reads the new version on \`${staged.goal}\`, the page's event \u2014 if the new version converts by reaching this Form's ending instead, it can never convert on that key and the test will call it harmful. Say its own event: \`baker experiment update --id <id> --variant-goal submit:${staged.newForms[0]}\` (or the confirmation step's \`form:${staged.newForms[0]}:<node>:<trigger>\` key, from \`baker analytics conversions --candidates\` once the Form has been opened in the preview).`
     );
   }
-  if (window2) hints2.push(window2);
   return hints2;
 }
 
@@ -38901,45 +39569,8 @@ var experimentCompositionSchema = z35.object({
 
 // ../api/src/experiments/goal.ts
 import { z as z36 } from "zod";
-var eventNameSchema = z36.string().min(1).max(120);
-var experimentGoalSchema = z36.discriminatedUnion("kind", [
-  z36.object({
-    kind: z36.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: z36.string().max(120).optional()
-  }),
-  z36.object({
-    kind: z36.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: z36.string().max(64).optional(),
-    value: z36.string().max(255).optional()
-  }),
-  z36.object({
-    kind: z36.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: z36.string().max(255).optional()
-  })
-]);
+var GOAL_KEY_HELP = "A goal is one event, by its key \u2014 `form:<flow>:<node>:<trigger>`, `submit:<flow>`, `page:<name>` or `exit:<host>`. `baker analytics conversions --candidates` lists the ones these pages produce";
+var experimentGoalSchema = z36.string().trim().min(1).max(400).refine((key) => parseEventKey(key) !== null, { message: GOAL_KEY_HELP });
 
 // ../api/src/experiments/hypothesis.ts
 import { z as z37 } from "zod";
@@ -38994,10 +39625,31 @@ var experimentHypothesisOutcomeSchema = z37.enum([
 // ../api/src/experiments/wire.ts
 import { z as z38 } from "zod";
 var slugSchema = z38.string().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Use a page slug, like `oferta`");
+var variantSlugSchema = z38.string().min(1).max(130).refine((slug) => {
+  const page = variantOfSlug(slug);
+  return page !== null && slugSchema.safeParse(page).success;
+}, "Use the variant's slug, `<page>--<n>` \u2014 `baker landing variant <page>` chooses it");
 var experimentPlanRequestSchema = z38.object({
   landingSlug: slugSchema,
-  variantSlug: slugSchema,
+  variantSlug: variantSlugSchema,
+  /**
+   * Which of the company's conversions the test is about.
+   *
+   * Optional only when the company counts exactly one outcome, in which case
+   * it is that one. A company counting several has to say which — a test that
+   * "measures conversions" on a page with a newsletter box and a demo request
+   * is measuring two things and deciding on their sum.
+   */
   goal: experimentGoalSchema.optional(),
+  /**
+   * The event the NEW version converts on, when it is not the page's.
+   *
+   * The test asks one question — did more visitors do the thing we want — but
+   * the thing can be a different event on each version: a variant that swaps
+   * the page's Form for a shorter one converts on the new Form's ending. Absent,
+   * the variant is read on `goal`, which is the common case.
+   */
+  variantGoal: experimentGoalSchema.optional(),
   /**
    * The smallest lift worth detecting, relative to the baseline. `0.2` is +20%.
    *
@@ -39008,19 +39660,38 @@ var experimentPlanRequestSchema = z38.object({
    */
   minDetectableRelativeLift: z38.number().gt(0).max(10).optional(),
   /**
-   * "I have this many days — what could I even see?"
+   * The share of visitors expected to do the goal, as a fraction — `0.05` is
+   * 5% — for a page whose history cannot say.
    *
-   * 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.
+   * A page about to get its first campaign has no rate to size on. Without
+   * this the plan stands on the company-wide rate for the outcome, or on a
+   * conventional 3%; with it, on what the person setting the test up knows.
+   * Either way the brief says which, because the sizing is a guide and never a
+   * finish line — the test runs until the numbers are clear.
    */
-  days: z38.number().int().gt(0).max(365).optional()
+  baselineRate: z38.number().gt(0).lt(1).optional()
+});
+var experimentTrafficSchema = z38.enum(["none", "low", "enough"]);
+var experimentBaselineSourceSchema = z38.enum(["page", "company", "assumed"]);
+var experimentSizedOnSchema = z38.object({
+  visitors: z38.number(),
+  convertingVisitors: z38.number(),
+  windowDays: z38.number()
 });
 var experimentStartRequestSchema = experimentPlanRequestSchema.extend({
   hypothesis: experimentHypothesisSchema,
+  /**
+   * The two pages' own identities, read off their `_definition.md` by the CLI.
+   *
+   * The backend prefers the `landings` rows, but the variant has no row until
+   * the Session that built it is published — which is after the test is
+   * staged. Without this the variant's identity was never recorded, so a
+   * renamed variant folder detached its running test and a fold archived the
+   * loser under the wrong key. Optional because a workspace that cannot read
+   * its own definition must still be able to start a test.
+   */
+  landingInternalId: z38.string().min(1).max(64).optional(),
+  variantInternalId: z38.string().min(1).max(64).optional(),
   /**
    * What the two arms are made of, read off the import graph by the caller at
    * the moment the test starts.
@@ -39032,34 +39703,61 @@ var experimentStartRequestSchema = experimentPlanRequestSchema.extend({
    */
   composition: experimentCompositionSchema.optional()
 });
+var experimentKeepSchema = z38.enum(["original", "variant"]);
+var experimentEndReasonSchema = z38.enum(["numbers_clear", "not_settling", "page_changing", "test_flawed"]);
+var experimentLearningSchema = z38.string().trim().min(1).max(2e3);
 var experimentFinishRequestSchema = z38.object({
   experimentId: z38.string().min(1).max(64),
+  keep: experimentKeepSchema,
+  /** Why it is being ended. The dashboard always asks; the agent should say. */
+  reason: experimentEndReasonSchema.optional(),
+  learning: experimentLearningSchema.optional()
+});
+var experimentPauseRequestSchema = z38.object({
+  experimentId: z38.string().min(1).max(64)
+});
+var experimentUpdateRequestSchema = z38.object({
+  experimentId: z38.string().min(1).max(64),
+  because: experimentHypothesisSchema.shape.because.optional(),
+  change: experimentHypothesisSchema.shape.change.optional(),
+  evidence: experimentHypothesisSchema.shape.evidence,
   /**
-   * 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.
+   * Staged tests only. Spelled out rather than borrowed from the hypothesis
+   * schema, whose `expect` defaults to `increase`: through `.optional()` that
+   * default still fires, so every wording-only update arrived carrying a
+   * direction and was refused for trying to change it.
    */
-  abandon: z38.boolean().optional()
+  expect: z38.enum(["increase", "decrease"]).optional(),
+  /** Staged tests only. */
+  goal: experimentGoalSchema.optional(),
+  /** Staged tests only. The new version's own event, when it differs. */
+  variantGoal: experimentGoalSchema.optional(),
+  /** Staged tests only. */
+  minDetectableRelativeLift: z38.number().gt(0).max(10).optional(),
+  /** Finished tests only: what the test taught, written or corrected after the fact. */
+  learning: experimentLearningSchema.optional()
+});
+var experimentUpdateResponseSchema = z38.object({
+  /** True when the test had not been published, so its whole plan was re-sized. */
+  staged: z38.boolean(),
+  hypothesisStatement: z38.string()
 });
 var experimentFoldRequestSchema = z38.object({
   /** Which test to fold. Omitted ⇒ every fold this company owes. */
   experimentId: z38.string().max(64).optional(),
   /** The files are written. Baker drops the promotion once the build lands. */
-  applied: z38.boolean().optional()
+  applied: z38.boolean().optional(),
+  /**
+   * Which of the owed folds were actually written, on an `applied` call.
+   *
+   * Folding is per page and one page failing must not hold back the others, so
+   * a run that folds two of three has to be able to say which two. Without it
+   * the report was "the company", every owed test was stamped as written, and
+   * the one that failed had its promotion dropped when the build landed — so
+   * its page served the version that LOST, with nothing owed and nothing
+   * logged. Omitted ⇒ everything owed, which is the whole-company case.
+   */
+  experimentIds: z38.array(z38.string().max(64)).max(200).optional()
 });
 var experimentFoldTargetSchema = z38.object({
   experimentId: z38.string(),
@@ -39079,12 +39777,39 @@ var experimentFoldResponseSchema = z38.object({
 });
 var experimentStatusRequestSchema = z38.object({
   experimentId: z38.string().max(64).optional(),
+  /** Only the tests on one page, by its slug. */
+  landingSlug: z38.string().max(200).optional(),
   full: z38.boolean().optional()
 });
+var experimentHistoryRequestSchema = z38.object({
+  landingSlug: z38.string().max(200).optional(),
+  limit: z38.number().int().positive().max(100).optional()
+});
+var experimentPageConversionSchema = z38.object({
+  /** The event, by key — what `--goal` takes. */
+  eventKey: z38.string(),
+  /** The conversion name the company counts it under, or null when nobody has named it. */
+  name: z38.string().nullable(),
+  /** Distinct visitors to the page who went on to do this. */
+  convertingVisitors: z38.number()
+});
+var experimentHorizonSchema = z38.object({
+  days: z38.number(),
+  /** The smallest relative lift detectable in that many days. `null` when none would be. */
+  detectableLift: z38.number().nullable()
+});
 var experimentPlanResponseSchema = z38.object({
   canRun: z38.boolean(),
   /** Present when `canRun` is false. Product language, ready to show. */
   reason: z38.string().optional(),
+  /** The event the test would be read on. Absent when none could be chosen. */
+  goal: experimentGoalSchema.optional(),
+  /** The new version's own event, when one was given. */
+  variantGoal: experimentGoalSchema.optional(),
+  /** Every event this page's visitors went on to do over the sizing window, most common first. */
+  conversions: z38.array(experimentPageConversionSchema),
+  /** Distinct visitors the page had over the sizing window. */
+  visitors: z38.number(),
   baselineRate: z38.number(),
   minDetectableRelativeLift: z38.number(),
   /** `null` when no amount of traffic could settle the hypothesis. */
@@ -39093,14 +39818,24 @@ var experimentPlanResponseSchema = z38.object({
   dailyVisitorsPerVariant: z38.number(),
   /** `null` when the page has no traffic to project from. */
   estimatedDays: z38.number().nullable(),
-  goal: experimentGoalSchema,
-  goalLabel: z38.string(),
+  horizons: z38.array(experimentHorizonSchema),
+  traffic: experimentTrafficSchema,
+  baselineSource: experimentBaselineSourceSchema,
+  sizedOn: experimentSizedOnSchema,
+  /**
+   * Why the sizing is a guide rather than a measurement, when it is one.
+   * Product language, ready to show; absent on a page with real traffic that
+   * has produced the goal.
+   */
+  warning: z38.string().optional(),
   /**
-   * 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.
+   * Every finished test on this page, newest first — see
+   * `experimentHistoryEntrySchema`. On the plan because the plan is the moment
+   * a hypothesis is chosen, and a page's own record is the first thing that
+   * should inform it: a refuted idea proposed again, or a supported one never
+   * built on, is what this exists to prevent.
    */
-  detectableLiftInDays: z38.number().nullable().optional()
+  pastTests: z38.array(z38.lazy(() => experimentHistoryEntrySchema)).default([])
 });
 var experimentVerdictSchema = z38.enum([
   "keep_running",
@@ -39109,16 +39844,17 @@ var experimentVerdictSchema = z38.enum([
   "invalid",
   "stopped_early_harmful",
   /**
-   * Stopped by a person before it concluded. Never produced by the stopping
-   * rule — only by `finish --abandon`.
+   * Ended before the numbers could say anything. Never produced by the
+   * stopping rule — only by ending a `keep_running` test.
    *
    * 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"
+  "inconclusive"
 ]);
+var experimentStatusValueSchema = z38.enum(["running", "paused", "finished"]);
 var experimentArmSchema = z38.object({
   slug: z38.string(),
   visitors: z38.number(),
@@ -39132,7 +39868,28 @@ var experimentArmSchema = z38.object({
    * screens cannot show a client two different "this is your offer page".
    * `null` before the first capture, and on a page whose capture failed.
    */
-  previewUrl: z38.string().nullable().optional()
+  previewUrl: z38.string().nullable().optional(),
+  /**
+   * This version as it was when the test started — the test's own capture,
+   * taken off the live site once the split was being served.
+   *
+   * `previewUrl` above is the page as it is *today*, which is right while a
+   * test runs and wrong the day after somebody edits the page, and absent
+   * altogether for a variant that lost and was archived. This is the record;
+   * a card prefers it and says which of the two it is showing.
+   */
+  snapshotUrl: z38.string().nullable().optional(),
+  snapshotCapturedAt: z38.number().nullable().optional()
+});
+var experimentMetricSchema = z38.object({
+  name: z38.string(),
+  control: z38.object({ conversions: z38.number(), rate: z38.number() }),
+  variant: z38.object({ conversions: z38.number(), rate: z38.number() }),
+  relativeLift: z38.number(),
+  /** The anytime-valid interval on the relative lift. */
+  liftInterval: z38.tuple([z38.number(), z38.number()]),
+  /** `better` when the interval sits above zero, `worse` below it, `unclear` across it. */
+  reading: z38.enum(["better", "worse", "unclear"])
 });
 var experimentTimelineArmSchema = z38.object({
   visitors: z38.number(),
@@ -39173,19 +39930,51 @@ var experimentStatusRowSchema = z38.object({
    * is not a hypothesis, "leads should go up by at least 20%" is.
    */
   minDetectableRelativeLift: z38.number(),
+  /** The event the verdict is read from on the page, by key. */
+  goal: experimentGoalSchema,
+  /** The event the new version is read on, when it differs from `goal`. */
+  variantGoal: experimentGoalSchema.nullable(),
+  /** Both, in words a marketer reads — the Form's name, the moment. */
   goalLabel: z38.string(),
-  status: z38.enum(["running", "finished"]),
+  status: experimentStatusValueSchema,
   startedAt: z38.number(),
+  /** Set while paused. The split is off and everyone sees the original. */
+  pausedAt: z38.number().nullable(),
   finishedAt: z38.number().nullable(),
   verdict: experimentVerdictSchema,
-  /** Set only on `winner`. Which page to keep. */
+  /** Set only on `winner`. Which version the numbers favour. */
   winner: z38.enum(["control", "variant"]).nullable(),
+  /**
+   * Which version is live, once the test has ended. Chosen by whoever ended it,
+   * and allowed to disagree with `winner` — the card says so when it does.
+   */
+  survivor: z38.enum(["control", "variant"]).nullable(),
   /** Set only on `invalid`. Why the numbers cannot be read. */
   invalidReason: z38.enum(["sample_ratio_mismatch", "crossover"]).nullable(),
+  /**
+   * Where the page's own content stands after the test, once it has ended.
+   *
+   * `owed` — the new variant was kept and is served by a rewrite; the page's
+   * source still says otherwise. `landing` — the files are written and the
+   * next publish carries them. `done` — the page's own content is the version
+   * that was kept, and nothing routes either arm any more. `none` — the
+   * original was kept, so there was never anything to move.
+   *
+   * On the row because two things on the card read it: whether "open this
+   * version" links still show the right file, and whether there is anything
+   * left for a person to do.
+   */
+  fold: z38.enum(["none", "owed", "landing", "done"]).nullable(),
   /** What a person should be told, in one sentence, in product language. */
   summary: z38.string(),
+  /** What the test taught, once somebody wrote it down. Null until then, and always null while it runs. */
+  learning: z38.string().nullable(),
+  /** Why it was ended, when whoever ended it said. Null while it runs. */
+  endReason: experimentEndReasonSchema.nullable(),
   control: experimentArmSchema,
   variant: experimentArmSchema,
+  /** Every other conversion the company counts, on the same two arms. */
+  secondary: z38.array(experimentMetricSchema),
   /**
    * How close this test is to being able to say anything at all, 0 to 1.
    *
@@ -39199,8 +39988,8 @@ var experimentStatusRowSchema = z38.object({
   earliestDecisionAt: z38.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.
+   * A different thing from a page that is merely slow, and the reason to end
+   * a test rather than leave it running.
    */
   willNotConclude: z38.boolean(),
   /**
@@ -39216,6 +40005,13 @@ var experimentStatusRowSchema = z38.object({
   evidence: z38.object({
     relativeLift: z38.number(),
     probabilityVariantBetter: z38.number(),
+    /**
+     * How sure the numbers are that the two versions differ at all, 0 to 1.
+     * Anytime-valid — the same construction the verdict is read from, so it
+     * holds however often it is read — and a winner is called exactly when
+     * it crosses 95%. The figure a card leads with.
+     */
+    confidence: z38.number(),
     controlInterval: z38.tuple([z38.number(), z38.number()]),
     variantInterval: z38.tuple([z38.number(), z38.number()]),
     /** The anytime-valid interval on the relative lift — what the verdict is read from. */
@@ -39225,6 +40021,54 @@ var experimentStatusRowSchema = z38.object({
 var experimentStatusResponseSchema = z38.object({
   experiments: z38.array(experimentStatusRowSchema)
 });
+var experimentHistoryEntrySchema = z38.object({
+  experimentId: z38.string(),
+  landingSlug: z38.string(),
+  variantSlug: z38.string(),
+  startedAt: z38.number(),
+  finishedAt: z38.number(),
+  /** Days the split ran, whole. */
+  ranForDays: z38.number(),
+  hypothesis: experimentHypothesisSchema,
+  hypothesisStatement: z38.string(),
+  /** The sections the new version owned, as labels — what was actually different. */
+  changed: z38.array(z38.string()),
+  goal: experimentGoalSchema,
+  variantGoal: experimentGoalSchema.nullable(),
+  goalLabel: z38.string(),
+  verdict: experimentVerdictSchema,
+  /** Which version the numbers favoured, on `winner`. */
+  winner: z38.enum(["control", "variant"]).nullable(),
+  /** Which version kept the traffic. */
+  survivor: z38.enum(["control", "variant"]),
+  /** True when what was kept is not what the numbers favoured. */
+  againstVerdict: z38.boolean(),
+  hypothesisOutcome: experimentHypothesisOutcomeSchema,
+  /** The numbers, as they were when the test ended. */
+  result: z38.object({
+    control: z38.object({ visitors: z38.number(), conversions: z38.number(), rate: z38.number() }),
+    variant: z38.object({ visitors: z38.number(), conversions: z38.number(), rate: z38.number() }),
+    relativeLift: z38.number(),
+    liftInterval: z38.tuple([z38.number(), z38.number()]),
+    confidence: z38.number(),
+    secondary: z38.array(experimentMetricSchema)
+  }),
+  summary: z38.string(),
+  /** Why it was ended, when whoever ended it said. */
+  endReason: experimentEndReasonSchema.nullable(),
+  /** What the test taught, or null when nobody has written it down yet. */
+  learning: z38.string().nullable()
+});
+var experimentHistoryResponseSchema = z38.object({
+  tests: z38.array(experimentHistoryEntrySchema)
+});
+var experimentFinishResponseSchema = z38.object({
+  verdict: experimentVerdictSchema,
+  survivor: z38.enum(["control", "variant"]),
+  /** True when `keep` went against a verdict the numbers had reached. */
+  againstVerdict: z38.boolean(),
+  summary: z38.string()
+});
 
 // src/commands/experiment/hypothesis.ts
 var SOURCES = experimentEvidenceSourceSchema.options.join(", ");
@@ -39246,9 +40090,8 @@ function parseOne(raw) {
   }
   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 !== "");
+function parseEvidence(raw, rawArgs) {
+  const entries = repeatedValues(rawArgs, "evidence", raw).map((entry) => entry.trim()).filter((entry) => entry !== "");
   if (entries.length === 0) return void 0;
   const parsed = [];
   for (const entry of entries) {
@@ -39259,20 +40102,70 @@ function parseEvidence(raw) {
   return parsed;
 }
 
+// src/commands/experiment/identity.ts
+import { readFile as readFile23 } from "fs/promises";
+import path30 from "path";
+async function readPageInternalId(root, slug) {
+  try {
+    const text2 = await readFile23(path30.resolve(root, "src", "pages", slug, "_definition.md"), "utf8");
+    return /^internalId:\s*"?([^"\s]+)"?\s*$/m.exec(text2)?.[1];
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/experiment/update.ts
+function buildUpdateRequest(args, rawArgs) {
+  const expect = args.expect === void 0 ? void 0 : String(args.expect);
+  if (expect !== void 0 && expect !== "increase" && expect !== "decrease") {
+    return {
+      error: "`--expect` is either `increase` or `decrease` \u2014 which way should the goal move if you are right?"
+    };
+  }
+  const evidence = parseEvidence(args.evidence, rawArgs);
+  if (evidence && "error" in evidence) return evidence;
+  const lift = args.lift === void 0 ? void 0 : Number(args.lift);
+  if (lift !== void 0 && !(lift > 0)) {
+    return {
+      error: "`--lift` is the smallest improvement worth detecting, relative \u2014 0.2 is +20%. It must be above zero."
+    };
+  }
+  const request = {
+    experimentId: String(args.id),
+    ...typed("because", args.because),
+    ...typed("change", args.change),
+    ...typed("goal", args.goal),
+    ...typed("variantGoal", args.variantGoal),
+    ...typed("learning", args.learning),
+    ...expect === void 0 ? {} : { expect },
+    ...evidence ? { evidence } : {},
+    ...lift === void 0 ? {} : { minDetectableRelativeLift: lift }
+  };
+  if (Object.keys(request).length === 1) {
+    return {
+      error: "Nothing to change. Pass --because, --change or --evidence; on a finished test, --learning; on a test that has not been published yet, also --expect, --goal, --variant-goal or --lift"
+    };
+  }
+  return request;
+}
+function typed(key, value) {
+  return value === void 0 ? {} : { [key]: String(value) };
+}
+
 // 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.",
+  description: "The ONE event the test is read on, by its key: `form:<flow>:<node>:<trigger>` (a Form reaching a step), `submit:<flow>` (a Form finished), `page:<name>` (a page event or one the client's systems post), `exit:<host>` (a click out). `baker analytics conversions --candidates` lists the keys these pages produce, and `plan` lists the ones this page's visitors went on to do. Fixed for the life of the test. Optional when exactly one of them is a named conversion; otherwise say which. Every conversion the company has named is reported beside the goal and decides nothing.",
   required: false
 };
-var LIFT_ARG = {
+var VARIANT_GOAL_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.",
+  description: "The event the NEW version is read on, when it is not the page's \u2014 a variant that swaps the Form for a shorter one converts on the new Form's ending (`submit:<new-flow>`, or its confirmation step's `form:` key). Same vocabulary as --goal. Leave it out when both versions convert on the same event, which is the common case.",
   required: false
 };
-var DAYS_ARG = {
+var LIFT_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.",
+  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 BECAUSE_ARG = {
@@ -39295,6 +40188,30 @@ var EVIDENCE_ARG = {
   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
 };
+var BASELINE_ARG = {
+  type: "string",
+  description: "The share of visitors you expect to do the goal, as a fraction \u2014 0.05 is 5% \u2014 for a page whose history cannot say: a new page, or one about to get its first campaign. Without it a page with no conversions yet is sized on the company-wide rate for the outcome, or on 3%. The sizing is a guide either way: the test runs until the numbers are clear.",
+  required: false
+};
+var ID_ARG = { type: "string", description: "The test, by its id", required: true };
+var LEARNING_ARG = {
+  type: "string",
+  description: "What this test taught, in one or two sentences the client should believe about this page from now on \u2014 \u201Cthe price is not the objection, the install date is\u201D. The one part of the record the numbers cannot write, and what `plan` hands the next test on this page. Finished tests only.",
+  required: false
+};
+var REASON_ARG = {
+  type: "string",
+  description: "Why the test is being ended, as distinct from what the numbers said: `numbers_clear` (the result was clear enough to act on), `not_settling` (too little traffic or too small a difference \u2014 waiting would not help), `page_changing` (the page has to change for another reason), `test_flawed` (the wrong goal, a broken variant). Always say \u2014 the dashboard asks a person the same question, and the next test on this page is planned differently after each answer.",
+  required: false
+};
+var LANDING_FILTER_ARG = {
+  type: "string",
+  description: "Only the tests on one page, by its slug",
+  required: false
+};
+function sizingHints(data) {
+  return typeof data.warning === "string" ? [data.warning] : [];
+}
 function fail5(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
@@ -39308,43 +40225,40 @@ function reportApiError(error) {
 }
 registerSchema({
   command: "experiment.plan",
-  description: "Whether a page has enough traffic to settle a question, before anything is built",
+  description: "Whether a page can settle a question, and how long it might take, 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 },
+    variant: { type: "string", description: "The new variant's slug, `<page>--<n>`", required: true },
     goal: GOAL_ARG,
+    variantGoal: VARIANT_GOAL_ARG,
     lift: LIFT_ARG,
-    days: DAYS_ARG
+    baseline: BASELINE_ARG
   }
 });
 var planCommand = defineCommand119({
   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."
+    description: "Start here, BEFORE building the alternative page. Says which event the test would be read on, which events the page's visitors actually go on to do (by key, with the conversion name each is counted under), how long it might take at this page's traffic, and what a 14, 28, 56 or 90-day window could settle. The duration is a guide, never a finish line \u2014 a test ends when the numbers are clear, and a page with no traffic yet can still be tested (`warning` says what it was sized on). What IS refused is a test that could not be measured: a goal this page has demonstrably never produced."
   },
   args: {
     landing: { type: "string", description: "The page under test, by slug", required: true },
-    variant: { type: "string", description: "The alternative page's slug", required: true },
+    variant: { type: "string", description: "The new variant's slug, `<page>--<n>`", required: true },
     goal: GOAL_ARG,
+    variantGoal: VARIANT_GOAL_ARG,
     lift: LIFT_ARG,
-    days: DAYS_ARG
+    baseline: BASELINE_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.goal ? { goal: String(args.goal) } : {},
+        ...args.variantGoal ? { variantGoal: String(args.variantGoal) } : {},
         ...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)
+        ...args.baseline ? { baselineRate: Number(args.baseline) } : {}
       });
+      writeJsonEnvelope({ ok: true, data: response.data, hints: buildPlanHints(response.data) });
     } catch (error) {
       reportApiError(error);
     }
@@ -39352,47 +40266,60 @@ var planCommand = defineCommand119({
 });
 registerSchema({
   command: "experiment.start",
-  description: "Stage an A/B test between a page and its alternative",
+  description: "Stage an A/B test between a page and a new variant of it",
   args: {
     landing: { type: "string", description: "The page under test, by slug", required: true },
-    variant: { type: "string", description: "The alternative page's slug", required: true },
+    variant: { type: "string", description: "The new variant's slug, `<page>--<n>`", required: true },
     because: BECAUSE_ARG,
     change: CHANGE_ARG,
     expect: EXPECT_ARG,
     evidence: EVIDENCE_ARG,
     goal: GOAL_ARG,
-    lift: LIFT_ARG
+    variantGoal: VARIANT_GOAL_ARG,
+    lift: LIFT_ARG,
+    baseline: BASELINE_ARG
   }
 });
 var startCommand = defineCommand119({
   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."
+    description: "Stage a test between the page and its new variant. Visitors are split between the two versions 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 new variant. 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 },
+    variant: { type: "string", description: "The new variant's slug, `<page>--<n>`", required: true },
     because: BECAUSE_ARG,
     change: CHANGE_ARG,
     expect: EXPECT_ARG,
     evidence: EVIDENCE_ARG,
     goal: GOAL_ARG,
-    lift: LIFT_ARG
+    variantGoal: VARIANT_GOAL_ARG,
+    lift: LIFT_ARG,
+    baseline: BASELINE_ARG
   },
-  run: async ({ args }) => {
-    const goal = parseGoal(args.goal ? String(args.goal) : void 0);
-    if (goal && "error" in goal) fail5(goal.error);
+  run: async ({ args, rawArgs }) => {
     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);
+    const evidence = parseEvidence(args.evidence, rawArgs);
     if (evidence && "error" in evidence) fail5(evidence.error);
     const composition = await readComposition(process.cwd(), String(args.landing), String(args.variant));
+    const [controlForms, variantForms] = await Promise.all([
+      readForms(process.cwd(), String(args.landing)),
+      readForms(process.cwd(), String(args.variant))
+    ]);
+    const newForms = formsOnlyIn(variantForms, controlForms);
+    const [landingInternalId, variantInternalId] = await Promise.all([
+      readPageInternalId(process.cwd(), String(args.landing)),
+      readPageInternalId(process.cwd(), String(args.variant))
+    ]);
     try {
       const response = await apiPost("/api/experiments/start", {
         landingSlug: String(args.landing),
         variantSlug: String(args.variant),
+        ...landingInternalId ? { landingInternalId } : {},
+        ...variantInternalId ? { variantInternalId } : {},
         hypothesis: {
           because: String(args.because),
           change: String(args.change),
@@ -39400,20 +40327,25 @@ var startCommand = defineCommand119({
           ...evidence ? { evidence } : {}
         },
         ...composition ? { composition } : {},
-        ...goal ? { goal } : {},
-        ...args.lift ? { minDetectableRelativeLift: Number(args.lift) } : {}
+        ...args.goal ? { goal: String(args.goal) } : {},
+        ...args.variantGoal ? { variantGoal: String(args.variantGoal) } : {},
+        ...args.lift ? { minDetectableRelativeLift: Number(args.lift) } : {},
+        ...args.baseline ? { baselineRate: Number(args.baseline) } : {}
       });
       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.",
+          ...sizingHints(response.data),
+          ...buildStartHints({
+            landing: String(args.landing),
+            variant: String(args.variant),
+            goal: String(response.data.goal),
+            variantGoal: args.variantGoal === void 0 ? void 0 : String(args.variantGoal),
+            composition,
+            newForms
+          }),
+          "Staged. The split starts when this session is published \u2014 publishing is the review of the new variant.",
           "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."
         ]
       });
@@ -39424,25 +40356,28 @@ var startCommand = defineCommand119({
 });
 registerSchema({
   command: "experiment.status",
-  description: "The verdict on every A/B test, running and finished",
+  description: "The verdict on every A/B test, running, paused and finished",
   args: {
     id: { type: "string", description: "One test, by its id", required: false },
+    landing: LANDING_FILTER_ARG,
     full: { type: "boolean", description: "Include the posteriors behind the verdict", required: false }
   }
 });
 var statusCommand6 = defineCommand119({
   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."
+    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, and `secondary` lists every other conversion the company counts on the same two arms \u2014 context, never a second decision. 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 },
+    landing: LANDING_FILTER_ARG,
     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.landing ? { landingSlug: String(args.landing) } : {},
         ...args.full === true ? { full: true } : {}
       });
       writeJsonEnvelope({
@@ -39456,45 +40391,218 @@ var statusCommand6 = defineCommand119({
   }
 });
 registerSchema({
-  command: "experiment.finish",
-  description: "End a test and send all its traffic to the surviving page",
+  command: "experiment.history",
+  description: "Every finished A/B test with what it found and what it taught \u2014 the record to read before proposing the next one",
   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
+    landing: LANDING_FILTER_ARG,
+    limit: { type: "string", description: "At most this many, newest first (default all)", required: false }
+  }
+});
+var historyCommand = defineCommand119({
+  meta: {
+    name: "history",
+    description: "What was tested before and what it taught. Finished tests only, newest first: the claim, what was different, what the numbers said, what was kept and whether that went against them, and the `learning` somebody wrote down. Read it \u2014 `--landing <slug>` for one page \u2014 BEFORE proposing a test: a refuted idea proposed again spends the page's traffic to return the same answer, and a supported one is what the next test should build on. `plan` hands the same entries back as `pastTests` for the page it sizes."
+  },
+  args: {
+    landing: LANDING_FILTER_ARG,
+    limit: { type: "string", description: "At most this many, newest first", required: false }
+  },
+  run: async ({ args }) => {
+    const limit = args.limit === void 0 ? void 0 : Number(args.limit);
+    if (limit !== void 0 && !(Number.isInteger(limit) && limit > 0)) fail5("`--limit` is a whole number above zero");
+    try {
+      const response = await apiPost("/api/experiments/history", {
+        ...args.landing ? { landingSlug: String(args.landing) } : {},
+        ...limit === void 0 ? {} : { limit }
+      });
+      writeJsonEnvelope({
+        ok: true,
+        data: response.data,
+        hints: buildHistoryHints(response.data.tests, args.landing === void 0 ? void 0 : String(args.landing))
+      });
+    } catch (error) {
+      reportApiError(error);
     }
   }
 });
+registerSchema({
+  command: "experiment.finish",
+  description: "End a test now and send all its traffic to the version you name",
+  args: {
+    id: ID_ARG,
+    keep: {
+      type: "string",
+      description: "Which version stays live: `original` or `variant`. Required \u2014 the verdict is a recommendation and this is the decision. A test that has not concluded can be ended too; it is recorded as inconclusive, never as a finding. Going against a verdict is allowed and is recorded as such.",
+      required: true
+    },
+    reason: REASON_ARG,
+    learning: LEARNING_ARG
+  }
+});
+var END_REASONS = ["numbers_clear", "not_settling", "page_changing", "test_flawed"];
+function finishHints(data, given) {
+  const { reason } = given;
+  const args = { learning: given.learning };
+  return [
+    `Done. Everyone now sees the ${data.survivor === "variant" ? "new variant" : "original"}.`,
+    ...data.againstVerdict ? [
+      `You kept the ${data.survivor === "variant" ? "new variant" : "original"} although the numbers favoured the other version (${data.verdict}). That is recorded on the test \u2014 say why in the write-up.`
+    ] : [],
+    ...data.verdict === "keep_running" ? [
+      "This test had not concluded, so it is recorded as inconclusive \u2014 nobody found out. Never report it as no difference."
+    ] : [],
+    ...data.survivor === "variant" ? [
+      "Now run `baker experiment fold` \u2014 it moves the winning version into the page itself and archives the other one. Until that lands the page is served by a rewrite, and it cannot be tested again."
+    ] : [],
+    ...args.learning || data.verdict === "keep_running" ? [] : [
+      'Write down what this taught while it is fresh: `baker experiment update --id <id> --learning "\u2026"` \u2014 one or two sentences the client should believe about this page now. It is what the next test on this page starts from.'
+    ],
+    ...reason ? [] : [
+      "No `--reason` was given, so the record says what the numbers had reached but not why anyone stopped looking. Next time pass one: numbers_clear, not_settling, page_changing or test_flawed."
+    ]
+  ];
+}
 var finishCommand = defineCommand119({
   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."
+    description: "End a test now and send all its traffic to the version you name. Takes effect within seconds \u2014 nothing to publish. Read `baker experiment status` first: `winner` says which version the numbers favour, `keep_running` means they have not spoken yet and ending records `inconclusive`. Keeping the variant owes a `fold`. A test staged in this session and not yet published is simply taken back off it."
   },
   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
+    id: ID_ARG,
+    keep: {
+      type: "string",
+      description: "Which version stays live: `original` or `variant`.",
+      required: true
+    },
+    reason: REASON_ARG,
+    learning: LEARNING_ARG
+  },
+  run: async ({ args }) => {
+    const keep = String(args.keep);
+    if (keep !== "original" && keep !== "variant") {
+      fail5("`--keep` is either `original` or `variant` \u2014 which version should everyone see from now on?");
+    }
+    const reason = args.reason === void 0 ? void 0 : String(args.reason);
+    if (reason !== void 0 && !END_REASONS.some((known) => known === reason)) {
+      fail5(`\`--reason\` is one of ${END_REASONS.join(", ")} \u2014 why is this test being ended?`);
     }
+    try {
+      const response = await apiPost(
+        "/api/experiments/finish",
+        {
+          experimentId: String(args.id),
+          keep,
+          ...reason ? { reason } : {},
+          ...args.learning ? { learning: String(args.learning) } : {}
+        }
+      );
+      if ("unstaged" in response.data) {
+        writeJsonEnvelope({
+          ok: true,
+          data: response.data,
+          hints: ["That test had not been published yet, so it was taken back off this session. Nothing was split."]
+        });
+        return;
+      }
+      const data = response.data;
+      writeJsonEnvelope({ ok: true, data, hints: finishHints(data, { reason, learning: args.learning }) });
+    } catch (error) {
+      reportApiError(error);
+    }
+  }
+});
+registerSchema({
+  command: "experiment.cancel",
+  description: "Call a test off \u2014 take a staged one back off the session, or end a live one keeping the original",
+  args: { id: ID_ARG }
+});
+var cancelCommand = defineCommand119({
+  meta: {
+    name: "cancel",
+    description: "Call a test off. A test staged in this session and not yet published is simply taken back off it \u2014 nothing was split. A test that is live is ended now with everyone sent back to the original: what the numbers had said is recorded as it stood (usually `inconclusive`), and the variant page stays in the workspace, unserved. `finish --keep` is the same act with the choice of version; this is the shortcut for \u201Cstop, keep the page as it is\u201D."
   },
+  args: { id: ID_ARG },
   run: async ({ args }) => {
     try {
-      const response = await apiPost("/api/experiments/finish", {
-        experimentId: String(args.id),
-        ...args.abandon === true ? { abandon: true } : {}
+      const response = await apiPost(
+        "/api/experiments/finish",
+        { experimentId: String(args.id), keep: "original" }
+      );
+      if ("unstaged" in response.data) {
+        writeJsonEnvelope({
+          ok: true,
+          data: response.data,
+          hints: ["That test had not been published yet, so it was taken back off this session. Nothing was split."]
+        });
+        return;
+      }
+      const data = response.data;
+      writeJsonEnvelope({
+        ok: true,
+        data,
+        hints: [
+          "Ended. Everyone sees the original page now, and the split stopped within seconds.",
+          ...data.verdict === "keep_running" ? [
+            "It had not concluded, so it is recorded as inconclusive \u2014 nobody found out. Never report it as no difference."
+          ] : data.againstVerdict ? [
+            `The numbers favoured the new variant (${data.verdict}), so this is recorded as a decision against them. Say why in the write-up.`
+          ] : [],
+          "The variant page is still in the workspace and served to nobody. Run `baker experiment fold` to archive it, or leave it for a later test."
+        ]
       });
+    } catch (error) {
+      reportApiError(error);
+    }
+  }
+});
+registerSchema({
+  command: "experiment.update",
+  description: "Change what a test says about itself \u2014 its wording always, its measurement only while it is still staged",
+  args: {
+    id: ID_ARG,
+    because: { ...BECAUSE_ARG, required: false },
+    change: { ...CHANGE_ARG, required: false },
+    evidence: EVIDENCE_ARG,
+    expect: { ...EXPECT_ARG, description: "Staged tests only. `increase` or `decrease`." },
+    goal: { ...GOAL_ARG, description: "Staged tests only. The event the test is read on, by key." },
+    variantGoal: {
+      ...VARIANT_GOAL_ARG,
+      description: "Staged tests only. The new version's own event, when it differs."
+    },
+    lift: { ...LIFT_ARG, description: "Staged tests only. The smallest lift worth detecting." },
+    learning: LEARNING_ARG
+  }
+});
+var updateCommand3 = defineCommand119({
+  meta: {
+    name: "update",
+    description: "Change what a test says about itself. The observation (`--because`), the change in the client's words (`--change`) and the evidence cited (`--evidence`) can change at any time \u2014 they describe the test, and a write-up corrected after the fact is still the write-up of the same test. On a FINISHED test, `--learning` writes down what it taught. What the test MEASURES \u2014 `--goal`, `--lift`, `--expect` \u2014 can only change while it is still staged in this session: once visitors have been split, moving the goal or the finish line is how a result gets argued into existence. To measure something else on a live test, `finish` it and start a new one."
+  },
+  args: {
+    id: ID_ARG,
+    because: { ...BECAUSE_ARG, required: false },
+    change: { ...CHANGE_ARG, required: false },
+    evidence: EVIDENCE_ARG,
+    expect: { ...EXPECT_ARG, description: "Staged tests only. `increase` or `decrease`." },
+    goal: { ...GOAL_ARG, description: "Staged tests only. The event the test is read on, by key." },
+    variantGoal: {
+      ...VARIANT_GOAL_ARG,
+      description: "Staged tests only. The new version's own event, when it differs."
+    },
+    lift: { ...LIFT_ARG, description: "Staged tests only. The smallest lift worth detecting." },
+    learning: LEARNING_ARG
+  },
+  run: async ({ args, rawArgs }) => {
+    const request = buildUpdateRequest(args, rawArgs);
+    if ("error" in request) fail5(request.error);
+    try {
+      const response = await apiPost("/api/experiments/update", request);
       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.`
-          ] : [],
-          "Then run `baker experiment fold` \u2014 it moves the winning version into the page itself and archives the other one, so the page's own content is what visitors get. Until that lands the page is served by a rewrite, and it cannot be tested again."
+          response.data.staged ? "Updated and re-sized. It still starts when this session is published." : request.learning !== void 0 ? "Updated. What this test taught is on its record now, and `plan` hands it to the next test on this page." : "Updated. The test keeps running exactly as it was \u2014 only its wording changed.",
+          `It now reads: ${response.data.hypothesisStatement}`
         ]
       });
     } catch (error) {
@@ -39502,6 +40610,56 @@ var finishCommand = defineCommand119({
     }
   }
 });
+registerSchema({
+  command: "experiment.pause",
+  description: "Switch a test's split off \u2014 everyone sees the original until it is resumed",
+  args: { id: ID_ARG }
+});
+var pauseCommand = defineCommand119({
+  meta: {
+    name: "pause",
+    description: "Switch the split off now. Everyone sees the original; visitors already assigned keep their side, so resuming continues the same test rather than starting a new one. Use it when the new variant has to come down for a while \u2014 a broken price, a campaign that needs the original \u2014 without throwing the test away."
+  },
+  args: { id: ID_ARG },
+  run: async ({ args }) => {
+    try {
+      await apiPost("/api/experiments/pause", { experimentId: String(args.id) });
+      writeJsonEnvelope({
+        ok: true,
+        data: { paused: true },
+        hints: [
+          `Paused. Everyone sees the original page now. \`baker experiment resume --id ${String(args.id)}\` restarts the split with the same sides.`
+        ]
+      });
+    } catch (error) {
+      reportApiError(error);
+    }
+  }
+});
+registerSchema({
+  command: "experiment.resume",
+  description: "Switch a paused test's split back on",
+  args: { id: ID_ARG }
+});
+var resumeCommand = defineCommand119({
+  meta: {
+    name: "resume",
+    description: "Switch a paused test's split back on. Visitors already assigned see the same side they saw before."
+  },
+  args: { id: ID_ARG },
+  run: async ({ args }) => {
+    try {
+      await apiPost("/api/experiments/resume", { experimentId: String(args.id) });
+      writeJsonEnvelope({
+        ok: true,
+        data: { resumed: true },
+        hints: ["Resumed. The split is back on, with the same sides."]
+      });
+    } catch (error) {
+      reportApiError(error);
+    }
+  }
+});
 registerSchema({
   command: "experiment.fold",
   description: "Make the page's own content the version that won, and archive the one that lost",
@@ -39541,6 +40699,7 @@ var foldCommand = defineCommand119({
       if (folded.length > 0) {
         await apiPost("/api/experiments/fold", {
           applied: true,
+          experimentIds: folded.map((result) => result.experimentId),
           ...args.id ? { experimentId: String(args.id) } : {}
         });
       }
@@ -39563,13 +40722,18 @@ var foldCommand = defineCommand119({
 var experimentCommand = defineCommand119({
   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."
+    description: "Run an A/B test between a landing page and a new variant 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. Nothing ends a test on its own \u2014 `finish` does, when you or the client decide."
   },
   subCommands: {
     plan: planCommand,
     start: startCommand,
+    update: updateCommand3,
     status: statusCommand6,
+    history: historyCommand,
+    pause: pauseCommand,
+    resume: resumeCommand,
     finish: finishCommand,
+    cancel: cancelCommand,
     fold: foldCommand
   }
 });
@@ -39580,176 +40744,6 @@ import { defineCommand as defineCommand124 } from "citty";
 // src/commands/flows/add.ts
 import { randomUUID } from "crypto";
 import { defineCommand as defineCommand120 } from "citty";
-
-// src/commands/flows/shared.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
-var FLOWS_DIR = "src/lib/flow-engine/flows";
-function flowsDir() {
-  let dir = process.cwd();
-  for (let i = 0; i < 6; i++) {
-    const candidate = join3(dir, FLOWS_DIR);
-    if (existsSync5(candidate)) {
-      return candidate;
-    }
-    const parent = join3(dir, "..");
-    if (parent === dir) {
-      break;
-    }
-    dir = parent;
-  }
-  return join3(process.cwd(), FLOWS_DIR);
-}
-function failLocal(message) {
-  writeJson({ ok: false, error: { code: "NOT_FOUND", message } });
-  process.exit(1);
-}
-function listFlowSlugs() {
-  const dir = flowsDir();
-  if (!existsSync5(dir)) {
-    return [];
-  }
-  return readdirSync2(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && entry.name !== ".gitkeep").map((entry) => entry.name).sort();
-}
-function flowDataPath(slug) {
-  return join3(flowsDir(), slug, "_data.json");
-}
-function writeFlowTree(slug, tree) {
-  writeFileSync3(flowDataPath(slug), `${JSON.stringify(tree, null, 2)}
-`, "utf-8");
-}
-function walkNodes(node, acc = []) {
-  if (!node || typeof node !== "object") return acc;
-  acc.push(node);
-  if (Array.isArray(node.children)) {
-    for (const child of node.children) walkNodes(child, acc);
-  }
-  return acc;
-}
-function collectSideEffects(tree) {
-  return walkNodes(tree).flatMap(
-    (node) => Array.isArray(node.sideEffects) ? node.sideEffects.filter((sideEffect) => Boolean(sideEffect) && typeof sideEffect === "object").map((sideEffect) => ({ node, sideEffect })) : []
-  );
-}
-function readFlowTree(slug) {
-  const path42 = join3(flowsDir(), slug, "_data.json");
-  if (!existsSync5(path42)) {
-    failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
-  }
-  try {
-    return JSON.parse(readFileSync11(path42, "utf-8"));
-  } catch (error) {
-    failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function isConfigured(value) {
-  return typeof value === "string" && value.length > 0;
-}
-function nodeMeta(record) {
-  const nodeId = typeof record.id === "string" ? record.id : "";
-  const nodeName = typeof record.name === "string" ? record.name : void 0;
-  return { nodeId, ...nodeName ? { nodeName } : {} };
-}
-function widgetNodeStatus(record, meta) {
-  const nodeData = record.nodeData;
-  const nodeType = nodeData?.type;
-  if (typeof nodeType !== "string" || !FLOW_RESOURCE_NODE_TYPES.includes(nodeType)) {
-    return null;
-  }
-  const external = nodeData?.form?.external;
-  const selected = external != null && typeof external === "object";
-  const name = selected ? external.name : void 0;
-  return {
-    ...meta,
-    target: "node",
-    kind: nodeType,
-    status: selected ? `${nodeType} \u2014 selected${typeof name === "string" ? ` "${name}"` : ""}` : `${nodeType} \u2014 not selected`,
-    needsInput: !selected
-  };
-}
-function sideEffectNeedsInput(raw) {
-  const effect = raw;
-  const type = effect?.type;
-  if (typeof type !== "string" || !FLOW_SECRET_SIDE_EFFECT_TYPES.includes(type)) {
-    return false;
-  }
-  const configured = isConfigured(effect?.encryptedConfig);
-  if (!isFlowOauthSideEffect(type)) return !configured;
-  return !isConfigured(effect?.oauthProviderId) || !configured;
-}
-function sideEffectStatus(raw, meta) {
-  const effect = raw;
-  const type = effect?.type;
-  if (typeof type !== "string" || !FLOW_SECRET_SIDE_EFFECT_TYPES.includes(type)) {
-    return null;
-  }
-  const configured = isConfigured(effect?.encryptedConfig);
-  const oauth = isFlowOauthSideEffect(type);
-  const connected = isConfigured(effect?.oauthProviderId);
-  const needs = FLOW_SECRET_FIELDS[type];
-  const status = oauth ? `${type} \u2014 connection ${connected ? "[connected]" : "[needs connection]"}, config ${configured ? "[set]" : "[missing]"}` : configured ? `${type} \u2014 [configured]` : `${type} \u2014 [missing]${needs.length > 0 ? ` (needs: ${needs.join(", ")})` : ""}`;
-  return {
-    ...meta,
-    target: "sideEffect",
-    ...typeof effect?.id === "string" ? { sideEffectId: effect.id } : {},
-    kind: type,
-    status,
-    needsInput: sideEffectNeedsInput(effect)
-  };
-}
-function requestFlowInputCall(slug, status) {
-  const args = status.target === "node" ? `{ target: "node", flowSlug: "${slug}", nodeId: "${status.nodeId}", nodeType: "${status.kind}" }` : `{ target: "sideEffect", flowSlug: "${slug}", nodeId: "${status.nodeId}", sideEffectId: "${status.sideEffectId}", sideEffectType: "${status.kind}" }`;
-  return `request_flow_input with ${args}`;
-}
-function collectConfigStatus(node, acc) {
-  if (!node || typeof node !== "object") {
-    return;
-  }
-  const record = node;
-  const meta = nodeMeta(record);
-  const widget = widgetNodeStatus(record, meta);
-  if (widget) {
-    acc.push(widget);
-  }
-  if (Array.isArray(record.sideEffects)) {
-    for (const raw of record.sideEffects) {
-      const status = sideEffectStatus(raw, meta);
-      if (status) {
-        acc.push(status);
-      }
-    }
-  }
-  if (Array.isArray(record.children)) {
-    for (const child of record.children) {
-      collectConfigStatus(child, acc);
-    }
-  }
-}
-function redactTree(node) {
-  if (Array.isArray(node)) {
-    return node.map(redactTree);
-  }
-  if (!node || typeof node !== "object") {
-    return node;
-  }
-  const out = {};
-  for (const [key, value] of Object.entries(node)) {
-    if (key === "encryptedConfig") {
-      out[key] = isConfigured(value) ? "[configured]" : value;
-    } else {
-      out[key] = redactTree(value);
-    }
-  }
-  return out;
-}
-function stepNameKey(name) {
-  return name.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toUpperCase();
-}
-function isUsableStepNameKey(key) {
-  return /^[\p{ID_Start}$_][\p{ID_Continue}$‌‍]*$/u.test(key);
-}
-
-// src/commands/flows/add.ts
 function unknownType(kind, type) {
   writeJson({
     ok: false,
@@ -39840,6 +40834,10 @@ var addNodeCommand = defineCommand120({
       data: { slug, nodeId: node.id, type, parentId: parent.id ?? null, path: flowDataPath(slug) },
       hints: [
         `Now fill in this step's \`ai\` field and its copy by editing ${flowDataPath(slug)}.`,
+        // Said on every step added, because the moment a Form's shape changes
+        // is the moment its outcome can move — and a Form nobody named an
+        // outcome for reports zero conversions rather than an error.
+        `Say what this Form counts before you finish: \`baker analytics conversions --flow ${slug}\` lists every ending already spelled as an event key, including this step's. Nothing in _data.json decides it.`,
         ...entry.owners?.["nodeData.form.external"] === "request_flow_input" ? [
           `A ${type} node's resource is picked by the user: call request_flow_input with { target: "node", flowSlug: "${slug}", nodeId: "${node.id}", nodeType: "${type}" }.`
         ] : [],
@@ -39953,6 +40951,13 @@ var addSideEffectCommand = defineCommand120({
       data: { slug, nodeId: node.id, sideEffectId: id, type, triggerId, path: flowDataPath(slug) },
       hints: [
         `Fires on \`${triggerId}\` \u2014 the moment "${String(node.name ?? node.id)}" raises. A side effect only runs when its triggerId is the one its own step raises, so this is set from the step, never from the side-effect type.`,
+        // A pixel side effect is the thing most often mistaken for "setting the
+        // conversion". It tells the ad platform; it tells Baker nothing, and a
+        // Form can fire every pixel it has while every Baker report says it
+        // converted nobody.
+        ...needsUser.some(([, owner]) => owner === "tags") ? [
+          `This reports the conversion to ${type}. It does NOT make Baker count anything: what Baker counts is a named event, set with \`baker analytics conversions --flow ${slug}\`. Do both \u2014 they are two different systems asked the same question.`
+        ] : [],
         ...needsUser.some(([, owner]) => owner === "request_flow_input") ? [
           `Configure it: request_flow_input with { target: "sideEffect", flowSlug: "${slug}", nodeId: "${node.id}", sideEffectId: "${id}", sideEffectType: "${type}" }. Read the destination straight off that call's result.`
         ] : [],
@@ -39966,11 +40971,11 @@ var addSideEffectCommand = defineCommand120({
 });
 
 // src/commands/flows/map.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { defineCommand as defineCommand121 } from "citty";
 
 // src/commands/flows/value-expression.ts
-import { existsSync as existsSync6, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync13 } from "fs";
 import { join as join4 } from "path";
 var PREFIXES = ["field", "tracking", "global", "code"];
 function splitParts(raw) {
@@ -40029,10 +41034,10 @@ function parseValueExpression(raw) {
   return parts.map(parsePart);
 }
 function trackingFieldIds() {
-  const path42 = join4(flowsDir(), "..", "tracking.ts");
-  if (!existsSync6(path42)) return null;
+  const path44 = join4(flowsDir(), "..", "tracking.ts");
+  if (!existsSync6(path44)) return null;
   try {
-    const source = readFileSync12(path42, "utf-8");
+    const source = readFileSync13(path44, "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]);
@@ -40573,13 +41578,13 @@ function specsFromFile(parsed) {
     return `${destField}${type}=${entry?.value ?? ""}`;
   });
 }
-function readSpecFile(path42) {
+function readSpecFile(path44) {
   let raw;
   try {
-    raw = path42 === "-" ? readFileSync13(0, "utf-8") : readFileSync13(path42, "utf-8");
+    raw = path44 === "-" ? readFileSync14(0, "utf-8") : readFileSync14(path44, "utf-8");
   } catch (error) {
     refuse(
-      `Could not read ${path42 === "-" ? "the mapping from stdin" : `"${path42}"`}: ${error instanceof Error ? error.message : String(error)}`
+      `Could not read ${path44 === "-" ? "the mapping from stdin" : `"${path44}"`}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   let parsed;
@@ -40587,7 +41592,7 @@ function readSpecFile(path42) {
     parsed = JSON.parse(raw);
   } catch (error) {
     refuse(
-      `${path42 === "-" ? "stdin" : `"${path42}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      `${path44 === "-" ? "stdin" : `"${path44}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
       'Expected { "map": { "<destField>": "<value>", \u2026 } }'
     );
   }
@@ -40857,18 +41862,18 @@ var ARRAY_FIELDS = [
   "tagIds"
 ];
 var ARRAY_OWNERS = ["", "body"];
-function dropUnsetOptionals(sideEffect, path42) {
+function dropUnsetOptionals(sideEffect, path44) {
   return OPTIONAL_STRINGS.flatMap((key) => {
     if (!(key in sideEffect) || sideEffect[key] !== null && sideEffect[key] !== "") return [];
     delete sideEffect[key];
-    return [{ path: path42, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
+    return [{ path: path44, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
   });
 }
-function fillNulledArrays(target, prefix, path42) {
+function fillNulledArrays(target, prefix, path44) {
   return ARRAY_FIELDS.flatMap((key) => {
     if (!(key in target) || target[key] !== null) return [];
     target[key] = [];
-    return [{ path: path42, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
+    return [{ path: path44, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
   });
 }
 function sideEffectsOf(node) {
@@ -40878,13 +41883,13 @@ function sideEffectsOf(node) {
   );
 }
 function normalizeSideEffect(sideEffect, where) {
-  const path42 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
+  const path44 = `${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}.` : "", path42);
+    return fillNulledArrays(target, owner ? `${owner}.` : "", path44);
   });
-  return [...dropUnsetOptionals(sideEffect, path42), ...arrays];
+  return [...dropUnsetOptionals(sideEffect, path44), ...arrays];
 }
 function normalizeFlowTree(tree) {
   const changes = [];
@@ -41117,9 +42122,15 @@ var listCommand13 = defineCommand124({
     writeJson({
       ok: true,
       data: { flows },
-      hints: pending.length > 0 ? [
-        `Still waiting on the user: ${pending.map((flow) => `${flow.slug} (${flow.needsConfig})`).join(", ")}. \`baker flows show <slug>\` returns the request_flow_input call for each.`
-      ] : []
+      hints: [
+        ...pending.length > 0 ? [
+          `Still waiting on the user: ${pending.map((flow) => `${flow.slug} (${flow.needsConfig})`).join(", ")}. \`baker flows show <slug>\` returns the request_flow_input call for each.`
+        ] : [],
+        // "Set the conversions on the Forms" lands here first, and nothing in
+        // this family can do it — the conversion side effects it does offer
+        // fire a pixel and are not what any Baker report counts.
+        "Setting what a Form COUNTS is not in this family: a conversion is a named event held in Baker. `baker analytics conversions` lists what this company counts; `--flow <slug>` spells one Form's endings as keys you can count, traffic or no traffic."
+      ]
     });
   }
 });
@@ -41147,7 +42158,15 @@ var showCommand4 = defineCommand124({
       data: response,
       // Inert side effects first: an unconfigured destination is work still to
       // do, but a side effect wired to the wrong moment reads as done.
-      hints: [...inertSideEffectHints(tree), ...pendingInputHints(slug, config)]
+      hints: [
+        ...inertSideEffectHints(tree),
+        ...pendingInputHints(slug, config),
+        // The question this command is asked — "is this Form wired up?" — has
+        // an answer that is not in this file at all. What a Form counts is a
+        // named event in Baker, and a Form can be perfectly configured, fire
+        // every pixel it has, and still report converting nobody.
+        `What this Form counts as a conversion is NOT in _data.json and not in any side effect here: it is a named event held in Baker. Read it, and this Form's own endings spelled as event keys, with \`baker analytics conversions --flow ${slug}\`.`
+      ]
     });
   }
 });
@@ -41312,7 +42331,7 @@ Examples:
 import { defineCommand as defineCommand126 } from "citty";
 
 // src/commands/ga4/shared.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 function failValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
@@ -41328,7 +42347,7 @@ function requireTarget5(args, entity) {
 function readJsonSource(args, flag) {
   const inline = args[flag];
   const file = args.file;
-  const raw = typeof file === "string" && file.length > 0 ? readFileSync14(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
+  const raw = typeof file === "string" && file.length > 0 ? readFileSync15(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
   if (raw === void 0) {
     failValidation3(`pass --${flag} with inline JSON or --file with a path to a JSON file`);
   }
@@ -41422,10 +42441,10 @@ async function stageOps(ops) {
     handleError2(err);
   }
 }
-async function draftAction2(path42, body, chat) {
+async function draftAction2(path44, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path42, { chatId, ...body });
+    const data = await apiPost(path44, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -41679,7 +42698,7 @@ Examples:
 });
 
 // src/commands/ga4/query.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync4 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync16, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve2 } from "path";
 import { defineCommand as defineCommand129 } from "citty";
 
@@ -41770,7 +42789,7 @@ function writeRowsToFile2(filePath, rows, append) {
       writeFileSync4(filePath, content, "utf-8");
     }
   } else if (append && existsSync7(filePath)) {
-    const existing = JSON.parse(readFileSync15(filePath, "utf-8"));
+    const existing = JSON.parse(readFileSync16(filePath, "utf-8"));
     writeFileSync4(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync4(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -42622,7 +43641,7 @@ Full guide: __tooling__/docs/tools/baker/ga4.md`
 import { defineCommand as defineCommand135 } from "citty";
 
 // src/commands/gsc/query.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync8, readFileSync as readFileSync16, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync5 } from "fs";
 import { resolve as resolve3 } from "path";
 import { defineCommand as defineCommand132 } from "citty";
 
@@ -42770,7 +43789,7 @@ function writeRowsToFile3(filePath, rows, append) {
       writeFileSync5(filePath, content, "utf-8");
     }
   } else if (append && existsSync8(filePath)) {
-    const existing = JSON.parse(readFileSync16(filePath, "utf-8"));
+    const existing = JSON.parse(readFileSync17(filePath, "utf-8"));
     writeFileSync5(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync5(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -43147,7 +44166,7 @@ var listCommand14 = defineCommand136({
     }
   }
 });
-var historyCommand = defineCommand136({
+var historyCommand2 = defineCommand136({
   meta: {
     name: "history",
     description: `Unified account history (audit log): what changed, who did it, and when.
@@ -43839,7 +44858,7 @@ function cropSprite(input, region) {
 
 // src/lib/image/io.ts
 import { randomBytes } from "crypto";
-import { glob as fsGlob, readFile as readFile22, rename, stat as stat6, writeFile as writeFile12 } from "fs/promises";
+import { glob as fsGlob, readFile as readFile24, rename, stat as stat6, writeFile as writeFile12 } 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 = /[*?[\]{}]/;
@@ -43872,11 +44891,11 @@ async function readImageBuffer(pathOrUrl) {
     const { buffer } = await fetchExternalBytes(pathOrUrl, { maxBytes: MAX_REMOTE_IMAGE_BYTES });
     return buffer;
   }
-  return readFile22(pathOrUrl);
+  return readFile24(pathOrUrl);
 }
-async function isDirectory(path42) {
+async function isDirectory(path44) {
   try {
-    const s = await stat6(path42);
+    const s = await stat6(path44);
     return s.isDirectory();
   } catch {
     return false;
@@ -44195,13 +45214,13 @@ function resolveDownloadPath({ baseName, extension, out, outIsDirectory: outIsDi
 }
 function disambiguate(paths) {
   const taken = /* @__PURE__ */ new Set();
-  return paths.map((path42) => {
-    if (!taken.has(path42)) {
-      taken.add(path42);
-      return path42;
+  return paths.map((path44) => {
+    if (!taken.has(path44)) {
+      taken.add(path44);
+      return path44;
     }
-    const ext = extname3(path42);
-    const stem = path42.slice(0, path42.length - ext.length);
+    const ext = extname3(path44);
+    const stem = path44.slice(0, path44.length - ext.length);
     let n = 2;
     while (taken.has(`${stem}-${n}${ext}`)) n += 1;
     const unique = `${stem}-${n}${ext}`;
@@ -44327,10 +45346,10 @@ async function runDownloads(plan) {
   const paths = disambiguate(fetched.map((item) => item.path));
   const downloaded = [];
   for (const [index, item] of fetched.entries()) {
-    const path42 = paths[index] ?? item.path;
+    const path44 = paths[index] ?? item.path;
     try {
-      await atomicWrite(path42, item.buffer);
-      downloaded.push({ input: item.input, output: path42, bytes: item.buffer.length, contentType: item.contentType });
+      await atomicWrite(path44, item.buffer);
+      downloaded.push({ input: item.input, output: path44, bytes: item.buffer.length, contentType: item.contentType });
     } catch (err) {
       failed.push({ input: item.input, error: failureMessage(err, "Write failed") });
     }
@@ -47294,8 +48313,8 @@ Full guide: __tooling__/docs/tools/baker/images.md`
 import { defineCommand as defineCommand175 } from "citty";
 
 // src/commands/landing/critique.ts
-import { readdir as readdir10, readFile as readFile24, stat as stat7 } from "fs/promises";
-import path31 from "path";
+import { readdir as readdir12, readFile as readFile26, stat as stat8 } from "fs/promises";
+import path33 from "path";
 import { defineCommand as defineCommand164 } from "citty";
 
 // src/engine/landing/lib/constants.ts
@@ -48473,13 +49492,13 @@ function describeCounts(findings) {
 
 // src/commands/landing/snapshot.ts
 import { mkdir as mkdir9, rename as rename2, writeFile as writeFile13 } from "fs/promises";
-import path29 from "path";
+import path31 from "path";
 var CRITIC_VERSION = "3";
 function critiqueCacheDir(projectRoot) {
-  return path29.join(projectRoot, ".cache", "landing-critique");
+  return path31.join(projectRoot, ".cache", "landing-critique");
 }
 function snapshotPath(projectRoot, slug) {
-  return path29.join(critiqueCacheDir(projectRoot), `${slug}.json`);
+  return path31.join(critiqueCacheDir(projectRoot), `${slug}.json`);
 }
 async function writeCritiqueSnapshot(projectRoot, snapshot) {
   await mkdir9(critiqueCacheDir(projectRoot), { recursive: true });
@@ -48491,8 +49510,8 @@ async function writeCritiqueSnapshot(projectRoot, snapshot) {
 }
 
 // src/commands/landing/source-version.ts
-import { readFile as readFile23 } from "fs/promises";
-import path30 from "path";
+import { readdir as readdir11, readFile as readFile25, stat as stat7 } from "fs/promises";
+import path32 from "path";
 var CRITIQUED_ROOTS = ["src/pages/", "src/components/"];
 async function landingSourceRelPaths(root, slug) {
   const files = await landingGraphFiles(root, slug);
@@ -48501,7 +49520,7 @@ async function landingSourceRelPaths(root, slug) {
 async function readLandingSources(root, slug) {
   const rel = await landingSourceRelPaths(root, slug);
   const out = [];
-  for (const r of rel) out.push({ path: r, text: await readFile23(path30.join(root, r), "utf8") });
+  for (const r of rel) out.push({ path: r, text: await readFile25(path32.join(root, r), "utf8") });
   return out;
 }
 async function computeLandingSourceSha(root, slug) {
@@ -48510,7 +49529,7 @@ async function computeLandingSourceSha(root, slug) {
   for (const r of rel) {
     let bytes;
     try {
-      bytes = await readFile23(path30.join(root, r));
+      bytes = await readFile25(path32.join(root, r));
     } catch {
       bytes = Buffer.alloc(0);
     }
@@ -48518,6 +49537,47 @@ async function computeLandingSourceSha(root, slug) {
   }
   return sha256Hex(Buffer.concat(parts));
 }
+async function computeLegacyLandingSourceSha(landingDir) {
+  const rel = [];
+  if (await isFile2(path32.join(landingDir, "index.astro"))) rel.push("index.astro");
+  for (const abs of await walkAstro(path32.join(landingDir, "_components"))) {
+    rel.push(path32.relative(landingDir, abs).split(path32.sep).join("/"));
+  }
+  rel.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const parts = [];
+  for (const r of rel) {
+    let bytes;
+    try {
+      bytes = await readFile25(path32.join(landingDir, r));
+    } catch {
+      bytes = Buffer.alloc(0);
+    }
+    parts.push(Buffer.from(`${r}\0${bytes.length}\0`), bytes);
+  }
+  return sha256Hex(Buffer.concat(parts));
+}
+async function isFile2(p) {
+  try {
+    return (await stat7(p)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function walkAstro(dir) {
+  let entries;
+  try {
+    entries = await readdir11(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    const abs = path32.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({
@@ -48573,7 +49633,7 @@ var critiqueCommand2 = defineCommand164({
           { availableSlugs: await listLandingSlugs(projectRoot) }
         );
       }
-      if (!await isDir2(path31.resolve(projectRoot, "src", "pages", slug))) {
+      if (!await isDir2(path33.resolve(projectRoot, "src", "pages", slug))) {
         fail6("NOT_FOUND", `No landing at src/pages/${slug}/`, {
           availableSlugs: await listLandingSlugs(projectRoot)
         });
@@ -48613,15 +49673,17 @@ var critiqueCommand2 = defineCommand164({
   }
 });
 async function critiqueOne(projectRoot, slug, brand, competitors) {
-  const [sources, sourceSha] = await Promise.all([
+  const [sources, compositionSha, sourceSha] = await Promise.all([
     readLandingSources(projectRoot, slug),
-    computeLandingSourceSha(projectRoot, slug)
+    computeLandingSourceSha(projectRoot, slug),
+    computeLegacyLandingSourceSha(path33.resolve(projectRoot, "src", "pages", slug))
   ]);
   const report = critiqueLanding({ slug, sources, brand, competitors });
   let snapshotFailed = false;
   try {
     await writeCritiqueSnapshot(projectRoot, {
       slug,
+      compositionSha,
       sourceSha,
       criticVersion: CRITIC_VERSION,
       at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -48634,18 +49696,18 @@ async function critiqueOne(projectRoot, slug, brand, competitors) {
   return { slug, report, snapshotFailed };
 }
 async function readCompetitorNames(projectRoot) {
-  const dir = path31.join(projectRoot, "src", "content", "competitors");
+  const dir = path33.join(projectRoot, "src", "content", "competitors");
   let entries;
   try {
-    entries = (await readdir10(dir)).filter((f) => f.endsWith(".md"));
+    entries = (await readdir12(dir)).filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
   const names = [];
   for (const entry of entries) {
-    names.push(path31.basename(entry, ".md").replace(/[-_]+/g, " "));
+    names.push(path33.basename(entry, ".md").replace(/[-_]+/g, " "));
     try {
-      const head = (await readFile24(path31.join(dir, entry), "utf8")).slice(0, 2e3);
+      const head = (await readFile26(path33.join(dir, entry), "utf8")).slice(0, 2e3);
       const titled = /^\s*(?:title|name)\s*:\s*["']?([^"'\n]+)["']?\s*$/im.exec(head);
       if (titled?.[1]) names.push(titled[1].trim());
     } catch {
@@ -48655,7 +49717,7 @@ async function readCompetitorNames(projectRoot) {
 }
 async function listLandingSlugs(projectRoot) {
   try {
-    const entries = await readdir10(path31.join(projectRoot, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir12(path33.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 [];
@@ -48674,7 +49736,7 @@ function present(f) {
 }
 async function isDir2(p) {
   try {
-    return (await stat7(p)).isDirectory();
+    return (await stat8(p)).isDirectory();
   } catch {
     return false;
   }
@@ -48807,7 +49869,7 @@ var addCommand = defineCommand165({
 
 // src/commands/landing/inspiration/code.ts
 import { mkdir as mkdir10, writeFile as writeFile14 } from "fs/promises";
-import path32 from "path";
+import path34 from "path";
 import { defineCommand as defineCommand166 } from "citty";
 registerSchema({
   command: "landing.inspiration.code",
@@ -48830,9 +49892,9 @@ var codeCommand = defineCommand166({
     try {
       const id = args.id;
       const data = await apiGet("/api/landing-inspiration/section-code", { id });
-      const dir = path32.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path34.join(process.cwd(), ".baker", "inspiration", id);
       await mkdir10(dir, { recursive: true });
-      const file = path32.join(dir, "section.html");
+      const file = path34.join(dir, "section.html");
       await writeFile14(file, data.html);
       const hints2 = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
       const fidelity = fidelityHint(data.fidelity);
@@ -48842,7 +49904,7 @@ var codeCommand = defineCommand166({
         ok: true,
         data: {
           id,
-          file: path32.relative(process.cwd(), file),
+          file: path34.relative(process.cwd(), file),
           bytes: data.html.length,
           fidelity: data.fidelity,
           reproduction_notes: data.reproductionNotes,
@@ -49274,7 +50336,7 @@ function classifyCaptureFailure(error) {
 
 // src/engine/landing-library/run.ts
 import { mkdir as mkdir11, writeFile as writeFile16 } from "fs/promises";
-import path34 from "path";
+import path36 from "path";
 
 // ../proxy/src/preflight.ts
 import http from "http";
@@ -49413,7 +50475,7 @@ var inPageCollectUsedCss = (selector) => {
     }
     return false;
   };
-  const walk = (rules, sink) => {
+  const walk2 = (rules, sink) => {
     for (const rule of Array.from(rules)) {
       totalRules++;
       if (rule instanceof CSSStyleRule) {
@@ -49434,7 +50496,7 @@ var inPageCollectUsedCss = (selector) => {
       const grouping = rule instanceof CSSMediaRule || rule instanceof CSSSupportsRule || typeof CSSLayerBlockRule !== "undefined" && rule instanceof CSSLayerBlockRule || typeof CSSContainerRule !== "undefined" && rule instanceof CSSContainerRule;
       if (grouping) {
         const inner = [];
-        walk(rule.cssRules, inner);
+        walk2(rule.cssRules, inner);
         if (inner.length === 0) continue;
         const condition = rule.conditionText ?? "";
         const prelude = rule instanceof CSSMediaRule ? `@media ${condition}` : rule.cssText.split("{")[0]?.trim();
@@ -49448,7 +50510,7 @@ ${inner.join("\n")}
     const owner = sheet.ownerNode;
     if (owner?.hasAttribute?.("data-baker-freeze")) continue;
     try {
-      walk(sheet.cssRules, kept);
+      walk2(sheet.cssRules, kept);
     } catch {
       if (sheet.href) unreadableHrefs.push(sheet.href);
     }
@@ -49899,7 +50961,7 @@ var inPageCollectMotion = (selector) => {
     else if (infinite) loop.push(effect);
     else entrance.push(effect);
   };
-  const walk = (rules, insideScrollTimeline) => {
+  const walk2 = (rules, insideScrollTimeline) => {
     for (const rule of Array.from(rules)) {
       if (rule instanceof CSSKeyframesRule) {
         keyframesByName.set(rule.name, rule.cssText);
@@ -49917,17 +50979,17 @@ var inPageCollectMotion = (selector) => {
           respectsReducedMotion = true;
           continue;
         }
-        walk(rule.cssRules, insideScrollTimeline);
+        walk2(rule.cssRules, insideScrollTimeline);
         continue;
       }
       const grouping = rule;
-      if (grouping.cssRules) walk(grouping.cssRules, insideScrollTimeline);
+      if (grouping.cssRules) walk2(grouping.cssRules, insideScrollTimeline);
     }
   };
   for (const sheet of Array.from(document.styleSheets)) {
     if (sheet.ownerNode?.hasAttribute?.("data-baker-freeze")) continue;
     try {
-      walk(sheet.cssRules, false);
+      walk2(sheet.cssRules, false);
     } catch {
     }
   }
@@ -50690,9 +51752,9 @@ async function renderBundleToPng(browser, html, viewportWidth, options = {}) {
 
 // src/engine/landing-library/report.ts
 import { writeFile as writeFile15 } from "fs/promises";
-import path33 from "path";
+import path35 from "path";
 async function writeCaptureReport(manifest, outDir) {
-  const file = path33.join(outDir, "report.html");
+  const file = path35.join(outDir, "report.html");
   await writeFile15(file, renderReport(manifest));
   return file;
 }
@@ -50871,32 +51933,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 writeFile16(path34.join(outDir, "page.html"), built.html);
+  await writeFile16(path36.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 writeFile16(path34.join(outDir, "page-rendered.png"), rendered);
+  await writeFile16(path36.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 = path34.join(sectionsDir, String(candidate.index).padStart(2, "0"));
+  const dir = path36.join(sectionsDir, String(candidate.index).padStart(2, "0"));
   await mkdir11(dir, { recursive: true });
   const desktop = await captureSection(page, candidate);
-  if (desktop) await writeFile16(path34.join(dir, "desktop.png"), desktop);
+  if (desktop) await writeFile16(path36.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 writeFile16(path34.join(dir, "section.html"), built.html);
+    await writeFile16(path36.join(dir, "section.html"), built.html);
     const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width);
     if (rendered && desktop) {
-      await writeFile16(path34.join(dir, "section-rendered.png"), rendered);
+      await writeFile16(path36.join(dir, "section-rendered.png"), rendered);
       const result = await scoreFidelity(desktop, rendered);
       fidelity = result.score;
       fidelityNote = result.note;
@@ -50904,9 +51966,9 @@ async function captureOneSection(args) {
   }
   return {
     ...candidate,
-    desktopShot: desktop ? path34.relative(outDir, path34.join(dir, "desktop.png")) : null,
+    desktopShot: desktop ? path36.relative(outDir, path36.join(dir, "desktop.png")) : null,
     mobileShot: null,
-    bundle: built ? path34.relative(outDir, path34.join(dir, "section.html")) : null,
+    bundle: built ? path36.relative(outDir, path36.join(dir, "section.html")) : null,
     fidelity,
     ...fidelityNote ? { fidelityNote } : {},
     ...built ? { cssStats: built.stats } : {},
@@ -50925,9 +51987,9 @@ async function captureMobileShots(args) {
     for (const section of sections) {
       const shot = await captureSectionOnMobile(mobile.page, section);
       if (!shot) continue;
-      const file = path34.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
+      const file = path36.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
       await writeFile16(file, shot);
-      section.mobileShot = path34.relative(outDir, file);
+      section.mobileShot = path36.relative(outDir, file);
     }
   } finally {
     await mobile.context.close();
@@ -50942,10 +52004,10 @@ async function captureMotionTakes(args) {
   const filmOne = async (section) => {
     const take = await captureMotionTake(browser, pageUrl, section.selector).catch(() => null);
     if (!take) return;
-    const dir = path34.join(sectionsDir, String(section.index).padStart(2, "0"));
-    const file = path34.join(dir, "motion-filmstrip.png");
+    const dir = path36.join(sectionsDir, String(section.index).padStart(2, "0"));
+    const file = path36.join(dir, "motion-filmstrip.png");
     await writeFile16(file, take.filmstrip);
-    section.motionFilmstrip = path34.relative(outDir, file);
+    section.motionFilmstrip = path36.relative(outDir, file);
     log(`  [${section.index}] ${section.motion.summary}`);
   };
   const queue = [...moving];
@@ -51002,7 +52064,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 writeFile16(path34.join(outDir, "full-page.png"), fullPage);
+  if (fullPage) await writeFile16(path36.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)}`);
@@ -51073,7 +52135,7 @@ async function openViaLadder(args) {
 async function scrapeLanding(options) {
   const timeoutMs = options.timeoutMs ?? 45e3;
   const log = options.onProgress ?? (() => void 0);
-  const sectionsDir = path34.join(options.outDir, "sections");
+  const sectionsDir = path36.join(options.outDir, "sections");
   const nonPublic = refuseNonPublicUrl(options.url);
   if (nonPublic) {
     throw new BlockedPageError({
@@ -51135,7 +52197,7 @@ async function scrapeLanding(options) {
       security: prepared.security,
       captureTier: tier
     };
-    await writeFile16(path34.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile16(path36.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
     if (options.report !== false) {
       const reportPath = await writeCaptureReport(manifest, options.outDir);
@@ -51150,28 +52212,28 @@ async function scrapeLanding(options) {
 
 // src/commands/landing/inspiration/captureOut.ts
 import { existsSync as existsSync9 } from "fs";
-import path35 from "path";
+import path37 from "path";
 var SCRATCH_DIR = ".baker";
 function isWithin(parent, target) {
-  const relative = path35.relative(parent, target);
-  return relative === "" || !relative.startsWith("..") && !path35.isAbsolute(relative);
+  const relative = path37.relative(parent, target);
+  return relative === "" || !relative.startsWith("..") && !path37.isAbsolute(relative);
 }
 function findRepoRoot(from) {
-  let dir = path35.resolve(from);
+  let dir = path37.resolve(from);
   for (; ; ) {
-    if (existsSync9(path35.join(dir, ".git"))) return dir;
-    const parent = path35.dirname(dir);
+    if (existsSync9(path37.join(dir, ".git"))) return dir;
+    const parent = path37.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function checkCaptureOut(out, options) {
   const { cwd, repoRoot } = options;
-  const resolved = path35.resolve(cwd, out);
+  const resolved = path37.resolve(cwd, out);
   if (repoRoot === null || !isWithin(repoRoot, resolved)) return { ok: true };
-  const scratch = path35.join(repoRoot, SCRATCH_DIR);
+  const scratch = path37.join(repoRoot, SCRATCH_DIR);
   if (isWithin(scratch, resolved)) return { ok: true };
-  const suggestion = path35.posix.join(SCRATCH_DIR, "teardowns", path35.basename(resolved) || "capture");
+  const suggestion = path37.posix.join(SCRATCH_DIR, "teardowns", path37.basename(resolved) || "capture");
   return {
     ok: false,
     error: {
@@ -51345,12 +52407,12 @@ var scrapeCommand = defineCommand169({
 });
 
 // src/commands/landing/inspiration/search.ts
-import path37 from "path";
+import path39 from "path";
 import { defineCommand as defineCommand170 } from "citty";
 
 // src/commands/landing/inspiration/shot.ts
 import { mkdir as mkdir12, writeFile as writeFile17 } from "fs/promises";
-import path36 from "path";
+import path38 from "path";
 import sharp6 from "sharp";
 var READABLE_SHOT = {
   maxWidth: 1440,
@@ -51376,9 +52438,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 mkdir12(path36.dirname(file), { recursive: true });
+    await mkdir12(path38.dirname(file), { recursive: true });
     await writeFile17(file, shot);
-    return path36.relative(process.cwd(), file);
+    return path38.relative(process.cwd(), file);
   } catch {
     return null;
   }
@@ -51470,13 +52532,13 @@ function buildSearchBody(args) {
   return body;
 }
 async function downloadShots(results) {
-  const dir = path37.join(process.cwd(), ".baker", "inspiration");
+  const dir = path39.join(process.cwd(), ".baker", "inspiration");
   const saved = /* @__PURE__ */ new Map();
   await Promise.all(
     results.map(async (result) => {
       const file = await downloadReadableShot(
         result.desktopShotUrl,
-        path37.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
+        path39.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
       );
       if (file) saved.set(result.id, file);
     })
@@ -51704,7 +52766,7 @@ var sequencesCommand = defineCommand171({
 });
 
 // src/commands/landing/inspiration/view.ts
-import path38 from "path";
+import path40 from "path";
 import { defineCommand as defineCommand172 } from "citty";
 registerSchema({
   command: "landing.inspiration.view",
@@ -51737,12 +52799,12 @@ var viewCommand2 = defineCommand172({
       const id = args.id;
       const data = await apiGet("/api/landing-inspiration/section", { id });
       const section = data.section;
-      const dir = path38.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path40.join(process.cwd(), ".baker", "inspiration", id);
       const ext = READABLE_SHOT.extension;
       const [desktop, mobile, filmstrip] = await Promise.all([
-        downloadReadableShot(section.desktopShotUrl, path38.join(dir, `desktop.${ext}`)),
-        downloadReadableShot(section.mobileShotUrl, path38.join(dir, `mobile.${ext}`)),
-        downloadReadableShot(section.motionFilmstripUrl, path38.join(dir, `motion-filmstrip.${ext}`))
+        downloadReadableShot(section.desktopShotUrl, path40.join(dir, `desktop.${ext}`)),
+        downloadReadableShot(section.mobileShotUrl, path40.join(dir, `mobile.${ext}`)),
+        downloadReadableShot(section.motionFilmstripUrl, path40.join(dir, `motion-filmstrip.${ext}`))
       ]);
       const full = args.full;
       const hints2 = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
@@ -51848,8 +52910,8 @@ Full guide: __tooling__/docs/tools/baker/landing.md`
 
 // src/commands/landing/variant.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir13, readdir as readdir11, readFile as readFile25, stat as stat8, writeFile as writeFile18 } from "fs/promises";
-import path39 from "path";
+import { mkdir as mkdir13, readdir as readdir13, readFile as readFile27, stat as stat9, writeFile as writeFile18 } from "fs/promises";
+import path41 from "path";
 import { defineCommand as defineCommand174 } from "citty";
 registerSchema({
   command: "landing.variant",
@@ -51876,7 +52938,7 @@ registerSchema({
 var SLUG_RE2 = /^[a-z0-9][a-z0-9-]*$/;
 async function readInternalId(definitionPath) {
   try {
-    const text2 = await readFile25(definitionPath, "utf8");
+    const text2 = await readFile27(definitionPath, "utf8");
     return /^internalId:\s*"?([^"\s]+)"?\s*$/m.exec(text2)?.[1] ?? null;
   } catch {
     return null;
@@ -51885,7 +52947,7 @@ async function readInternalId(definitionPath) {
 async function archivedVariantNumbers(root, internalId) {
   if (!internalId) return [];
   try {
-    const entries = await readdir11(path39.resolve(root, "src/_variants", internalId), { withFileTypes: true });
+    const entries = await readdir13(path41.resolve(root, "src/_variants", internalId), { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => Number(entry.name)).filter((n) => Number.isInteger(n) && n > 0);
   } catch {
     return [];
@@ -51900,14 +52962,14 @@ function fail7(code, message, fix) {
 }
 async function isDir3(p) {
   try {
-    return (await stat8(p)).isDirectory();
+    return (await stat9(p)).isDirectory();
   } catch {
     return false;
   }
 }
 async function exists(p) {
   try {
-    await stat8(p);
+    await stat9(p);
     return true;
   } catch {
     return false;
@@ -51915,7 +52977,7 @@ async function exists(p) {
 }
 async function listLandingSlugs2(root) {
   try {
-    const entries = await readdir11(path39.resolve(root, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir13(path41.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 [];
@@ -51924,14 +52986,14 @@ async function listLandingSlugs2(root) {
 async function listComponents(componentsDir, prefix = "") {
   let entries;
   try {
-    entries = await readdir11(componentsDir, { withFileTypes: true });
+    entries = await readdir13(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(path39.join(componentsDir, entry.name), rel));
+    if (entry.isDirectory()) out.push(...await listComponents(path41.join(componentsDir, entry.name), rel));
     else if (entry.name.endsWith(".astro")) out.push(rel);
   }
   return out.sort();
@@ -51945,27 +53007,39 @@ function resolveForkName(requested, available) {
   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);
+function parseForks(fork, rawArgs) {
+  const names = repeatedValues(rawArgs, "fork", fork).flatMap((s) => s.split(",")).map((s) => s.trim()).filter((s) => s.length > 0);
   return [...new Set(names)];
 }
+function pageInTest(status, page) {
+  for (const test of status.experiments) {
+    if (test.landingSlug !== page) continue;
+    if (test.status !== "finished") {
+      return `${page} is already in a test (${test.experimentId}, against ${test.variantSlug}, ${test.status}). One page has one test at a time \u2014 read it with \`baker experiment status --landing ${page}\`, and end it with \`baker experiment finish\` before building the next version.`;
+    }
+    if (test.fold === "owed" || test.fold === "landing") {
+      return `The last test on ${page} was won by ${test.variantSlug}, and the page is still being updated to match \u2014 run \`baker experiment fold\` and publish before building the next version.`;
+    }
+  }
+  return null;
+}
 function buildVariantDefinition(controlDefinition, opts) {
-  let out = controlDefinition;
+  const frontmatter = controlDefinition.match(/^---\n[\s\S]*?\n---/)?.[0] ?? "---\n---";
+  let out = frontmatter;
   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}\``,
+    `# Version ${variantNumberOf(opts.variantSlug) ?? "?"} of \`${opts.controlSlug}\` \u2014 for an A/B test`,
     "",
-    `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.`,
+    `This is not a page. It is one version of \`${opts.controlSlug}\`, shown to half of that page's visitors while a test runs; the address bar keeps saying \`/${opts.controlSlug}/\` and this folder has no address of its own. Everything about the page \u2014 the campaign, the audience, the offer, the proof \u2014 is in \`src/pages/${opts.controlSlug}/_definition.md\`, and that is where it is edited. This file only says what is different here.`,
     "",
-    `**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.`,
+    `**Only this differs:** ${shared}. Every other section is imported from \`${opts.controlSlug}\`, on purpose \u2014 an edit to the page reaches both versions, so the test keeps measuring the one difference rather than a drift between two copies. Edit only the files under \`src/pages/${opts.variantSlug}/_components/\`.`,
     ...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\`.`,
+    `Run \`baker experiment start --landing ${opts.controlSlug} --variant ${opts.variantSlug} --because "\u2026" --change "\u2026"\` to begin, and read the result with \`baker experiment status\`. When the test ends, \`baker experiment fold\` moves the version that won into the page and removes this folder.`,
     ""
   ].join("\n");
   return `${out.trimEnd()}
@@ -51986,16 +53060,16 @@ async function resolveTargets(projectRoot, opts) {
       `"${controlSlug}" is already a variant of "${variantOfSlug(controlSlug)}". Make the next variant of the page itself: \`baker landing variant ${variantOfSlug(controlSlug)}\`.`
     );
   }
-  const controlDir = path39.resolve(projectRoot, "src", "pages", controlSlug);
+  const controlDir = path41.resolve(projectRoot, "src", "pages", controlSlug);
   if (!await isDir3(controlDir)) {
     fail7("NOT_FOUND", `No page at src/pages/${controlSlug}/`, {
       availableSlugs: await listLandingSlugs2(projectRoot)
     });
   }
-  if (!await exists(path39.join(controlDir, "index.astro"))) {
+  if (!await exists(path41.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 internalId = await readInternalId(path39.join(controlDir, "_definition.md"));
+  const internalId = await readInternalId(path41.join(controlDir, "_definition.md"));
   const variantSlugValue = variantSlug(
     controlSlug,
     nextVariantNumber(
@@ -52004,10 +53078,10 @@ async function resolveTargets(projectRoot, opts) {
       await archivedVariantNumbers(projectRoot, internalId)
     )
   );
-  const variantDir = path39.resolve(projectRoot, "src", "pages", variantSlugValue);
-  const available = await listComponents(path39.join(controlDir, "_components"));
+  const variantDir = path41.resolve(projectRoot, "src", "pages", variantSlugValue);
+  const available = await listComponents(path41.join(controlDir, "_components"));
   const forks = [];
-  for (const name of parseForks(opts.fork)) {
+  for (const name of parseForks(opts.fork, opts.rawArgs)) {
     const resolved = resolveForkName(name, available);
     if (resolved === null) {
       fail7("NOT_FOUND", `"${name}" is not a component of ${controlSlug}.`, {
@@ -52021,26 +53095,26 @@ async function resolveTargets(projectRoot, opts) {
 }
 async function writeVariant(opts) {
   const { controlDir, variantDir, controlSlug, variantSlug: variantSlug2, forks } = opts;
-  const forkedTargets = new Set(forks.map((f) => path39.join(controlDir, "_components", f)));
+  const forkedTargets = new Set(forks.map((f) => path41.join(controlDir, "_components", f)));
   const written = [];
-  const indexText = await readFile25(path39.join(controlDir, "index.astro"), "utf8");
+  const indexText = await readFile27(path41.join(controlDir, "index.astro"), "utf8");
   await mkdir13(variantDir, { recursive: true });
   await writeFile18(
-    path39.join(variantDir, "index.astro"),
+    path41.join(variantDir, "index.astro"),
     repointFile(indexText, { fromDir: controlDir, toDir: variantDir, controlDir, variantDir, forkedTargets }),
     "utf8"
   );
   written.push(`src/pages/${variantSlug2}/index.astro`);
   for (const fork of forks) {
-    const fromFile = path39.join(controlDir, "_components", fork);
-    const toFile = path39.join(variantDir, "_components", fork);
-    const text2 = await readFile25(fromFile, "utf8");
-    await mkdir13(path39.dirname(toFile), { recursive: true });
+    const fromFile = path41.join(controlDir, "_components", fork);
+    const toFile = path41.join(variantDir, "_components", fork);
+    const text2 = await readFile27(fromFile, "utf8");
+    await mkdir13(path41.dirname(toFile), { recursive: true });
     await writeFile18(
       toFile,
       repointFile(text2, {
-        fromDir: path39.dirname(fromFile),
-        toDir: path39.dirname(toFile),
+        fromDir: path41.dirname(fromFile),
+        toDir: path41.dirname(toFile),
         controlDir,
         variantDir,
         forkedTargets
@@ -52049,9 +53123,9 @@ async function writeVariant(opts) {
     );
     written.push(`src/pages/${variantSlug2}/_components/${fork}`);
   }
-  const controlDefinitionPath = path39.join(controlDir, "_definition.md");
+  const controlDefinitionPath = path41.join(controlDir, "_definition.md");
   if (await exists(controlDefinitionPath)) {
-    const definition = buildVariantDefinition(await readFile25(controlDefinitionPath, "utf8"), {
+    const definition = buildVariantDefinition(await readFile27(controlDefinitionPath, "utf8"), {
       internalId: randomUUID2().replace(/-/g, "").slice(0, 8),
       variantSlug: variantSlug2,
       controlSlug,
@@ -52059,11 +53133,11 @@ async function writeVariant(opts) {
       ...opts.because ? { because: opts.because } : {},
       ...opts.change ? { change: opts.change } : {}
     });
-    await writeFile18(path39.join(variantDir, "_definition.md"), definition, "utf8");
+    await writeFile18(path41.join(variantDir, "_definition.md"), definition, "utf8");
     written.push(`src/pages/${variantSlug2}/_definition.md`);
   }
-  await mkdir13(path39.join(variantDir, "_images"), { recursive: true });
-  await writeFile18(path39.join(variantDir, "_images", ".gitkeep"), "", "utf8");
+  await mkdir13(path41.join(variantDir, "_images"), { recursive: true });
+  await writeFile18(path41.join(variantDir, "_images", ".gitkeep"), "", "utf8");
   return written;
 }
 var variantCommand = defineCommand174({
@@ -52088,13 +53162,28 @@ var variantCommand = defineCommand174({
       description: "What is different about this version, in the client's words \u2014 \u201Cput the booking form in the hero\u201D."
     }
   },
-  async run({ args }) {
+  async run({ args, rawArgs }) {
     const projectRoot = process.cwd();
     const controlSlug = String(args.page);
     const { controlDir, variantDir, variantSlug: variantSlug2, available, forks } = await resolveTargets(projectRoot, {
       controlSlug,
-      fork: args.fork
+      fork: args.fork,
+      rawArgs
     });
+    let status;
+    try {
+      const response = await apiPost("/api/experiments/status", {
+        landingSlug: controlSlug
+      });
+      status = response.data;
+    } catch (error) {
+      fail7(
+        "UNAVAILABLE",
+        `Could not check whether ${controlSlug} is already in a test (${error instanceof Error ? error.message : String(error)}). Nothing was written \u2014 run \`baker experiment status --landing ${controlSlug}\` and try again.`
+      );
+    }
+    const taken = pageInTest(status, controlSlug);
+    if (taken) fail7("CONFLICT", taken, { landing: controlSlug });
     const written = await writeVariant({
       controlDir,
       variantDir,
@@ -54070,8 +55159,8 @@ var listCommand16 = defineCommand193({
 });
 
 // src/commands/scheduled-actions/templates.ts
-import { readFile as readFile26 } from "fs/promises";
-import path40 from "path";
+import { readFile as readFile28 } from "fs/promises";
+import path42 from "path";
 import { defineCommand as defineCommand194 } from "citty";
 registerSchema({
   command: "scheduled-actions.templates",
@@ -54174,7 +55263,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 readFile26(path40.resolve(briefFile), "utf8") : flag("brief");
+        const brief = briefFile.length > 0 ? await readFile28(path42.resolve(briefFile), "utf8") : flag("brief");
         if (brief.trim().length === 0) {
           failValidation4("--brief-file (preferred) or --brief is required: the brief is the recipe.");
         }
@@ -54295,7 +55384,7 @@ registerSchema({
     prompt: { type: "string", description: "Replacement additional spawned-agent instructions", required: false }
   }
 });
-var updateCommand3 = defineCommand196({
+var updateCommand4 = defineCommand196({
   meta: {
     name: "update",
     description: "Stage a scheduled action update. Examples: baker scheduled-actions update <id> --enabled false | baker scheduled-actions update <id> --mode publish"
@@ -54394,7 +55483,7 @@ Full guide: __tooling__/docs/tools/baker/scheduled-actions.md`
     list: listCommand16,
     get: getCommand4,
     create: createCommand3,
-    update: updateCommand3,
+    update: updateCommand4,
     delete: deleteCommand3,
     templates: templatesCommand,
     trigger: triggerCommand
@@ -54645,7 +55734,7 @@ function parseImageRefs(spec) {
 }
 var defaultDeps = {
   ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
-  upload: (path42) => uploadLocalImage({ file: path42, contentType: detectImageContentType(path42), source: "uploaded" })
+  upload: (path44) => uploadLocalImage({ file: path44, contentType: detectImageContentType(path44), source: "uploaded" })
 };
 async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   const refs = parseImageRefs(spec);
@@ -54665,10 +55754,10 @@ async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   }
   return { imageIds, added };
 }
-function uploadFailure(path42) {
+function uploadFailure(path44) {
   return (error) => {
     if (error instanceof ApiError) throw error;
-    throw new ApiError("VALIDATION_ERROR", `Could not read "${path42}" as an image.`);
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path44}" as an image.`);
   };
 }
 
@@ -55666,7 +56755,7 @@ import { defineCommand as defineCommand211 } from "citty";
 import { defineCommand as defineCommand208 } from "citty";
 
 // src/commands/tag-manager/shared.ts
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 function failValidation5(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
@@ -55682,7 +56771,7 @@ function requireTarget6(args, entity) {
 function loadJsonArg2(args, flag = "json") {
   const inline = args[flag];
   const file = args.file;
-  const raw = typeof file === "string" && file.length > 0 ? readFileSync17(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
+  const raw = typeof file === "string" && file.length > 0 ? readFileSync18(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
   if (raw === void 0) {
     failValidation5(`pass --${flag} with inline JSON or --file with a path to a JSON file`);
   }
@@ -55730,10 +56819,10 @@ async function stageOp4(op) {
     handleError5(err);
   }
 }
-async function draftAction3(path42, body, chat) {
+async function draftAction3(path44, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path42, { chatId, ...body });
+    const data = await apiPost(path44, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -56868,9 +57957,9 @@ var groupCommand2 = defineCommand219({
 });
 
 // src/commands/videos/ingest.ts
-import { mkdtemp as mkdtemp2, rm as rm8, stat as stat9 } from "fs/promises";
+import { mkdtemp as mkdtemp2, rm as rm8, stat as stat10 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import path41 from "path";
+import path43 from "path";
 import { defineCommand as defineCommand220 } from "citty";
 
 // src/lib/streamUpload.ts
@@ -57221,7 +58310,7 @@ function ingestUrl(args) {
 }
 async function downloadThenIngest(args, country) {
   const vimeoCookie = captureVimeoCookie();
-  const workDir = await mkdtemp2(path41.join(tmpdir3(), "videos-ingest-"));
+  const workDir = await mkdtemp2(path43.join(tmpdir3(), "videos-ingest-"));
   try {
     const probe = await probeYtDlp({ url: args.url, country, vimeoCookie, cookieDir: workDir });
     if (isAudioOnly(probe.info)) {
@@ -57252,7 +58341,7 @@ async function downloadThenIngest(args, country) {
       // we allow to fetch it cannot drift apart.
       timeoutMs: downloadTimeoutMs(durationSeconds(probe.info))
     });
-    const stats = await stat9(filePath);
+    const stats = await stat10(filePath);
     if (stats.size > MAX_VIDEO_INGEST_BYTES) {
       throw new ApiError(
         "VALIDATION_ERROR",
@@ -57357,7 +58446,7 @@ var searchCommand4 = defineCommand221({
 var tagsCommand6 = makeTagsCommand("videos", "video", "/api/videos/tags");
 
 // src/commands/videos/upload.ts
-import { readFile as readFile27, stat as stat10 } from "fs/promises";
+import { readFile as readFile29, stat as stat11 } from "fs/promises";
 import { basename as basename3, extname as extname4 } from "path";
 import { defineCommand as defineCommand222 } from "citty";
 var MIME_MAP = {
@@ -57441,7 +58530,7 @@ var uploadCommand2 = defineCommand222({
       const originalFilename = basename3(filePath);
       const descriptionContext = args.context;
       if (args["dry-run"]) {
-        const fileStats = await stat10(filePath);
+        const fileStats = await stat11(filePath);
         writeJson({
           ok: true,
           dryRun: true,
@@ -57454,7 +58543,7 @@ var uploadCommand2 = defineCommand222({
         originalFilename,
         descriptionContext
       });
-      const fileBuffer = await readFile27(filePath);
+      const fileBuffer = await readFile29(filePath);
       const uploadResponse = await fetch(uploadUrl, {
         method: "PUT",
         headers: { "Content-Type": contentType },
@@ -58841,7 +59930,7 @@ function unknownFlagEnvelope(unknown, commandPath, suggestion) {
   };
 }
 function commandPathOf(root, argv) {
-  const path42 = [];
+  const path44 = [];
   let command = root;
   for (const token of argv) {
     if (token === "--" || token.startsWith("-")) {
@@ -58852,10 +59941,10 @@ function commandPathOf(root, argv) {
     if (next === void 0 || typeof next !== "object") {
       break;
     }
-    path42.push(token);
+    path44.push(token);
     command = next;
   }
-  return path42.join(" ");
+  return path44.join(" ");
 }
 function refuseUnknownFlags(root, argv) {
   const unknown = findUnknownFlags(root, argv);
@@ -58873,7 +59962,7 @@ function refuseUnknownFlags(root, argv) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 function packageJsonUrl() {
   return new URL("../package.json", import.meta.url);
 }
@@ -58885,7 +59974,7 @@ function parsePackageVersion(raw) {
   throw new Error("Invalid CLI package.json: missing version");
 }
 function getCliVersion() {
-  return parsePackageVersion(readFileSync18(packageJsonUrl(), "utf8"));
+  return parsePackageVersion(readFileSync19(packageJsonUrl(), "utf8"));
 }
 
 // src/cli.ts
@@ -58924,7 +60013,7 @@ Introspection: Run 'baker schema <command>' to inspect argument schemas.`
     tags: tagsCommand4,
     "tag-manager": tagManagerCommand,
     chats: chatsCommand,
-    history: historyCommand,
+    history: historyCommand2,
     hubspot: hubspotCommand,
     "winning-ads": winningAdsCommand,
     mcp: mcpCommand,