@koda-sl/baker-cli 0.313.0-dev.ca75dc08a → 0.314.0-dev.e1de11139

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 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 has its **outcome** marked in `moments.events` with `outcome: true` and the `step` it happens on — a Form nobody has filled in yet gets that row at zero, `seen: false`. It is the same ending `baker analytics conversions` recommends counting, so a step and a conversion land on the same event; `baker analytics conversions --flow <slug>` lists all of one Form's endings when a step wants another. `baker funnel` also hints, in one line, every workspace Form that reaches no step, with its outcome key. 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 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.
 
@@ -2215,6 +2215,8 @@ Each external source is its own subcommand. Pick the verb that matches the sourc
 | `baker images download <targets>` | Remote URLs and/or library ids → local files, so the local transforms can read them | n/a (writes to disk, no upload) |
 | `baker images tags` | List available image tag names (defaults + company custom tags) | n/a |
 
+**Every image record carries `width` and `height`, without `--full`.** They are there to be passed straight to the component that places the image: a remote image rendered with no declared size makes the site build download the file purely to measure it, which is the only reason building a site needs the network at all — and a dropped connection there fails the entire quality-check run for a reason nothing on the page caused.
+
 **Auto-ingest** runs the full `processImage` pipeline (Gemini describe + Voyage multimodal embed + OpenRouter text embed) on every hit. Override with `--auto-ingest N` (turn on) or `--no-auto-ingest` (turn off where default is on). When auto-ingest succeeds, the matching returned hit uses the Baker-owned URL and keeps the original provider URL as `sourceUrl`. After auto-ingest the next `baker images library` query for the same concept hits the local row.
 
 **Provider context biases the description.** When a hit carries human-readable text (Giphy `alt_text` / `title`, Pexels `alt`, Pixabay `tags`, Brandfetch type+theme, etc.) it's surfaced on the hit as `descriptionContext` and forwarded to Gemini during auto-ingest as a hint — Gemini still trusts the pixels (e.g. it'll correct a wrong botanical name) but uses the hint for cultural/brand/scene awareness it can't infer from bytes alone.

package/dist/cli.js

@@ -222,6 +222,15 @@ function compactImage(image) {
     imageUrl: String(image.imageUrl ?? ""),
     description: String(image.description ?? ""),
     tags: Array.isArray(image.tags) ? image.tags : [],
+    // Two numbers that are not about choosing the image but about placing it.
+    // A remote <BakerImage> with no width/height makes Astro DOWNLOAD the file
+    // at build time just to measure it — one request per image per build, on a
+    // build that is otherwise offline, and a single dropped connection there
+    // fails a client's whole verify. They are cheap enough to always carry, and
+    // burying them behind --full meant the agent placing the image never had
+    // them.
+    width: typeof image.width === "number" ? image.width : null,
+    height: typeof image.height === "number" ? image.height : null,
     // The facts that decide a pick, so choosing does not need a second call:
     // whose brand it is, who is in it, and what text is burned in.
     subject: typeof analysis.subject === "string" ? analysis.subject : null,
@@ -235,8 +244,6 @@ function fullImage(image) {
   const compact3 = compactImage(image);
   return {
     ...compact3,
-    width: image.width ?? null,
-    height: image.height ?? null,
     aspectRatio: formatAspectRatio(image.aspectRatio),
     dominantColor: image.dominantColor ?? null,
     imagePalette: Array.isArray(image.imagePalette) ? image.imagePalette : [],
@@ -28864,10 +28871,6 @@ function flowEventKeys(tree, slug) {
     }
   ];
 }
-function suggestedEnding(endings) {
-  const deepestFirst = [...endings].reverse();
-  return deepestFirst.find((row) => row.isCompletion && row.nodeType !== "text") ?? deepestFirst.find((row) => row.isCompletion) ?? endings[endings.length - 1] ?? null;
-}
 
 // ../api/src/event-ingest/arrivals.ts
 import { z as z33 } from "zod";
@@ -30086,12 +30089,8 @@ 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 suggestion = suggestedEnding(rows);
   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.`
   ];
 }
@@ -47236,56 +47235,58 @@ import { readFileSync as readFileSync15 } from "fs";
 import { defineCommand as defineCommand129 } from "citty";
 
 // src/commands/funnel/formMoments.ts
-var MAX_NAMED_FORMS = 8;
-function formMoments(events, forms) {
-  const outcomes = /* @__PURE__ */ new Map();
+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) {
-    const outcome = suggestedEnding(flowEventKeys(form.tree, form.slug));
-    if (outcome !== null) outcomes.set(outcome.eventKey, { slug: form.slug, outcome });
+    for (const ending of offeredEndings(form)) endings.set(ending.eventKey, { slug: form.slug, ending });
   }
-  const marked = events.map((event) => {
-    const found = outcomes.get(event.eventKey);
+  const known = events.map((event) => {
+    const found = endings.get(event.eventKey);
     if (found === void 0) return event;
-    outcomes.delete(event.eventKey);
-    return { ...event, step: found.outcome.nodeName, outcome: true };
+    endings.delete(event.eventKey);
+    return { ...event, step: found.ending.nodeName };
   });
-  const unfired = [...outcomes.values()].map(
-    ({ slug, outcome }) => ({
-      eventKey: outcome.eventKey,
+  const unfired = [...endings.values()].map(({ slug, ending }) => {
+    const countedAs = counted.get(ending.eventKey);
+    return {
+      eventKey: ending.eventKey,
       origin: "site",
       flowSlug: slug,
-      ...outcome.nodeType === null ? {} : { nodeType: outcome.nodeType },
+      ...ending.nodeType === null ? {} : { nodeType: ending.nodeType },
       events: 0,
       sessions: 0,
-      step: outcome.nodeName,
+      step: ending.nodeName,
       seen: false,
-      outcome: true
-    })
-  );
-  return [...marked, ...unfired];
+      ...countedAs === void 0 ? {} : { countedAs }
+    };
+  });
+  return [...known, ...unfired];
 }
-function withFormMoments(moments, forms) {
-  return { ...moments, events: formMoments(moments.events, forms) };
+function withFormMoments(moments, forms, counted) {
+  return { ...moments, events: formMoments(moments.events, forms, counted) };
 }
 function formsNamedHere(forms) {
-  return forms.filter((form) => suggestedEnding(flowEventKeys(form.tree, form.slug)) !== null).map((form) => form.slug);
+  return forms.filter((form) => flowEventKeys(form.tree, form.slug).length > 0).map((form) => form.slug);
 }
-function unplacedFormHints(steps, forms) {
+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.some((ending) => onAStep.has(ending.eventKey))) continue;
-    const outcome = suggestedEnding(endings);
-    if (outcome !== null) unplaced.push(`${form.slug} \u2192 \`${outcome.eventKey}\` ("${outcome.nodeName}")`);
+    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 [];
-  const shown = unplaced.slice(0, MAX_NAMED_FORMS);
-  const rest = unplaced.length - shown.length;
   return [
-    `${unplaced.length} Form(s) in this workspace reach no funnel step, so they move nobody along it however many people finish them: ${shown.join("; ")}${rest > 0 ? `; and ${rest} more` : ""}. Place one with \`baker funnel --add-trigger <step> --event <key>\`, which adds that one way in and leaves the rest of the step alone (\`baker funnel\` with no flags lists the step keys). If you also count a Form as a page conversion, count THAT SAME key, or the two numbers disagree for ever. A Form's other endings \u2014 a booking widget mid-flow, an embed's own signals \u2014 are listed by \`baker analytics conversions --flow <slug>\`.`
+    `${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.`
   ];
 }
 
@@ -47664,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(
@@ -47684,16 +47692,6 @@ var funnelResponseSchema = z44.object({
            * itself, which is the only place the name is known.
            */
           step: z44.string().optional(),
-          /**
-           * `true` on the ONE ending of a Form that is its outcome — the
-           * booking on a Form that books, the submit on a Form that submits.
-           * A Form raises several events and only one of them is the point;
-           * without this the agent is handed five equal-looking keys and the
-           * lifecycle noise a widget raises about itself sits among them.
-           * Same rule as `baker analytics conversions` recommends, so the
-           * conversion and the funnel step land on the same event.
-           */
-          outcome: z44.boolean().optional(),
           /**
            * `false` on an ending a Form raises natively but nobody has fired
            * yet — derived from the Form, offered at zero, exactly as a
@@ -47944,7 +47942,7 @@ var args3 = {
   },
   event: {
     type: "string",
-    description: "The event key `--add-trigger` or `--remove-trigger` acts on \u2014 an `events[].eventKey` from `--moments`, never invented. A Form's own outcome is listed there at zero, marked `outcome: true`, before anybody has filled the Form in",
+    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": {
@@ -47959,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 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; with **each Form's OUTCOME in this workspace marked** `outcome: true` and the `step` it happens on \u2014 a Form nobody has filled in yet gets that row at zero, `seen: false`, so a Form built minutes ago is pickable with nothing set up first. It is the booking on a Form that books, the submit on a Form that submits, and it is the same ending `baker analytics conversions` recommends counting, so the step and the conversion land on the same event. One marked row and not all seven a Form raises: the rest are rarely what a step wants, and `baker analytics conversions --flow <slug>` lists every ending of one Form, fired or not), `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",
+    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: {
@@ -47994,8 +47992,9 @@ var funnelCommand2 = defineCommand129({
         ...namedByCaller.length === 0 ? {} : { namedByCaller }
       };
       const response = await apiPost("/api/funnel", request);
-      const data = response.data.moments === void 0 ? response.data : { ...response.data, moments: withFormMoments(response.data.moments, forms) };
-      const hints2 = [...response.hints ?? [], ...unplacedFormHints(response.data.steps ?? [], forms)];
+      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,