@koda-sl/baker-cli 0.354.0-dev.faae9de67 → 0.355.0-dev.c2de9a6fe

package/README.md

@@ -742,7 +742,7 @@ Use `--no-cache` on any command to bypass **both** the local file cache and the
 |------|-----------|---------|
 | `FIELD_NOT_FOUND` | No | Invalid field in GAQL query |
 | `WRONG_RESOURCE` | No | Field queried from wrong resource |
-| `INVALID_OPERATOR` | No | Unsupported operator (e.g. CONTAINS) |
+| `INVALID_OPERATOR` | No | Unsupported operator (e.g. CONTAINS(), or =, IN or IS NOT NULL on a list field such as `final_urls` or `labels`, which takes only CONTAINS ALL/ANY/NONE). List-field operators are refused before the query is sent, with a corrected command that rewrites =/IN to CONTAINS ANY and drops a null test |
 | `CUSTOMER_NOT_FOUND` | No | Invalid customer ID — run `baker ads google accounts` to find valid IDs |
 | `MISSING_MANAGER_ID` | No | Account not accessible (may need MCC login-customer-id) |
 | `INCOMPATIBLE_FIELDS` | No | Fields can't be in same query |
@@ -1421,8 +1421,8 @@ baker experiment plan --landing oferta --variant oferta--1 --goal submit:book-a-
 baker experiment start --landing oferta --variant oferta--1 --because "60% of visitors never scroll past the hero" --change "put the price in the headline"
 baker experiment update --id temp_exp_1 --goal submit:book-a-call # a staged test can still change what it measures
 baker experiment update --id a3f91c2b --because "…"              # a live one can only change its wording
-baker experiment status                                          # the verdict on every test, first; dates as calendar dates
-baker experiment status --id a3f91c2b --full                     # one test, with everything the dashboard reads and the posteriors
+baker experiment status                                          # the verdict on every test
+baker experiment status --id a3f91c2b --full                     # one test, with the confidence and posteriors behind it
 baker experiment history --landing oferta                        # every finished test on a page: claim, numbers, decision, learning
 baker experiment pause --id a3f91c2b                             # everyone sees the original for now
 baker experiment resume --id a3f91c2b                            # the split picks up with the same sides
@@ -5412,7 +5412,7 @@ Before the deconstruct it runs a **local shot-cut pass** on the source file with
 
 A shot longer than the video model's per-clip ceiling (Seedance's 15s, passed as `video_deconstruct`'s `max_clip_s`) is split into equal **continuation sub-scenes** that share their splice boundary exactly — so a long shot is reproduced in **full** (no truncation) and joins seamlessly. Each sub-scene carries `continues_previous`.
 
-It then scaffolds the full pipeline like an **editing timeline**: each clip gets a **static-ad-grade start AND end keyframe** (`image_generate`, each with its **own `params.prompt`** regenerated from that scene's `scenes/sNN.json` — edit the scene file to change that frame, never the node prompt by hand; the slim `prompt.style.json` wired as the **shared `target_blueprint`** style reference, plus a per-element reference legend). Each keyframe is **fully recast** to the dropped `el_*` reference images. The original extracted frame is kept LAST as a **pure composition anchor** (framing / camera angle / shot size / pose) whenever identity is safely locked — i.e. a frame with no person/animal, OR every cast member present is **sheet-backed** (a multi-view turnaround owns identity, so the anchor can reproduce the source's framing without dictating the face). Since every base element is now sheet-backed by default, cast frames keep their framing anchor too — this is what reproduces the source's composition (a side-profile stays a side-profile, the camera angle holds scene to scene) instead of drifting to a fresh guess. The anchor's legend forbids taking identity/text/palette from it. It is dropped only when a cast member rests on a weak lone-snapshot reference (e.g. a `same_as` second-look slot), where the original frame could re-leak the source actor. Both keyframes feed `video_generate` (`first_frame`+`last_frame`, so Seedance interpolates real in-shot motion; ultra-detailed motion brief; duration snapped to the nearest allowed clip length). Every keyframe grounds **only on its own extracted frame + `el_*` slots** — no reference to any other generated frame — so all images render **in parallel** (no cascade). Source-frame URLs are **deduped** (each ingested once). `--frames reuse` wires the real source frame straight in.
+It then scaffolds the full pipeline like an **editing timeline**: each clip gets a **static-ad-grade start AND end keyframe** (`image_generate`, each with its **own `params.prompt`** regenerated from that scene's `scenes/sNN.json` — edit the scene file to change that frame, never the node prompt by hand; the slim `prompt.style.json` wired as the **shared `target_blueprint`** style reference, plus a per-element reference legend). Each keyframe is **fully recast** to the dropped `el_*` reference images. The original extracted frame is kept LAST as a **pure composition anchor** (framing / camera angle / shot size / pose) whenever identity is safely locked — i.e. a frame with no person/animal, OR every cast member present is **sheet-backed** (a multi-view turnaround owns identity, so the anchor can reproduce the source's framing without dictating the face). Since every base element is now sheet-backed by default, cast frames keep their framing anchor too — this is what reproduces the source's composition (a side-profile stays a side-profile, the camera angle holds scene to scene) instead of drifting to a fresh guess. The anchor's legend forbids taking identity/text/palette from it. It is dropped only when a cast member rests on a weak lone-snapshot reference (e.g. a `same_as` second-look slot), where the original frame could re-leak the source actor. Both keyframes feed `video_generate` (`first_frame`+`last_frame`, so Seedance interpolates real in-shot motion; ultra-detailed motion brief; duration snapped to the nearest allowed clip length). Every keyframe grounds **only on its own extracted frame + `el_*` slots** — no reference to any other generated frame — so all images render **in parallel** (no cascade). Source-frame URLs are **deduped** (each ingested once). `--frames reuse` wires the real source frame straight in — only on a video with nobody in it: when the deconstruct found a cast or a recurring person, reuse is refused (`frames_reuse_refused`) and every frame is generated, so the source's actors never reach the ad.
 
 **Composited scenes (split-screen / picture-in-picture / keyed presenter).** Real ads aren't always one full-frame shot — a frame can be **persistently divided** (b-roll on top, a presenter talking on the bottom) or **layer a presenter** over background footage (boxed in a corner, or green-screen keyed). The deconstruct now reports this per scene as `scene.composition` (`layout: split_screen | pip | keyed_overlay`, with one `region` per stream — each its own clean-plate frame + motion brief, the talking-head region flagged `is_presenter`). The scaffold reproduces a composited scene by building **one clip per region** (`s<i>_r0_*`, `s<i>_r1_*`, …) and compositing them with ffmpeg: a split-screen `vstack`/`hstack` (stack direction read from the region **panels**, so a top/bottom split always stacks vertically), or a picture-in-picture `overlay` of the presenter inset at its corner. A **keyed** presenter is first cut to transparency by `video_background_remove` (`s<i>_key`), then overlaid. The presenter region carries the native lip-synced voice; b-roll/render panels stay silent. To change a layout, edit `composition` in that scene's `scenes/sNN.json` and re-scaffold, or hand-edit the `s<i>_composite` ffmpeg args. Plain full-frame scenes (the default) are unaffected.
 
@@ -5466,7 +5466,7 @@ baker canvas run ./reference-ad.video.canvas.json
 |---|---|---|
 | `--out <path>` | `<video-dir>/<name>.video.canvas.json` | Where to write the canvas (composition is copied alongside). |
 | `--slug <slug>` | — | Creative slug (lowercase kebab): writes the canvas to `src/creatives/<slug>/<slug>.canvas.json` — the repo convention that attaches every run to the creative's dashboard generation history. `--out` wins over `--slug`. |
-| `--frames <mode>` | `generate` | `generate` emits ONE recast keyframe per scene (the original frame is dropped so the dropped `el_*` assets drive identity); `reuse` wires the real extracted first+last frames straight into the clips (faithful, cheaper, no recast). |
+| `--frames <mode>` | `generate` | `generate` emits ONE recast keyframe per scene (the original frame is dropped so the dropped `el_*` assets drive identity); `reuse` wires the real extracted first+last frames straight into the clips (faithful, cheaper, no recast) — only on a video with nobody in it; on one showing people it is refused and every frame is generated. |
 | `--ambient` | off | Give silent **b-roll** scenes native diegetic ambient (Seedance `generate_audio`), mixed deep under the music bed. Talking scenes already carry voice; check levels don't muddy the mix before keeping it. |
 | `--seam-dedup <mode>` | `head` | How to dedup the boundary frame two clips SHARE when a long shot is split for length (the second clip's first frame IS the first clip's last frame, so a plain concat freezes on it for a frame). `head` drops the second clip's first frame, `tail` drops the first clip's last frame, `off` keeps both. Only touches shared-frame continuation joins — a hard cut between two shots shares no frame. |
 | `--max-scenes <n>` | all source scenes | **Cost lever that reduces fidelity** — caps the deconstruct, MERGING away every scene beyond the cap (fewer cuts, lost beats). Prints a warning when set; omit it to reproduce every scene. |

package/dist/cli.js

@@ -10564,6 +10564,102 @@ function hintsFor(scope, days) {
   return hints2;
 }
 
+// src/commands/ads/google/list-fields.ts
+var LIST_FIELDS = /* @__PURE__ */ new Set([
+  "ad.final_mobile_urls",
+  "ad.final_urls",
+  "ad_group.excluded_parent_asset_field_types",
+  "ad_group.excluded_parent_asset_set_types",
+  "ad_group.labels",
+  "ad_group.primary_status_reasons",
+  "ad_group_ad.ad.final_mobile_urls",
+  "ad_group_ad.ad.final_urls",
+  "ad_group_ad.labels",
+  "ad_group_ad.primary_status_reasons",
+  "ad_group_asset.primary_status_reasons",
+  "ad_group_criterion.disapproval_reasons",
+  "ad_group_criterion.final_mobile_urls",
+  "ad_group_criterion.final_urls",
+  "ad_group_criterion.labels",
+  "ad_group_criterion.primary_status_reasons",
+  "ad_group_criterion.topic.path",
+  "ad_group_criterion.webpage.sample.sample_urls",
+  "asset.dynamic_custom_asset.contextual_keywords",
+  "asset.dynamic_custom_asset.similar_ids",
+  "asset.dynamic_education_asset.contextual_keywords",
+  "asset.dynamic_education_asset.similar_program_ids",
+  "asset.dynamic_flights_asset.similar_destination_ids",
+  "asset.dynamic_hotels_and_rentals_asset.contextual_keywords",
+  "asset.dynamic_hotels_and_rentals_asset.similar_property_ids",
+  "asset.dynamic_jobs_asset.contextual_keywords",
+  "asset.dynamic_jobs_asset.similar_job_ids",
+  "asset.dynamic_local_asset.contextual_keywords",
+  "asset.dynamic_local_asset.similar_deal_ids",
+  "asset.dynamic_real_estate_asset.contextual_keywords",
+  "asset.dynamic_real_estate_asset.similar_listing_ids",
+  "asset.dynamic_travel_asset.contextual_keywords",
+  "asset.dynamic_travel_asset.similar_destination_ids",
+  "asset.final_mobile_urls",
+  "asset.final_urls",
+  "asset.page_feed_asset.labels",
+  "asset.structured_snippet_asset.values",
+  "asset_group.final_mobile_urls",
+  "asset_group.final_urls",
+  "asset_group.primary_status_reasons",
+  "asset_group_asset.primary_status_reasons",
+  "asset_group_signal.disapproval_reasons",
+  "asset_set.business_profile_location_group.dynamic_business_profile_location_group_filter.label_filters",
+  "asset_set.business_profile_location_group.dynamic_business_profile_location_group_filter.listing_id_filters",
+  "asset_set.location_set.business_profile_location_set.label_filters",
+  "asset_set.location_set.business_profile_location_set.listing_id_filters",
+  "bidding_data_exclusion.advertising_channel_types",
+  "bidding_data_exclusion.campaigns",
+  "bidding_data_exclusion.devices",
+  "bidding_seasonality_adjustment.advertising_channel_types",
+  "bidding_seasonality_adjustment.campaigns",
+  "bidding_seasonality_adjustment.devices",
+  "campaign.excluded_parent_asset_field_types",
+  "campaign.excluded_parent_asset_set_types",
+  "campaign.feed_types",
+  "campaign.labels",
+  "campaign.optimization_goal_setting.optimization_goal_types",
+  "campaign.primary_status_reasons",
+  "campaign.selective_optimization.conversion_actions",
+  "campaign.shopping_setting.advertising_partner_ids",
+  "campaign.text_guidelines.term_exclusions",
+  "campaign_asset.primary_status_reasons",
+  "campaign_criterion.location_group.geo_target_constants",
+  "campaign_criterion.topic.path",
+  "campaign_criterion.webpage.sample.sample_urls",
+  "conversion_value_rule.audience_condition.user_interests",
+  "conversion_value_rule.audience_condition.user_lists",
+  "conversion_value_rule.device_condition.device_types",
+  "conversion_value_rule.geo_location_condition.excluded_geo_target_constants",
+  "conversion_value_rule.geo_location_condition.geo_target_constants",
+  "conversion_value_rule_set.conversion_value_rules",
+  "conversion_value_rule_set.dimensions",
+  "custom_conversion_goal.conversion_actions",
+  "customer.pay_per_conversion_eligibility_failure_reasons",
+  "customer_asset.primary_status_reasons",
+  "customer_client.applied_labels",
+  "experiment_arm.campaigns",
+  "experiment_arm.in_design_campaigns",
+  "keyword_plan_campaign.language_constants",
+  "local_services_employee.category_ids",
+  "local_services_employee.languages_spoken",
+  "metrics.interaction_event_types",
+  "recommendation.campaigns",
+  "shared_criterion.webpage.sample.sample_urls",
+  "shopping_product.target_countries",
+  "topic_constant.path",
+  "user_list.lookalike_user_list.country_codes",
+  "user_list.lookalike_user_list.seed_user_list_ids"
+]);
+var LIST_FIELD_OPERATORS = "CONTAINS ALL, CONTAINS ANY, CONTAINS NONE";
+function listFieldGuidance(field) {
+  return `${field} is a list field: it takes only ${LIST_FIELD_OPERATORS} \u2014 no comparison (=, !=, IN), pattern match or null test. To find rows that have it, drop that condition, keep ${field} in SELECT and filter the rows (rows without it omit the key); to match values, use ${field} CONTAINS ANY ('value')`;
+}
+
 // src/commands/ads/google/correction-table.ts
 function buildCommand(query, ctx) {
   return `baker ads google query "${query}" --customer-id ${ctx.customerId}`;
@@ -10591,6 +10687,27 @@ var CORRECTION_RULES = [
       };
     }
   },
+  // 0b. OPERATOR_FIELD_MISMATCH — the field refuses this operator, and Google names the
+  // ones it takes. Kept ahead of the field-specific rules for the same reason as rule 0.
+  // A repeated field (final_urls, labels, …) takes only CONTAINS ALL/ANY/NONE, so it has
+  // no null test at all: read it unfiltered and filter the rows instead.
+  {
+    matchApiError: /OPERATOR_FIELD_MISMATCH|is not a valid operator to use with/i,
+    fix: (ctx) => {
+      const message = ctx.apiErrorMessage ?? "";
+      const field = message.match(/valid operator to use with '([\w.]+)'/i)?.[1] ?? "this field";
+      const operator = message.match(/([A-Z=!<>][A-Z_ =!<>]*?) is not a valid operator/)?.[1]?.trim();
+      const valid = message.match(/Valid operators: (.+?)\.?(?:"|$)/i)?.[1]?.trim();
+      const refused = operator ? `${operator} cannot be used on ${field}` : `${field} does not take that operator`;
+      const allowed = valid ? `; its valid operators are ${valid}` : "";
+      const repeated = valid?.split(",").every((op) => /^CONTAINS (ALL|ANY|NONE)$/i.test(op.trim())) ?? false;
+      const guidance = repeated ? `. ${listFieldGuidance(field)}` : ". Rewrite that condition with one of them, or drop it and filter the rows";
+      return {
+        action: "change_operator",
+        explanation: `${refused}${allowed}${guidance}`
+      };
+    }
+  },
   // 1. bare keyword.text → ad_group_criterion.keyword.text (leaves <resource>.keyword.text untouched)
   {
     matchQuery: /(?<![\w.])keyword\.text\b/,
@@ -10633,10 +10750,11 @@ var CORRECTION_RULES = [
       };
     }
   },
-  // 4. CONTAINS → LIKE
+  // 4. CONTAINS → LIKE. Keyed on the query alone: Google's error envelope ("Request contains an
+  // invalid argument … Valid operators: CONTAINS ANY") matches any loose error pattern, and this
+  // advice only makes sense when the query actually wrote CONTAINS(…).
   {
     matchQuery: /CONTAINS\s*\(/i,
-    matchApiError: /CONTAINS.*not.*supported|invalid.*operator.*CONTAINS/i,
     fix: (ctx) => {
       const match = ctx.originalQuery.match(/CONTAINS\s*\(\s*([^,]+),\s*'([^']+)'\s*\)/i);
       if (match) {
@@ -13082,6 +13200,73 @@ function rejectOversizedLimit(query, customerId) {
     }
   };
 }
+var WHERE_OPERATOR = /(?<![\w.])([a-z_]+(?:\.[a-z_]+)+)\s*(CONTAINS\s+(?:ALL|ANY|NONE)|IS\s+NOT\s+NULL|IS\s+NULL|NOT\s+LIKE|NOT\s+IN|NOT\s+REGEXP_MATCH|REGEXP_MATCH|LIKE|IN|BETWEEN|DURING|!=|<=|>=|=|<|>)/gi;
+function escapeRegExp(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function withoutNullTest(query, field) {
+  const test = `${escapeRegExp(field)}\\s+IS\\s+(?:NOT\\s+)?NULL\\b`;
+  const dropped = query.replace(new RegExp(`\\bWHERE\\s+${test}\\s+AND\\s+`, "i"), "WHERE ").replace(new RegExp(`\\s+AND\\s+${test}`, "i"), "").replace(new RegExp(`\\s*\\bWHERE\\s+${test}`, "i"), "");
+  return mentions(selectClause(dropped), field) ? dropped : dropped.replace(/SELECT\s+/i, `SELECT ${field}, `);
+}
+function asListCondition(query, field) {
+  const condition = new RegExp(
+    `(?<![\\w.])${escapeRegExp(field)}\\s*(NOT\\s+IN\\b|IN\\b|!=|=)\\s*('[^']*'|\\([^)]*\\))`,
+    "i"
+  );
+  const match = query.match(condition);
+  if (!match) return null;
+  const [, operator = "", value = ""] = match;
+  const contains = /^(=|IN)$/i.test(operator.trim()) ? "CONTAINS ANY" : "CONTAINS NONE";
+  const values = value.startsWith("(") ? value : `(${value})`;
+  return query.replace(condition, `${field} ${contains} ${values}`);
+}
+function rejectListFieldOperator(query, customerId) {
+  const where = whereClause(query).replace(/'[^']*'/g, "''");
+  const refusals = [...where.matchAll(WHERE_OPERATOR)].map(([, field = "", operator = ""]) => ({
+    field: field.toLowerCase(),
+    operator: operator.toUpperCase().replace(/\s+/g, " ")
+  })).filter(({ field, operator }) => LIST_FIELDS.has(field) && !operator.startsWith("CONTAINS"));
+  const first = refusals[0];
+  if (!first) return null;
+  const fixed = refusals.reduce(
+    (corrected, { field, operator }) => corrected === null ? null : operator.startsWith("IS ") ? withoutNullTest(corrected, field) : asListCondition(corrected, field),
+    query
+  );
+  return {
+    ok: false,
+    error: {
+      code: "INVALID_OPERATOR",
+      message: `${first.operator} cannot be used on ${first.field}: it is a list field, so Google would refuse this query.`,
+      fix: {
+        action: "change_operator",
+        ...fixed ? { correctedCommand: buildCommand2(fixed, customerId) } : {},
+        explanation: listFieldGuidance(first.field)
+      },
+      retryable: false
+    }
+  };
+}
+function rejectContainsCall(query, customerId) {
+  const containsMatch = query.match(/CONTAINS\s*\(\s*([^,]+),\s*'([^']+)'\s*\)/i);
+  if (!containsMatch) return null;
+  const field = containsMatch[1]?.trim();
+  const value = containsMatch[2] ?? "";
+  const fixed = query.replace(/CONTAINS\s*\(\s*[^,]+,\s*'[^']+'\s*\)/i, `${field} LIKE '%${value}%'`);
+  return {
+    ok: false,
+    error: {
+      code: "INVALID_OPERATOR",
+      message: "GAQL does not support CONTAINS. Use LIKE with % wildcards.",
+      fix: {
+        action: "change_operator",
+        correctedCommand: buildCommand2(fixed, customerId),
+        explanation: "GAQL uses LIKE '%value%' for substring matching, not CONTAINS()"
+      },
+      retryable: false
+    }
+  };
+}
 function validatePreflight(query, customerId, limit) {
   const warnings = [];
   const corrected = query;
@@ -13104,29 +13289,6 @@ function validatePreflight(query, customerId, limit) {
       }
     };
   }
-  const containsMatch = corrected.match(/CONTAINS\s*\(\s*([^,]+),\s*'([^']+)'\s*\)/i);
-  if (containsMatch) {
-    const field = containsMatch[1]?.trim();
-    const value = containsMatch[2] ?? "";
-    const fixed = corrected.replace(/CONTAINS\s*\(\s*[^,]+,\s*'[^']+'\s*\)/i, `${field} LIKE '%${value}%'`);
-    return {
-      valid: false,
-      warnings: [],
-      error: {
-        ok: false,
-        error: {
-          code: "INVALID_OPERATOR",
-          message: "GAQL does not support CONTAINS. Use LIKE with % wildcards.",
-          fix: {
-            action: "change_operator",
-            correctedCommand: buildCommand2(fixed, customerId),
-            explanation: "GAQL uses LIKE '%value%' for substring matching, not CONTAINS()"
-          },
-          retryable: false
-        }
-      }
-    };
-  }
   const openDateMatch = corrected.match(/segments\.date\s*>=\s*'(\d{4}-\d{2}-\d{2})'/i);
   if (openDateMatch && !/BETWEEN/i.test(corrected)) {
     const startDate = openDateMatch[1] ?? "";
@@ -13153,10 +13315,10 @@ function validatePreflight(query, customerId, limit) {
       }
     };
   }
-  const duringRejection = rejectUnsupportedDuring(corrected, customerId);
-  if (duringRejection) return { valid: false, warnings: [], error: duringRejection };
-  const limitRejection = rejectOversizedLimit(corrected, customerId);
-  if (limitRejection) return { valid: false, warnings: [], error: limitRejection };
+  for (const reject of [rejectContainsCall, rejectListFieldOperator, rejectUnsupportedDuring, rejectOversizedLimit]) {
+    const rejection2 = reject(corrected, customerId);
+    if (rejection2) return { valid: false, warnings: [], error: rejection2 };
+  }
   if (/\bsegments\.conversion_action_name\b/i.test(corrected) && /\bmetrics\.cost_micros\b/i.test(corrected)) {
     return {
       valid: false,
@@ -39734,10 +39896,18 @@ function dropUncastVoices(nodes) {
     if (node && node.type === "voice_select" && !referenced.has(node.id)) nodes.splice(i, 1);
   }
 }
-function scaffoldVideoCanvas(input, elementsInput, opts) {
+function framesReuseRefusal(blueprint, elements, requested) {
+  if (requested !== "reuse") return void 0;
+  const showsPeople = (blueprint.global?.cast ?? []).length > 0 || elements.some((e) => e.type.toLowerCase() === "person");
+  if (!showsPeople) return void 0;
+  return "--frames reuse was not applied: this video shows people, and reusing its frames would put the source's actors into our ad. Every frame is generated instead, recast to the el_* references. Reuse applies only to a video with nobody in it.";
+}
+function scaffoldVideoCanvas(input, elementsInput, requested) {
   const blueprint = VideoBlueprint.parse(input);
   injectHookPhysicality(blueprint);
   const elements = RecurringElements.parse(elementsInput);
+  const reuseRefused = framesReuseRefusal(blueprint, elements, requested.frames);
+  const opts = reuseRefused ? { ...requested, frames: "generate" } : requested;
   const clock = spineClockFor(blueprint);
   const nodes = [];
   emitBlueprintIngests(opts, nodes);
@@ -39844,6 +40014,7 @@ function scaffoldVideoCanvas(input, elementsInput, opts) {
   }
   const todo = {
     ...buildVideoTodo(videoReport(input, elementsInput), overlays.length, floating.length, opts, blueprint),
+    ...reuseRefused ? { frames_reuse_refused: reuseRefused } : {},
     ...aspectRemapTodo(resolveAspect(blueprint.source?.aspect_ratio, opts.aspect, genAspectsFor(opts.videoModel))),
     model_constraints: buildModelConstraints()
   };
@@ -44651,6 +44822,12 @@ function videoDefinitionDescription(blueprint) {
   const product = g.branding?.product;
   return typeof product === "string" && product.trim() ? product.trim() : void 0;
 }
+function framesModeReport(canvas, requested) {
+  const todo = canvas.metadata?.todo;
+  const mode = typeof todo?.frames_mode === "string" ? todo.frames_mode : requested;
+  const refused = typeof todo?.frames_reuse_refused === "string" ? todo.frames_reuse_refused : void 0;
+  return { frames_mode: mode, ...refused ? { frames_reuse_refused: refused } : {} };
+}
 async function materializeReferenceVideo(fileArg2) {
   if (!/^https?:\/\//i.test(fileArg2)) return path26.resolve(fileArg2);
   let bytes;
@@ -44808,7 +44985,10 @@ var scaffoldVideoCommand = defineCommand116({
       type: "string",
       description: "Creative slug \u2014 writes the canvas to src/creatives/<slug>/<slug>.canvas.json (repo convention)"
     },
-    frames: { type: "string", description: '"generate" (default, anchored regen) or "reuse" (wire real frames in)' },
+    frames: {
+      type: "string",
+      description: `"generate" (default, every frame regenerated for our ad) or "reuse" (wire the source's real frames in). Reuse applies only to a video with nobody in it \u2014 on a video showing people it is refused and every frame is generated, so the source's actors never reach our ad.`
+    },
     ambient: {
       type: "boolean",
       description: "Give silent b-roll scenes native diegetic ambient mixed deep under the music bed (off by default)"
@@ -44996,6 +45176,7 @@ var scaffoldVideoCommand = defineCommand116({
             error: { code: "validation", issues: validation.issues },
             canvas_path: outPath,
             prompt_path: blueprintPath,
+            ...framesModeReport(canvas, frames),
             note: "The canvas WAS written despite the blocking issue(s) \u2014 fix them in place, then `baker canvas validate` before running."
           },
           null,
@@ -45045,7 +45226,7 @@ var scaffoldVideoCommand = defineCommand116({
           source_reference: sourceRef.url,
           composition_dir: compositionDest,
           output: canvas.output,
-          frames_mode: frames,
+          ...framesModeReport(canvas, frames),
           models: {
             deconstruct: deconstructModel,
             select: selectModel,
@@ -47115,80 +47296,6 @@ async function declarationsOf(root, files) {
   return sources.flatMap(eventDeclarationsIn);
 }
 
-// src/commands/experiment/readout.ts
-function isoMoment(ms) {
-  return ms === null ? null : new Date(ms).toISOString();
-}
-function isoDay2(ms) {
-  return ms === null ? null : new Date(ms).toISOString().slice(0, 10);
-}
-function compactArm(arm) {
-  return { visitors: arm.visitors, conversions: arm.conversions, rate: Math.round(arm.rate * 1e4) / 1e4 };
-}
-function compactMetric(metric) {
-  return {
-    name: metric.name,
-    reading: metric.reading,
-    control: metric.control.conversions,
-    variant: metric.variant.conversions
-  };
-}
-function fullArm(arm) {
-  return {
-    ...arm,
-    ...arm.snapshotCapturedAt === void 0 ? {} : { snapshotCapturedAt: isoMoment(arm.snapshotCapturedAt) }
-  };
-}
-function statusReadout(row, { full, now }) {
-  const decisionWhen = {
-    earliestDecisionAt: isoDay2(row.earliestDecisionAt),
-    ...row.earliestDecisionAt === null ? {} : { earliestDecisionIn: describeWait(row.earliestDecisionAt, now) }
-  };
-  const moments = {
-    startedAt: isoMoment(row.startedAt),
-    pausedAt: isoMoment(row.pausedAt),
-    finishedAt: isoMoment(row.finishedAt)
-  };
-  if (full) {
-    return {
-      ...row,
-      ...moments,
-      ...decisionWhen,
-      control: fullArm(row.control),
-      variant: fullArm(row.variant)
-    };
-  }
-  return {
-    experimentId: row.experimentId,
-    landingSlug: row.landingSlug,
-    variantSlug: row.variantSlug,
-    status: row.status,
-    verdict: row.verdict,
-    summary: row.summary,
-    ...row.winner === null ? {} : { winner: row.winner },
-    ...row.invalidReason === null ? {} : { invalidReason: row.invalidReason },
-    stillNeeded: row.stillNeeded,
-    ...decisionWhen,
-    willNotConclude: row.willNotConclude,
-    control: compactArm(row.control),
-    variant: compactArm(row.variant),
-    secondary: row.secondary.map(compactMetric),
-    hypothesisStatement: row.hypothesisStatement,
-    minDetectableRelativeLift: row.minDetectableRelativeLift,
-    goal: row.goal,
-    ...row.variantGoal === null ? {} : { variantGoal: row.variantGoal },
-    goalLabel: row.goalLabel,
-    ...moments,
-    ...row.status === "finished" ? {
-      survivor: row.survivor,
-      hypothesisOutcome: row.hypothesisOutcome,
-      fold: row.fold,
-      learning: row.learning,
-      endReason: row.endReason
-    } : {}
-  };
-}
-
 // src/commands/experiment/update.ts
 function buildUpdateRequest(args5, rawArgs) {
   const expect = args5.expect === void 0 ? void 0 : String(args5.expect);
@@ -47430,26 +47537,18 @@ registerSchema({
   args: {
     id: { type: "string", description: "One test, by its id", required: false },
     landing: LANDING_FILTER_ARG,
-    full: {
-      type: "boolean",
-      description: "Every field the dashboard reads too \u2014 the hypothesis in parts, what each version owns, the preview pictures and the posteriors behind the verdict",
-      required: false
-    }
+    full: { type: "boolean", description: "Include the posteriors behind the verdict", required: false }
   }
 });
 var statusCommand6 = defineCommand124({
   meta: {
     name: "status",
-    description: "The verdict on each test. Read `verdict` and nothing else to decide: keep_running | winner | no_difference | cannot_win | invalid. `cannot_win` means even the best case is under the lift the test was looking for \u2014 end it and keep the original. `stillNeeded` is the data (visitors, conversions) the test still needs; a test is gated on data, never on days. `earliestDecisionAt` is the day this page's traffic would get it there (YYYY-MM-DD) and `earliestDecisionIn` how far off that is \u2014 say those, never work a date out yourself. `summary` is one sentence you can show the client, and `secondary` lists every other conversion the company counts on the same two arms \u2014 context, never a second decision. The numbers under `--full` are for printing, never for deciding \u2014 a test that says keep_running has not finished, however good its numbers look."
+    description: "The verdict on each test. Read `verdict` and nothing else to decide: keep_running | winner | no_difference | cannot_win | invalid. `cannot_win` means even the best case is under the lift the test was looking for \u2014 end it and keep the original. `stillNeeded` is the data (visitors, conversions) the test still needs; a test is gated on data, never on days. `summary` is one sentence you can show the client, and `secondary` lists every other conversion the company counts on the same two arms \u2014 context, never a second decision. The numbers under `--full` are for printing, never for deciding \u2014 a test that says keep_running has not finished, however good its numbers look."
   },
   args: {
     id: { type: "string", description: "One test, by its id", required: false },
     landing: LANDING_FILTER_ARG,
-    full: {
-      type: "boolean",
-      description: "Every field the dashboard reads too \u2014 the hypothesis in parts, what each version owns, the preview pictures and the posteriors behind the verdict",
-      required: false
-    }
+    full: { type: "boolean", description: "Include the posteriors behind the verdict", required: false }
   },
   run: async ({ args: args5 }) => {
     try {
@@ -47458,13 +47557,10 @@ var statusCommand6 = defineCommand124({
         ...args5.landing ? { landingSlug: String(args5.landing) } : {},
         ...args5.full === true ? { full: true } : {}
       });
-      const now = Date.now();
       writeJsonEnvelope({
         ok: true,
-        data: {
-          experiments: response.data.experiments.map((row) => statusReadout(row, { full: args5.full === true, now }))
-        },
-        hints: buildStatusHints(response.data.experiments, now)
+        data: response.data,
+        hints: buildStatusHints(response.data.experiments)
       });
     } catch (error) {
       reportApiError(error);
@@ -57608,7 +57704,7 @@ function mentionsInSource(source, names) {
   const out = [];
   for (const name of names) {
     const seen = /* @__PURE__ */ new Set();
-    for (const m of visible.matchAll(new RegExp(`\\b${escapeRegExp(name)}\\b`, "gi"))) {
+    for (const m of visible.matchAll(new RegExp(`\\b${escapeRegExp2(name)}\\b`, "gi"))) {
       const at = m.index ?? 0;
       if (tables.some(([from, to]) => at >= from && at < to)) continue;
       const start = sentenceStart(visible, at);
@@ -57637,7 +57733,7 @@ function blankHtmlKeepingOffsets(text2) {
   }
   return out.join("");
 }
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function detectSource(source) {