@koda-sl/baker-cli 0.313.0 → 0.315.0

package/README.md

@@ -1382,7 +1382,7 @@ baker funnel --steps '[...]'                          # the whole funnel, restat
 
 **Every write says what it dropped.** `--step` changes one step and leaves the rest as it stands; `--steps` replaces the whole funnel and `--preset` draws over it. Every write returns `removed[]` and a `REMOVED steps:` hint when a step went, so a restatement written from a stale read is caught in the same turn.
 
-**A step says what triggers it, and every trigger is PICKED from `--moments`.** `triggers` is a list and any one of them firing is enough. Three kinds: `{"kind":"event","eventKey":"submit:contact"}` for anything the company's Forms, pages or systems produced (`moments.events`, `moments.sources`), `{"kind":"landing","landingId":"<id>"}` for one landing being viewed (`moments.landings`), and `{"kind":"any_landing"}` for any landing — what the default first step listens for. Nothing has to be named first: the event is used by its own key, and the step shows it by its own words. `moments.events[].origin` tells a page's event (`site`) from one the client's own systems sent (`systems`); `moments.sources` lists the client's systems by the `page:<name>` key each raises, pickable before the first send arrives. A key typed from memory saves, publishes and counts nobody forever — the hint "has a trigger and nobody reached it while N people entered" is that mistake caught after the fact. A step written with `offlineConversions`, a `conversion` trigger or an `analytics` trigger is refused before any round trip, with the shape to use.
+**A step says what triggers it, and every trigger is PICKED from `--moments`.** `triggers` is a list and any one of them firing is enough. Three kinds: `{"kind":"event","eventKey":"submit:contact"}` for anything the company's Forms, pages or systems produced (`moments.events`, `moments.sources`), `{"kind":"landing","landingId":"<id>"}` for one landing being viewed (`moments.landings`), and `{"kind":"any_landing"}` for any landing — what the default first step listens for. Nothing has to be named first: the event is used by its own key, and the step shows it by its own words. `moments.events[].origin` tells a page's event (`site`) from one the client's own systems sent (`systems`); `moments.sources` lists the client's systems by the `page:<name>` key each raises, pickable before the first send arrives. **A Form's own endings need nothing set up first** — no Source, no conversion: a Baker page raises them natively, so every Form in the workspace lists its endings in `moments.events` — each step's completion and its `submit:` — with the `step` each happens on, at zero and `seen: false` until somebody fires one, and `countedAs` when the company already counts it. **Baker never picks which ending is the Form's outcome; the agent does**, from the step names, asking the person when they do not make it obvious — and uses the same key the Form is counted on, when it is counted. `baker funnel` also hints, in one line, every workspace Form that reaches no step. Place one with **`baker funnel --add-trigger <step-key> --event <key>`**, which adds a single way in and leaves the step's name, stage, `after[]` and other triggers untouched — `--step` takes a whole step and silently drops any trigger a restatement forgets. That is what makes a Form built minutes ago pickable. A key typed from memory saves, publishes and counts nobody forever — the hint "has a trigger and nobody reached it while N people entered" is that mistake caught after the fact. A step written with `offlineConversions`, a `conversion` trigger or an `analytics` trigger is refused before any round trip, with the shape to use.
 
 **A landing being viewed can be a step** — where most funnels start — and never a conversion: `baker analytics conversions` refuses a `view:` key.
 

package/dist/cli.js

@@ -10756,14 +10756,14 @@ function collectionLine(collection) {
 }
 function accountsInTree(nodes) {
   const accounts = /* @__PURE__ */ new Set();
-  const walk2 = (node) => {
+  const walk = (node) => {
     accounts.add(node.customerId);
     for (const child of node.children) {
-      walk2(child);
+      walk(child);
     }
   };
   for (const node of nodes) {
-    walk2(node);
+    walk(node);
   }
   return accounts;
 }
@@ -21390,14 +21390,14 @@ function collectionLine2(collection) {
 }
 function accountsInTree2(nodes) {
   const accounts = /* @__PURE__ */ new Set();
-  const walk2 = (node) => {
+  const walk = (node) => {
     accounts.add(node.accountId);
     for (const child of node.children) {
-      walk2(child);
+      walk(child);
     }
   };
   for (const node of nodes) {
-    walk2(node);
+    walk(node);
   }
   return accounts;
 }
@@ -27002,14 +27002,14 @@ function collectionLine3(collection) {
 }
 function accountsInTree3(nodes) {
   const accounts = /* @__PURE__ */ new Set();
-  const walk2 = (node) => {
+  const walk = (node) => {
     accounts.add(node.accountId);
     for (const child of node.children) {
-      walk2(child);
+      walk(child);
     }
   };
   for (const node of nodes) {
-    walk2(node);
+    walk(node);
   }
   return accounts;
 }
@@ -28827,6 +28827,51 @@ 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/analytics/flowEventKeys.ts
+function flowNodes(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) flowNodes(child, acc);
+  return acc;
+}
+function flowEventKeys(tree, slug) {
+  const primary = [];
+  const secondary = [];
+  const nodes = flowNodes(tree).filter((node) => typeof node.id === "string" && node.id !== "");
+  if (nodes.length === 0) return [];
+  for (const node of nodes) {
+    const id = node.id;
+    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
+    }
+  ];
+}
+
 // ../api/src/event-ingest/arrivals.ts
 import { z as z33 } from "zod";
 
@@ -30006,56 +30051,14 @@ function mergeStoredWithCounts(stored, reported) {
 }
 
 // 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);
+  const node = flowNodes(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.`
+      fix: `Steps in this Form: ${flowNodes(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);
@@ -30086,19 +30089,14 @@ function flowConversionHints(slug, rows, noConversionReason) {
       `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.`
-    ] : [],
+    `Nothing on "${slug}" is counted, so it converts nobody on every report however many people finish it. Which ending is its outcome is your call, never Baker's: read the endings above by the step each happens on (\`nodeName\`), and when the step names do not make it obvious \u2014 a Form that branches into a rejection and a confirmation \u2014 ask the person which one means a real result. Then \`baker analytics conversions --event "<key>" --name "<what a person calls it>"\`. If this Form is already on a funnel step, count the key that step uses, so the two numbers agree.`,
     `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 rows = joinFlowConversions(flowEventKeys(tree, slug), definitions);
     const declared = tree?.noConversion?.reason;
     const seen = /* @__PURE__ */ new Set();
     return {
@@ -31170,7 +31168,7 @@ var args2 = {
   },
   contacts: {
     type: "string",
-    description: "With --object deal (on --create-hubspot or --set-trigger): whose event it is \u2014 `first` (the deal's first contact, the default) or `every` (every contact on the deal, each its own event, each worth the deal's amount)",
+    description: "With --object deal (on --create-hubspot or --set-trigger): whose event it is \u2014 `every` (the default: every contact on the deal, each its own event, each worth the deal's amount) or `first` (the deal's first contact only)",
     required: false
   },
   property: {
@@ -32116,7 +32114,7 @@ function readFlowConversions2(slug, definitions) {
   return {
     slug,
     noConversionReason: reason,
-    endings: joinFlowConversions(flowConversionCandidates(tree, slug), definitions)
+    endings: joinFlowConversions(flowEventKeys(tree, slug), definitions)
   };
 }
 function conversionsEnvelope(args4, definitions, candidates) {
@@ -47233,8 +47231,65 @@ Full guide: __tooling__/docs/tools/baker/flows.md`
 });
 
 // src/commands/funnel/index.ts
+import { readFileSync as readFileSync15 } from "fs";
 import { defineCommand as defineCommand129 } from "citty";
 
+// src/commands/funnel/formMoments.ts
+function offeredEndings(form) {
+  return flowEventKeys(form.tree, form.slug).filter((ending) => ending.isCompletion || ending.nodeId === null);
+}
+function formMoments(events, forms, counted) {
+  const endings = /* @__PURE__ */ new Map();
+  for (const form of forms) {
+    for (const ending of offeredEndings(form)) endings.set(ending.eventKey, { slug: form.slug, ending });
+  }
+  const known = events.map((event) => {
+    const found = endings.get(event.eventKey);
+    if (found === void 0) return event;
+    endings.delete(event.eventKey);
+    return { ...event, step: found.ending.nodeName };
+  });
+  const unfired = [...endings.values()].map(({ slug, ending }) => {
+    const countedAs = counted.get(ending.eventKey);
+    return {
+      eventKey: ending.eventKey,
+      origin: "site",
+      flowSlug: slug,
+      ...ending.nodeType === null ? {} : { nodeType: ending.nodeType },
+      events: 0,
+      sessions: 0,
+      step: ending.nodeName,
+      seen: false,
+      ...countedAs === void 0 ? {} : { countedAs }
+    };
+  });
+  return [...known, ...unfired];
+}
+function withFormMoments(moments, forms, counted) {
+  return { ...moments, events: formMoments(moments.events, forms, counted) };
+}
+function formsNamedHere(forms) {
+  return forms.filter((form) => flowEventKeys(form.tree, form.slug).length > 0).map((form) => form.slug);
+}
+function unplacedFormHints(steps, forms, counted) {
+  const onAStep = new Set(
+    steps.flatMap((step) => (step.triggers ?? []).flatMap((trigger) => trigger.eventKey ? [trigger.eventKey] : []))
+  );
+  const unplaced = [];
+  for (const form of forms) {
+    const endings = flowEventKeys(form.tree, form.slug);
+    if (endings.length === 0 || endings.some((ending) => onAStep.has(ending.eventKey))) continue;
+    const countedOn = endings.filter((ending) => counted.has(ending.eventKey));
+    unplaced.push(
+      countedOn.length === 0 ? form.slug : `${form.slug} (counted as ${countedOn.map((ending) => `"${counted.get(ending.eventKey)}" on \`${ending.eventKey}\``).join(", ")})`
+    );
+  }
+  if (unplaced.length === 0) return [];
+  return [
+    `${unplaced.length} Form(s) in this workspace reach no funnel step, so they move nobody along it however many people finish them: ${unplaced.join("; ")}. Which ending moves somebody to which step is your call: \`baker funnel --moments\` lists every Form's endings by the step each happens on, and when the step names do not make it obvious \u2014 a Form that branches into a rejection and a confirmation \u2014 ask the person which one means a lead or a customer. Place it with \`baker funnel --add-trigger <step> --event <key>\`. A Form already counted as a page conversion goes on the funnel by THAT SAME key, or the two numbers disagree for ever.`
+  ];
+}
+
 // ../api/src/funnel/vocabulary.ts
 var FUNNEL_STEP_CLASSES = [
   /** Saw the offer: a landing opened, an ad clicked through. */
@@ -47527,6 +47582,18 @@ var funnelRequestSchema = z44.object({
   step: funnelStepSchema.optional(),
   /** One step taken out by key; whatever came after it moves up to whatever came before it. */
   removeStep: z44.string().min(1).max(64).optional(),
+  /**
+   * ONE way in added to a step, leaving the rest of that step alone.
+   *
+   * `step` takes a whole step, so adding a way in through it means restating
+   * the step's name, stage, `after[]` and every trigger it already had — and a
+   * trigger left out of that restatement is silently removed. This is the door
+   * for the thing that is actually being asked ("this Form's booking should
+   * count here"), and it cannot drop anything.
+   */
+  addTrigger: z44.object({ stepKey: z44.string().min(1).max(64), eventKey: z44.string().min(1).max(320) }).optional(),
+  /** ONE way in taken off a step, by the event key it listens for. */
+  removeTrigger: z44.object({ stepKey: z44.string().min(1).max(64), eventKey: z44.string().min(1).max(320) }).optional(),
   /** One of the ready-made graphs, instead of stating steps. */
   preset: z44.enum(FUNNEL_VERTICALS).optional(),
   /** Also return the suggestion library and the presets. */
@@ -47538,7 +47605,14 @@ var funnelRequestSchema = z44.object({
    */
   moments: z44.boolean().optional(),
   /** How many days the counts beside each step cover. Default 30. */
-  days: z44.number().int().min(1).max(400).optional()
+  days: z44.number().int().min(1).max(400).optional(),
+  /**
+   * The Forms, by slug, the caller names itself when no step counts them —
+   * `baker funnel` reads its own workspace and names each with the key that
+   * places it. The backend leaves them out of its own hint, so no Form is
+   * named twice.
+   */
+  namedByCaller: z44.array(z44.string().min(1).max(200)).max(1e3).optional()
 });
 var funnelResponseSchema = z44.object({
   ok: z44.literal(true),
@@ -47591,6 +47665,13 @@ var funnelResponseSchema = z44.object({
      * one", given in the same turn.
      */
     removed: z44.array(z44.string()).optional(),
+    /**
+     * What this company counts as page conversions, this chat's staged counts
+     * included, by event key and name. Here so a Form's ending can say it is
+     * already counted — the agent choosing a step's way in should use that
+     * same key — and outside `moments` because the plain read's hints say it too.
+     */
+    counted: z44.array(z44.object({ eventKey: z44.string(), name: z44.string() })).optional(),
     /** Everything a trigger can name, when asked for with `moments`. */
     moments: z44.object({
       events: z44.array(
@@ -47604,7 +47685,20 @@ var funnelResponseSchema = z44.object({
           events: z44.number(),
           sessions: z44.number(),
           /** The name it is counted under as a page conversion, when the company counts it. Informational. */
-          countedAs: z44.string().optional()
+          countedAs: z44.string().optional(),
+          /**
+           * The step of the Form this happens on, in the Form's own words —
+           * never a node id. Present on a Form's ending read from the Form
+           * itself, which is the only place the name is known.
+           */
+          step: z44.string().optional(),
+          /**
+           * `false` on an ending a Form raises natively but nobody has fired
+           * yet — derived from the Form, offered at zero, exactly as a
+           * Source is offered before its first send. Absent means it came
+           * from the event store and therefore happened.
+           */
+          seen: z44.boolean().optional()
         })
       ),
       /** The company's sources: a system of theirs that posts events to Baker, by the event name it raises. */
@@ -47660,9 +47754,15 @@ function parseFunnelArgs(raw) {
   const step = parseStep(raw.step);
   const removeStep = parseRemoveStep(raw["remove-step"] ?? raw.removeStep);
   const preset = parsePreset(raw.preset);
-  const doors = [steps, step, removeStep, preset].filter((door) => door !== void 0).length;
+  const addTrigger = parseWayIn(raw["add-trigger"] ?? raw.addTrigger, raw.event, "--add-trigger");
+  const removeTrigger = parseWayIn(raw["remove-trigger"] ?? raw.removeTrigger, raw.event, "--remove-trigger");
+  const doors = [steps, step, removeStep, preset, addTrigger, removeTrigger].filter(
+    (door) => door !== void 0
+  ).length;
   if (doors > 1) {
-    throw new FunnelArgsError("Give one of --steps, --step, --remove-step or --preset, not two.");
+    throw new FunnelArgsError(
+      "Give one of --steps, --step, --remove-step, --preset, --add-trigger or --remove-trigger, not two."
+    );
   }
   const days = raw.days === void 0 ? void 0 : Number(raw.days);
   if (days !== void 0 && (!Number.isInteger(days) || days <= 0 || days > 400)) {
@@ -47673,6 +47773,8 @@ function parseFunnelArgs(raw) {
     ...step === void 0 ? {} : { step },
     ...removeStep === void 0 ? {} : { removeStep },
     ...preset === void 0 ? {} : { preset },
+    ...addTrigger === void 0 ? {} : { addTrigger },
+    ...removeTrigger === void 0 ? {} : { removeTrigger },
     templates: raw.templates === true,
     moments: raw.moments === true,
     ...days === void 0 ? {} : { days }
@@ -47684,6 +47786,8 @@ function funnelWrite(args4) {
     ...args4.step === void 0 ? {} : { step: args4.step },
     ...args4.removeStep === void 0 ? {} : { removeStep: args4.removeStep },
     ...args4.preset === void 0 ? {} : { preset: args4.preset },
+    ...args4.addTrigger === void 0 ? {} : { addTrigger: args4.addTrigger },
+    ...args4.removeTrigger === void 0 ? {} : { removeTrigger: args4.removeTrigger },
     ...args4.templates ? { templates: true } : {},
     ...args4.moments ? { moments: true } : {},
     ...args4.days === void 0 ? {} : { days: args4.days }
@@ -47793,6 +47897,26 @@ function parsePreset(raw) {
   }
   return raw;
 }
+function parseWayIn(stepKey, eventKey, flag) {
+  if (stepKey === void 0) return void 0;
+  if (typeof stepKey !== "string" || stepKey.trim() === "") {
+    throw new FunnelArgsError(`${flag} takes the key of the step to change: \`${flag} lead\`.`);
+  }
+  if (typeof eventKey !== "string" || eventKey.trim() === "") {
+    throw new FunnelArgsError(`${flag} needs --event, naming what gets somebody there.`, {
+      action: "read_the_moments",
+      explanation: `Run \`baker funnel --moments\` and copy an \`events[].eventKey\` \u2014 a Form's own outcome is listed there at zero before anybody has filled it in. Then: \`${flag} ${stepKey.trim()} --event "<key>"\`.`
+    });
+  }
+  const key = eventKey.trim();
+  if (flag === "--add-trigger" && parseEventKey(key) === null) {
+    throw new FunnelArgsError(`"${key}" is not an event key, so nothing would ever reach that step through it.`, {
+      action: "read_the_moments",
+      explanation: "Run `baker funnel --moments` and copy an `events[].eventKey`. They look like form:<form>:<step>:<trigger>, submit:<form>, page:<name> or view:<landing>."
+    });
+  }
+  return { stepKey: stepKey.trim(), eventKey: key };
+}
 
 // src/commands/funnel/index.ts
 var args3 = {
@@ -47806,6 +47930,21 @@ var args3 = {
     description: 'ONE step as a JSON object, in the same shape as an entry of --steps. It is added to the funnel as it now stands, or replaces the step with the same `key`, and every other step is left exactly as it is \u2014 the door for adding or changing a stage without restating the rest. Example: --step \'{"key":"demo","displayName":"Demo held","stepClass":"engaged","after":["lead"],"triggers":[{"id":"t1","kind":"event","eventKey":"page:demo_held"}]}\'',
     required: false
   },
+  "add-trigger": {
+    type: "string",
+    description: 'The key of ONE step to add a way in to, with `--event` naming what gets somebody there: `--add-trigger lead --event "submit:contact"`. Start here for "this Form should count as a lead" \u2014 it adds that one way in and leaves the step\'s name, stage, `after[]` and every other trigger exactly as they are. Prefer it to `--step`, which takes a WHOLE step and therefore silently removes any trigger the restatement forgets. Adding a key the step already listens for changes nothing. Take the key from `--moments`, never from memory',
+    required: false
+  },
+  "remove-trigger": {
+    type: "string",
+    description: 'The key of ONE step to take a way in OFF, with `--event` naming which: `--remove-trigger lead --event "submit:contact"`. By event key rather than by trigger id, because the id is not something you ever saw. Everything else about the step is untouched',
+    required: false
+  },
+  event: {
+    type: "string",
+    description: "The event key `--add-trigger` or `--remove-trigger` acts on \u2014 an `events[].eventKey` from `--moments`, never invented. Every Form's endings are listed there by the step each happens on, at zero before anybody has filled the Form in; which one means the step is your decision",
+    required: false
+  },
   "remove-step": {
     type: "string",
     description: "The key of one step to take off the funnel. Whatever came after it moves up to whatever came before it, so the chain stays joined. The response lists it under `removed`",
@@ -47818,7 +47957,7 @@ var args3 = {
   },
   moments: {
     type: "boolean",
-    description: "Also return everything a trigger can name, so a trigger is PICKED rather than invented: `events` (every event this company's Forms, pages and systems actually produced in the window, with volume, the Form it belongs to, `origin` \u2014 `site` for a page or Form, `systems` for the client's own server, `both` \u2014 and `countedAs` when the company also counts it as a page conversion, which a trigger does not need), `sources` (the client's own systems that post events to Baker, by the `page:<name>` key each raises, pickable before its first send arrives) and `landings` (its pages, by the id a `landing` trigger takes). Use this before writing any `triggers`: a key typed from memory saves, publishes and counts nobody forever",
+    description: "Also return everything a trigger can name, so a trigger is PICKED rather than invented: `events` (every event this company's Forms, pages and systems produced in the window, with volume, the Form it belongs to, `origin` \u2014 `site` for a page or Form, `systems` for the client's own server, `both` \u2014 and `countedAs` when the company also counts it as a page conversion, which a trigger does not need; PLUS **every workspace Form's endings** \u2014 each step's completion and its `submit:` \u2014 with the `step` each happens on, at zero and `seen: false` until somebody fires one, so a Form built minutes ago is pickable with nothing set up first, and `countedAs` when the company already counts it. Nothing is marked as the outcome: which ending means a step is YOUR decision \u2014 read the step names, and ask the person when they do not make it obvious (a Form that branches into \u201CNot a fit\u201D and \u201CQuote confirmed\u201D). If the Form is already counted, use that same key, so the step and the conversion agree. `baker analytics conversions --flow <slug>` also lists a widget's housekeeping), `sources` (the client's own systems that post events to Baker, by the `page:<name>` key each raises, pickable before its first send arrives) and `landings` (its pages, by the id a `landing` trigger takes). Use this before writing any `triggers`: a key typed from memory saves, publishes and counts nobody forever. A Form's events need NOTHING set up first \u2014 no Source, no conversion: a Baker page raises them by itself",
     required: false
   },
   days: {
@@ -47840,17 +47979,26 @@ registerSchema({
 var funnelCommand2 = defineCommand129({
   meta: {
     name: "funnel",
-    description: 'Start here: run with no flags to see the funnel this company has, with the last 30 days of PEOPLE counted beside every step \u2014 `people` reached it, `atLeast` got at least that far, `before` got as far as the step before, `share` is the ratio, and `worstStep` names where the most people are lost. Every company has one from the day it exists: Visited (any landing) \u2192 Became a lead \u2192 Became a customer, the last two with no way in until somebody gives them one. Then `--moments` for everything a trigger can name (every event the company\'s Forms, pages and systems actually produced, its sources, its landings), and `--step \'<json>\'` to add or change ONE step in the client\'s own words \u2014 it replaces the step with that key, so restate its `after` and the triggers it keeps. A step is reached by three kinds of thing and nothing else: an event by its own key (`{"id":"t1","kind":"event","eventKey":"<from moments.events or moments.sources>"}`), one landing being viewed (`{"id":"t2","kind":"landing","landingId":"<from moments.landings>"}`) or any landing (`{"id":"t3","kind":"any_landing"}`). Nothing has to be named first. Pick every trigger from `--moments`, never from memory. A step with no `triggers` advances NOBODY and reports zero forever without warning \u2014 that is what the hints keep pointing at. There is no default door: a Form is only counted where a trigger names it. Keep it true: a chat that adds a Form, a Source or an event that moves people forward places it on its step in the same chat. Each step comes back with `sends[]`, read-only: where the people who reach it are sent and what happened, read off the system events behind its ways in. A send is set on the event with `baker analytics sends`, never on a step, and once published it spends ad budget \u2014 a failed one is named in the hints. Everything here is STAGED: it becomes the company\'s funnel in one piece when the chat is published \u2014 the client sees it on the canvas in this chat and can edit it there too \u2014 and the previous version stays on file so what was already measured under it is not lost.'
+    description: 'Start here: run with no flags to see the funnel this company has, with the last 30 days of PEOPLE counted beside every step \u2014 `people` reached it, `atLeast` got at least that far, `before` got as far as the step before, `share` is the ratio, and `worstStep` names where the most people are lost. Every company has one from the day it exists: Visited (any landing) \u2192 Became a lead \u2192 Became a customer, the last two with no way in until somebody gives them one. Then `--moments` for everything a trigger can name (every event the company\'s Forms, pages and systems produced, its sources, its landings, plus each Form\'s own outcome at zero). **To make an event count on a step \u2014 the usual job \u2014 use `--add-trigger <step> --event <key>`:** it adds that one way in and touches nothing else about the step. `--step \'<json>\'` is for adding or renaming a STEP; it replaces the step with that key, so it means restating its `after` and every trigger it keeps, and one left out is gone. A step is reached by three kinds of thing and nothing else: an event by its own key (`{"id":"t1","kind":"event","eventKey":"<from moments.events or moments.sources>"}`), one landing being viewed (`{"id":"t2","kind":"landing","landingId":"<from moments.landings>"}`) or any landing (`{"id":"t3","kind":"any_landing"}`). Nothing has to be named first. Pick every trigger from `--moments`, never from memory. A step with no `triggers` advances NOBODY and reports zero forever without warning \u2014 that is what the hints keep pointing at. There is no default door: a Form is only counted where a trigger names it. Keep it true: a chat that adds a Form, a Source or an event that moves people forward places it on its step in the same chat. Each step comes back with `sends[]`, read-only: where the people who reach it are sent and what happened, read off the system events behind its ways in. A send is set on the event with `baker analytics sends`, never on a step, and once published it spends ad budget \u2014 a failed one is named in the hints. Everything here is STAGED: it becomes the company\'s funnel in one piece when the chat is published \u2014 the client sees it on the canvas in this chat and can edit it there too \u2014 and the previous version stays on file so what was already measured under it is not lost.'
   },
   args: args3,
   run: async ({ args: raw }) => {
     try {
       const parsed = parseFunnelArgs(raw);
-      const response = await apiPost("/api/funnel", funnelWrite(parsed));
+      const forms = workspaceForms();
+      const namedByCaller = formsNamedHere(forms);
+      const request = {
+        ...funnelWrite(parsed),
+        ...namedByCaller.length === 0 ? {} : { namedByCaller }
+      };
+      const response = await apiPost("/api/funnel", request);
+      const counted = new Map((response.data.counted ?? []).map((row) => [row.eventKey, row.name]));
+      const data = response.data.moments === void 0 ? response.data : { ...response.data, moments: withFormMoments(response.data.moments, forms, counted) };
+      const hints2 = [...response.hints ?? [], ...unplacedFormHints(response.data.steps ?? [], forms, counted)];
       writeJsonEnvelope({
         ok: true,
-        data: response.data,
-        ...response.hints && response.hints.length > 0 ? { hints: response.hints } : {}
+        data,
+        ...hints2.length > 0 ? { hints: hints2 } : {}
       });
     } catch (err) {
       handleError4(err);
@@ -47875,6 +48023,16 @@ function handleError4(err) {
   });
   process.exit(1);
 }
+function workspaceForms() {
+  const forms = [];
+  for (const slug of listFlowSlugs()) {
+    try {
+      forms.push({ slug, tree: JSON.parse(readFileSync15(flowDataPath(slug), "utf-8")) });
+    } catch {
+    }
+  }
+  return forms;
+}
 
 // src/commands/ga4/index.ts
 import { defineCommand as defineCommand136 } from "citty";
@@ -48004,7 +48162,7 @@ Examples:
 import { defineCommand as defineCommand131 } from "citty";
 
 // src/commands/ga4/shared.ts
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 function failValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
@@ -48020,7 +48178,7 @@ function requireTarget5(args4, entity) {
 function readJsonSource(args4, flag) {
   const inline = args4[flag];
   const file = args4.file;
-  const raw = typeof file === "string" && file.length > 0 ? readFileSync15(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
+  const raw = typeof file === "string" && file.length > 0 ? readFileSync16(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`);
   }
@@ -48371,7 +48529,7 @@ Examples:
 });
 
 // src/commands/ga4/query.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync16, writeFileSync as writeFileSync4 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync17, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve2 } from "path";
 import { defineCommand as defineCommand134 } from "citty";
 
@@ -48462,7 +48620,7 @@ function writeRowsToFile2(filePath, rows, append) {
       writeFileSync4(filePath, content, "utf-8");
     }
   } else if (append && existsSync7(filePath)) {
-    const existing = JSON.parse(readFileSync16(filePath, "utf-8"));
+    const existing = JSON.parse(readFileSync17(filePath, "utf-8"));
     writeFileSync4(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync4(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -49314,7 +49472,7 @@ Full guide: __tooling__/docs/tools/baker/ga4.md`
 import { defineCommand as defineCommand140 } from "citty";
 
 // src/commands/gsc/query.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync8, readFileSync as readFileSync18, writeFileSync as writeFileSync5 } from "fs";
 import { resolve as resolve3 } from "path";
 import { defineCommand as defineCommand137 } from "citty";
 
@@ -49462,7 +49620,7 @@ function writeRowsToFile3(filePath, rows, append) {
       writeFileSync5(filePath, content, "utf-8");
     }
   } else if (append && existsSync8(filePath)) {
-    const existing = JSON.parse(readFileSync17(filePath, "utf-8"));
+    const existing = JSON.parse(readFileSync18(filePath, "utf-8"));
     writeFileSync5(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync5(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -56340,7 +56498,7 @@ var inPageCollectUsedCss = (selector) => {
     }
     return false;
   };
-  const walk2 = (rules, sink) => {
+  const walk = (rules, sink) => {
     for (const rule of Array.from(rules)) {
       totalRules++;
       if (rule instanceof CSSStyleRule) {
@@ -56361,7 +56519,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 = [];
-        walk2(rule.cssRules, inner);
+        walk(rule.cssRules, inner);
         if (inner.length === 0) continue;
         const condition = rule.conditionText ?? "";
         const prelude = rule instanceof CSSMediaRule ? `@media ${condition}` : rule.cssText.split("{")[0]?.trim();
@@ -56375,7 +56533,7 @@ ${inner.join("\n")}
     const owner = sheet.ownerNode;
     if (owner?.hasAttribute?.("data-baker-freeze")) continue;
     try {
-      walk2(sheet.cssRules, kept);
+      walk(sheet.cssRules, kept);
     } catch {
       if (sheet.href) unreadableHrefs.push(sheet.href);
     }
@@ -56826,7 +56984,7 @@ var inPageCollectMotion = (selector) => {
     else if (infinite) loop.push(effect);
     else entrance.push(effect);
   };
-  const walk2 = (rules, insideScrollTimeline) => {
+  const walk = (rules, insideScrollTimeline) => {
     for (const rule of Array.from(rules)) {
       if (rule instanceof CSSKeyframesRule) {
         keyframesByName.set(rule.name, rule.cssText);
@@ -56844,17 +57002,17 @@ var inPageCollectMotion = (selector) => {
           respectsReducedMotion = true;
           continue;
         }
-        walk2(rule.cssRules, insideScrollTimeline);
+        walk(rule.cssRules, insideScrollTimeline);
         continue;
       }
       const grouping = rule;
-      if (grouping.cssRules) walk2(grouping.cssRules, insideScrollTimeline);
+      if (grouping.cssRules) walk(grouping.cssRules, insideScrollTimeline);
     }
   };
   for (const sheet of Array.from(document.styleSheets)) {
     if (sheet.ownerNode?.hasAttribute?.("data-baker-freeze")) continue;
     try {
-      walk2(sheet.cssRules, false);
+      walk(sheet.cssRules, false);
     } catch {
     }
   }
@@ -62693,7 +62851,7 @@ import { defineCommand as defineCommand217 } from "citty";
 import { defineCommand as defineCommand214 } from "citty";
 
 // src/commands/tag-manager/shared.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 function failValidation5(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
@@ -62709,7 +62867,7 @@ function requireTarget6(args4, entity) {
 function loadJsonArg2(args4, flag = "json") {
   const inline = args4[flag];
   const file = args4.file;
-  const raw = typeof file === "string" && file.length > 0 ? readFileSync18(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
+  const raw = typeof file === "string" && file.length > 0 ? readFileSync19(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`);
   }
@@ -65988,7 +66146,7 @@ function refuseUnknownFlags(root, argv) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync19 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 function packageJsonUrl() {
   return new URL("../package.json", import.meta.url);
 }
@@ -66000,7 +66158,7 @@ function parsePackageVersion(raw) {
   throw new Error("Invalid CLI package.json: missing version");
 }
 function getCliVersion() {
-  return parsePackageVersion(readFileSync19(packageJsonUrl(), "utf8"));
+  return parsePackageVersion(readFileSync20(packageJsonUrl(), "utf8"));
 }
 
 // src/cli.ts