@koda-sl/baker-cli 0.280.0 → 0.281.0

package/dist/cli.js

@@ -10482,14 +10482,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;
 }
@@ -12772,6 +12772,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 = {
@@ -12793,6 +12812,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;
@@ -20318,14 +20340,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;
 }
@@ -25348,14 +25370,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;
 }
@@ -27170,6 +27192,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";
 
@@ -27983,50 +28008,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 path38 = join2(flowsDir(), slug, "_data.json");
+  if (!existsSync3(path38)) {
+    failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
+  }
+  try {
+    return JSON.parse(readFileSync11(path38, "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
@@ -28064,6 +28364,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;
@@ -28946,26 +29403,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: {
@@ -28973,6 +29497,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",
@@ -28981,34 +29510,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));
@@ -31310,10 +31838,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, exists = existsSync3, maxDepth = 12) {
+function findWorkspaceRoot(startDir, exists = existsSync4, maxDepth = 12) {
   let dir = path5.resolve(startDir);
   for (let i = 0; i < maxDepth; i++) {
     if (exists(path5.join(dir, "package.json"))) return dir;
@@ -36958,7 +37486,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;
@@ -37011,7 +37539,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",
@@ -37032,7 +37560,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 });
   }
@@ -37056,9 +37584,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, exists = existsSync4, maxDepth = 8) {
+function resolveShippedCanvasDir(name, startDir, exists = existsSync5, maxDepth = 8) {
   const rel = path21.join("canvas", name);
   let dir = startDir;
   for (let i = 0; i < maxDepth; i++) {
@@ -38432,176 +38960,6 @@ import { defineCommand as defineCommand123 } from "citty";
 // src/commands/flows/add.ts
 import { randomUUID } from "crypto";
 import { defineCommand as defineCommand119 } 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 path38 = join3(flowsDir(), slug, "_data.json");
-  if (!existsSync5(path38)) {
-    failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
-  }
-  try {
-    return JSON.parse(readFileSync11(path38, "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,
@@ -38692,6 +39050,10 @@ var addNodeCommand = defineCommand119({
       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}" }.`
         ] : [],
@@ -38805,6 +39167,13 @@ var addSideEffectCommand = defineCommand119({
       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.`
         ] : [],
@@ -38818,11 +39187,11 @@ var addSideEffectCommand = defineCommand119({
 });
 
 // src/commands/flows/map.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { defineCommand as defineCommand120 } 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) {
@@ -38884,7 +39253,7 @@ function trackingFieldIds() {
   const path38 = join4(flowsDir(), "..", "tracking.ts");
   if (!existsSync6(path38)) return null;
   try {
-    const source = readFileSync12(path38, "utf-8");
+    const source = readFileSync13(path38, "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]);
@@ -39428,7 +39797,7 @@ function specsFromFile(parsed) {
 function readSpecFile(path38) {
   let raw;
   try {
-    raw = path38 === "-" ? readFileSync13(0, "utf-8") : readFileSync13(path38, "utf-8");
+    raw = path38 === "-" ? readFileSync14(0, "utf-8") : readFileSync14(path38, "utf-8");
   } catch (error) {
     refuse(
       `Could not read ${path38 === "-" ? "the mapping from stdin" : `"${path38}"`}: ${error instanceof Error ? error.message : String(error)}`
@@ -39969,9 +40338,15 @@ var listCommand13 = defineCommand123({
     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."
+      ]
     });
   }
 });
@@ -39999,7 +40374,15 @@ var showCommand4 = defineCommand123({
       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}\`.`
+      ]
     });
   }
 });
@@ -40164,7 +40547,7 @@ Examples:
 import { defineCommand as defineCommand125 } 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);
@@ -40180,7 +40563,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`);
   }
@@ -40531,7 +40914,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 defineCommand128 } from "citty";
 
@@ -40622,7 +41005,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");
@@ -41474,7 +41857,7 @@ Full guide: __tooling__/docs/tools/baker/ga4.md`
 import { defineCommand as defineCommand134 } 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 defineCommand131 } from "citty";
 
@@ -41622,7 +42005,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");
@@ -48289,7 +48672,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) {
@@ -48310,7 +48693,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();
@@ -48324,7 +48707,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);
     }
@@ -48775,7 +49158,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);
@@ -48793,17 +49176,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 {
     }
   }
@@ -54256,7 +54639,7 @@ import { defineCommand as defineCommand209 } from "citty";
 import { defineCommand as defineCommand206 } 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);
@@ -54272,7 +54655,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`);
   }
@@ -57463,7 +57846,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);
 }
@@ -57475,7 +57858,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