@koda-sl/baker-cli 0.244.0 → 0.246.0

package/dist/cli.js

@@ -9408,8 +9408,8 @@ function countStaccato(text2) {
   let first = "";
   let runStart = 0;
   for (const [i, s] of sentences.entries()) {
-    const words3 = s.split(/\s+/).filter(Boolean).length;
-    if (words3 > 0 && words3 <= STACCATO_MAX_WORDS) {
+    const words2 = s.split(/\s+/).filter(Boolean).length;
+    if (words2 > 0 && words2 <= STACCATO_MAX_WORDS) {
       if (run === 0) runStart = i;
       run++;
       if (run === STACCATO_RUN) {
@@ -9427,10 +9427,10 @@ function countTitleCaseHeadings(text2) {
   let first = "";
   for (const m of text2.matchAll(/^\s{0,3}#{1,6}\s+(.+)$/gm)) {
     const heading = (m[1] ?? "").trim();
-    const words3 = heading.split(/\s+/).filter((w) => new RegExp("\\p{L}", "u").test(w));
-    if (words3.length < 4) continue;
-    const capitalized = words3.filter((w) => new RegExp("^\\p{Lu}", "u").test(w)).length;
-    if (capitalized / words3.length < 0.8) continue;
+    const words2 = heading.split(/\s+/).filter((w) => new RegExp("\\p{L}", "u").test(w));
+    if (words2.length < 4) continue;
+    const capitalized = words2.filter((w) => new RegExp("^\\p{Lu}", "u").test(w)).length;
+    if (capitalized / words2.length < 0.8) continue;
     count++;
     if (!first) first = heading;
   }
@@ -9679,7 +9679,7 @@ function renderAdvisories(data, lines) {
     return;
   }
   lines.push("");
-  lines.push("Advisories (non-blocking \u2014 build these out for a higher-performance campaign)");
+  lines.push("Advisories (non-blocking, checked across the whole draft \u2014 settle these before you publish)");
   for (const advisory of advisories) {
     lines.push(`  \u2022 ${advisory.message}`);
   }
@@ -9779,11 +9779,11 @@ function rawTextEntries(value) {
   const values = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
   return values.filter((v) => typeof v === "string").flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
 }
-function rawFileEntries(path40) {
-  if (typeof path40 !== "string" || path40.length === 0) {
+function rawFileEntries(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return [];
   }
-  return readFileSync2(path40, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return readFileSync2(path38, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function keywordEntries(args) {
   const defaultMatch = typeof args["match-type"] === "string" ? args["match-type"].toUpperCase() : void 0;
@@ -9806,19 +9806,19 @@ function keywordEntries(args) {
   }
   return entries;
 }
-function loadJsonFileArg(path40) {
-  if (typeof path40 !== "string" || path40.length === 0) {
+function loadJsonFileArg(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync2(path40, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path38, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation(`${path40} must contain a JSON object`);
+      failWriteValidation(`${path38} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation(`${path40} is not valid JSON: ${err.message}`);
+      failWriteValidation(`${path38} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -9948,10 +9948,10 @@ async function stageUpdate(kind, customerId, target, payload, hints) {
 async function stageTarget(kind, customerId, target, hints) {
   await stageGoogleOp({ kind, customerId, target }, hints);
 }
-async function draftAction(path40, body, chat) {
+async function draftAction(path38, body, chat) {
   try {
     const chatId = resolveChatId(chat);
-    const response = await apiPost(path40, { chatId, ...body });
+    const response = await apiPost(path38, { chatId, ...body });
     writeJsonEnvelope(response);
   } catch (err) {
     handleGoogleError(err);
@@ -10188,10 +10188,33 @@ function warnDefaults(ctx) {
   }
 }
 
+// src/commands/ads/google/keywords/provenance.ts
+var PLANNER_SOURCE = "keyword_planner_estimate";
+var IDENTITY_FIELDS = /* @__PURE__ */ new Set(["keyword"]);
+function stampPlannerRows(rows) {
+  return rows.map((row) => {
+    const stamped = { source: PLANNER_SOURCE };
+    for (const [key, value] of Object.entries(row)) {
+      stamped[IDENTITY_FIELDS.has(key) || key.startsWith("planner_") ? key : `planner_${key}`] = value;
+    }
+    return stamped;
+  });
+}
+var PLANNER_FIELD_DESCRIPTIONS = {
+  source: `Always "${PLANNER_SOURCE}". These rows are Keyword Planner ESTIMATES of total market search volume, NOT this account's data. Never report them as impressions, clicks or any account metric \u2014 read those from a query against the account.`,
+  keyword: "The keyword this estimate is for",
+  planner_avg_monthly_searches: "ESTIMATE: average monthly searches across the whole market (string), last 12 months",
+  planner_competition: "ESTIMATE: competition level \u2014 LOW, MEDIUM, HIGH",
+  planner_competition_index: "ESTIMATE: competition index 0-100 as string (higher = more competitive)",
+  planner_low_top_of_page_bid_micros: "ESTIMATE: low-range top-of-page CPC bid in micros (\xF7 1,000,000 for currency)",
+  planner_high_top_of_page_bid_micros: "ESTIMATE: high-range top-of-page CPC bid in micros (\xF7 1,000,000 for currency)",
+  planner_monthly_search_volumes: "ESTIMATE: monthly market search volume breakdown (array of {year, month, monthly_searches})"
+};
+
 // src/commands/ads/google/keywords/discover.ts
 registerSchema({
   command: "ads.google.keywords.discover",
-  description: "Discover keyword ideas from seed keywords or URLs. Returns { keywords, total_results, next_page_token? } with snake_case fields matching the Google Ads API. IMPORTANT: If --location and --language are omitted, defaults to United States (2840) and English (1000). The response includes a query_context object showing which location/language were used.",
+  description: 'Discover keyword ideas from seed keywords or URLs. Returns { source: "keyword_planner_estimate", keywords, total_results, next_page_token? }. THESE ARE ESTIMATES OF TOTAL MARKET SEARCH VOLUME, NOT THIS ACCOUNT\'S DATA: every row carries a source column and every metric is prefixed planner_ (planner_avg_monthly_searches, planner_competition, ...). Never report a planner_ number as impressions, clicks or any account metric \u2014 read those with `baker ads google query` against the account. IMPORTANT: If --location and --language are omitted, defaults to United States (2840) and English (1000). The response includes a query_context object showing which location/language were used.',
   args: {
     "customer-id": {
       type: "string",
@@ -10220,15 +10243,9 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var KEYWORD_IDEA_FIELDS = {
-  keyword: "Suggested keyword text",
-  avg_monthly_searches: "Average monthly search volume (string)",
-  competition: "Competition level: LOW, MEDIUM, HIGH",
-  competition_index: "Competition index 0-100 as string (higher = more competitive)",
-  low_top_of_page_bid_micros: "Low-range CPC bid in micros (\xF7 1,000,000 for currency)",
-  high_top_of_page_bid_micros: "High-range CPC bid in micros (\xF7 1,000,000 for currency)",
-  monthly_search_volumes: "Monthly search volume breakdown (array of {year, month, monthly_searches})"
-};
+function stampDiscoverResponse(data) {
+  return { ...data, source: PLANNER_SOURCE, keywords: stampPlannerRows(data.keywords ?? []) };
+}
 function buildDiscoverBody(customerId, args) {
   const body = {
     customerId,
@@ -10269,6 +10286,8 @@ var discoverCommand = defineCommand23({
     name: "discover",
     description: `Discover new keyword ideas from seed keywords or competitor URLs.
 
+Returns Keyword Planner ESTIMATES of market search volume, not this account's numbers. Every row carries source=keyword_planner_estimate and planner_-prefixed metrics; keep those names when you quote a figure, and never present one as an impression or click count.
+
 Examples:
   baker ads google keywords discover --customer-id 1234567890 --seeds "running shoes,athletic footwear"
   baker ads google keywords discover --customer-id 1234567890 --url "https://competitor.com"
@@ -10303,7 +10322,7 @@ Examples:
       const cached = cacheGet("keywords", cacheKey);
       if (cached) {
         warnDefaults(queryContext);
-        writeAdsJson({ ok: true, data: cached.data, cached: true, query_context: queryContext });
+        writeAdsJson({ ok: true, data: stampDiscoverResponse(cached.data), cached: true, query_context: queryContext });
         return;
       }
     }
@@ -10313,12 +10332,13 @@ Examples:
         cacheSet("keywords", cacheKey, data, 24 * 60 * 60 * 1e3);
       }
       warnDefaults(queryContext);
+      const stamped = stampDiscoverResponse(data);
       const format = args.output || "json";
       if (format !== "json") {
-        writeAdsOutput(data.keywords, format);
+        writeAdsOutput(stamped.keywords, format);
         return;
       }
-      writeAdsJson({ ok: true, data, fields: KEYWORD_IDEA_FIELDS, query_context: queryContext });
+      writeAdsJson({ ok: true, data: stamped, fields: PLANNER_FIELD_DESCRIPTIONS, query_context: queryContext });
     } catch (err) {
       handleKeywordError(err);
     }
@@ -10371,7 +10391,7 @@ var locationsCommand = defineCommand25({
 import { defineCommand as defineCommand26 } from "citty";
 registerSchema({
   command: "ads.google.keywords.metrics",
-  description: "Get historical metrics for specific keywords. Returns { historical_metrics: [...] } with snake_case fields matching the Google Ads API. IMPORTANT: If --location and --language are omitted, defaults to United States (2840) and English (1000). The response includes a query_context object showing which location/language were used.",
+  description: 'Get historical market metrics for specific keywords. Returns { source: "keyword_planner_estimate", historical_metrics: [...] }. THESE ARE KEYWORD PLANNER ESTIMATES OF TOTAL MARKET SEARCH VOLUME, NOT THIS ACCOUNT\'S DATA: every row carries a source column and every metric is prefixed planner_ (planner_avg_monthly_searches, planner_competition, ...). Never report a planner_ number as impressions, clicks or any account metric \u2014 read those with `baker ads google query` against the account. IMPORTANT: If --location and --language are omitted, defaults to United States (2840) and English (1000). The response includes a query_context object showing which location/language were used.',
   args: {
     "customer-id": {
       type: "string",
@@ -10393,6 +10413,9 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
+function stampMetricsResponse(data) {
+  return { ...data, source: PLANNER_SOURCE, historical_metrics: stampPlannerRows(data.historical_metrics ?? []) };
+}
 function handleMetricsError(err) {
   if (err instanceof ApiError) {
     if (isNotConnectedError(err.code, err.message)) {
@@ -10418,6 +10441,8 @@ var metricsCommand = defineCommand26({
     name: "metrics",
     description: `Get historical search metrics for specific keywords.
 
+Returns Keyword Planner ESTIMATES of market search volume, not this account's numbers. Every row carries source=keyword_planner_estimate and planner_-prefixed metrics; keep those names when you quote a figure, and never present one as an impression or click count.
+
 Examples:
   baker ads google keywords metrics --customer-id 1234567890 --keywords "running shoes,nike shoes,adidas shoes"
   baker ads google keywords metrics --customer-id 1234567890 --keywords "seo tools" --location 2826`
@@ -10454,7 +10479,7 @@ Examples:
       const cached = cacheGet("keywords", cacheKey);
       if (cached) {
         warnDefaults(queryContext);
-        writeAdsJson({ ok: true, data: cached.data, cached: true, query_context: queryContext });
+        writeAdsJson({ ok: true, data: stampMetricsResponse(cached.data), cached: true, query_context: queryContext });
         return;
       }
     }
@@ -10464,21 +10489,13 @@ Examples:
         cacheSet("keywords", cacheKey, data, 24 * 60 * 60 * 1e3);
       }
       warnDefaults(queryContext);
+      const stamped = stampMetricsResponse(data);
       const format = args.output || "json";
       if (format !== "json") {
-        writeAdsOutput(data.historical_metrics, format);
+        writeAdsOutput(stamped.historical_metrics, format);
         return;
       }
-      const fields = {
-        keyword: "The keyword analyzed",
-        avg_monthly_searches: "Average monthly search volume as string (last 12 months)",
-        competition: "Competition level: LOW, MEDIUM, HIGH",
-        competition_index: "Competition index 0-100 as string (higher = more competitive)",
-        low_top_of_page_bid_micros: "Low-range CPC bid in micros (\xF7 1,000,000 for currency)",
-        high_top_of_page_bid_micros: "High-range CPC bid in micros (\xF7 1,000,000 for currency)",
-        monthly_search_volumes: "Monthly search volume breakdown (array of {year, month, monthly_searches})"
-      };
-      writeAdsJson({ ok: true, data, fields, query_context: queryContext });
+      writeAdsJson({ ok: true, data: stamped, fields: PLANNER_FIELD_DESCRIPTIONS, query_context: queryContext });
     } catch (err) {
       handleMetricsError(err);
     }
@@ -10625,10 +10642,211 @@ function keywordServingWarnings(rows, options) {
   return renderKeywordLimits(collectKeywordLimits(rows, options));
 }
 
+// src/commands/ads/google/presets.ts
+var GAQL_DATE_RANGE_RE = /^(?:TODAY|YESTERDAY|LAST_7_DAYS|LAST_14_DAYS|LAST_30_DAYS|LAST_90_DAYS|THIS_MONTH|LAST_MONTH|THIS_QUARTER|LAST_QUARTER|THIS_YEAR|LAST_YEAR|ALL_TIME|BETWEEN\s+'[0-9]{4}-[0-9]{2}-[0-9]{2}'\s+AND\s+'[0-9]{4}-[0-9]{2}-[0-9]{2}')$/i;
+function isValidDateRange(value) {
+  return GAQL_DATE_RANGE_RE.test(value.trim());
+}
+var SERVING_CHAINS = {
+  keyword_view: ["campaign.status", "ad_group.status", "ad_group_criterion.status"],
+  ad_group_criterion: ["campaign.status", "ad_group.status", "ad_group_criterion.status"],
+  ad_group_ad: ["campaign.status", "ad_group.status", "ad_group_ad.status"],
+  search_term_view: ["campaign.status", "ad_group.status"],
+  ad_group: ["campaign.status", "ad_group.status"],
+  asset_group: ["campaign.status", "asset_group.status"],
+  asset_group_asset: ["campaign.status", "asset_group.status"]
+};
+var PRESETS = [
+  {
+    name: "campaign-performance",
+    description: "Campaign-level metrics overview",
+    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, campaign.advertising_channel_type, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions, metrics.conversions_value, metrics.ctr, metrics.average_cpc FROM campaign WHERE segments.date DURING {dateRange}{statusScope} ORDER BY metrics.cost_micros DESC LIMIT {limit}`,
+    defaultDateRange: "LAST_30_DAYS",
+    defaultLimit: 200,
+    statusFields: ["campaign.status"]
+  },
+  {
+    name: "keyword-analysis",
+    description: "Keyword performance with match type and quality",
+    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, ad_group.id, ad_group.name, ad_group.status, ad_group_criterion.criterion_id, ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ad_group_criterion.status, ad_group_criterion.quality_info.quality_score, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions, metrics.ctr FROM keyword_view WHERE segments.date DURING {dateRange}{statusScope} ORDER BY metrics.impressions DESC LIMIT {limit}`,
+    defaultDateRange: "LAST_30_DAYS",
+    defaultLimit: 200,
+    statusFields: ["campaign.status", "ad_group.status", "ad_group_criterion.status"]
+  },
+  {
+    name: "keyword-serving",
+    description: "Why a keyword is limited \u2014 Google Ads' 'Eligible (Limited) / Below first page bid' column, with the first-page bid estimate, the current max CPC and quality score",
+    gaqlTemplate: `SELECT campaign.id, campaign.name, ad_group.id, ad_group.name, ad_group_criterion.criterion_id, ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ad_group_criterion.status, ad_group_criterion.primary_status, ad_group_criterion.primary_status_reasons, ad_group_criterion.system_serving_status, ad_group_criterion.approval_status, ad_group_criterion.effective_cpc_bid_micros, ad_group_criterion.effective_cpc_bid_source, ad_group_criterion.position_estimates.first_page_cpc_micros, ad_group_criterion.position_estimates.top_of_page_cpc_micros, ad_group_criterion.quality_info.quality_score, ad_group_criterion.quality_info.creative_quality_score, ad_group_criterion.quality_info.post_click_quality_score, ad_group_criterion.quality_info.search_predicted_ctr FROM ad_group_criterion WHERE ad_group_criterion.type = 'KEYWORD' AND ad_group_criterion.negative = FALSE{statusScope} ORDER BY campaign.name LIMIT {limit}`,
+    defaultDateRange: "ALL_TIME",
+    defaultLimit: 500,
+    statusFields: ["campaign.status", "ad_group.status", "ad_group_criterion.status"]
+  },
+  {
+    name: "positive-keywords",
+    description: "Positive (targeting) keywords only \u2014 excludes negatives",
+    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, ad_group.id, ad_group.name, ad_group.status, ad_group_criterion.criterion_id, ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ad_group_criterion.status, ad_group_criterion.negative FROM ad_group_criterion WHERE ad_group_criterion.type = 'KEYWORD' AND ad_group_criterion.negative = FALSE{statusScope} ORDER BY campaign.name LIMIT {limit}`,
+    defaultDateRange: "ALL_TIME",
+    defaultLimit: 500,
+    statusFields: ["campaign.status", "ad_group.status", "ad_group_criterion.status"]
+  },
+  {
+    name: "negative-keywords",
+    description: "Negative keywords only \u2014 campaign and ad group level",
+    gaqlTemplate: `SELECT campaign.id, campaign.name, ad_group.name, ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ad_group_criterion.negative FROM ad_group_criterion WHERE ad_group_criterion.type = 'KEYWORD' AND ad_group_criterion.negative = TRUE AND campaign.status != 'REMOVED' ORDER BY campaign.name LIMIT {limit}`,
+    defaultDateRange: "ALL_TIME",
+    defaultLimit: 500
+  },
+  {
+    name: "negative-keyword-lists",
+    description: "Shared negative keyword lists and the terms inside them (SharedSet members)",
+    gaqlTemplate: `SELECT shared_set.id, shared_set.name, shared_criterion.keyword.text, shared_criterion.keyword.match_type FROM shared_criterion WHERE shared_set.type = 'NEGATIVE_KEYWORDS' AND shared_set.status = 'ENABLED' ORDER BY shared_set.name LIMIT {limit}`,
+    defaultDateRange: "ALL_TIME",
+    defaultLimit: 500
+  },
+  {
+    name: "negative-list-attachments",
+    description: "Which campaigns each shared negative keyword list is attached to",
+    gaqlTemplate: `SELECT campaign.id, campaign.name, shared_set.id, shared_set.name FROM campaign_shared_set WHERE shared_set.type = 'NEGATIVE_KEYWORDS' AND campaign_shared_set.status = 'ENABLED' ORDER BY campaign.name LIMIT {limit}`,
+    defaultDateRange: "ALL_TIME",
+    defaultLimit: 500
+  },
+  {
+    name: "search-terms",
+    description: "Actual user search queries triggering ads",
+    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, ad_group.name, ad_group.status, search_term_view.search_term, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions FROM search_term_view WHERE segments.date DURING {dateRange}{statusScope} ORDER BY metrics.impressions DESC LIMIT {limit}`,
+    defaultDateRange: "LAST_7_DAYS",
+    defaultLimit: 200,
+    statusFields: ["campaign.status", "ad_group.status"]
+  },
+  {
+    name: "ad-copy-performance",
+    description: "Ad headline and description effectiveness",
+    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, ad_group.status, ad_group_ad.status, ad_group_ad.ad.responsive_search_ad.headlines, ad_group_ad.ad.responsive_search_ad.descriptions, ad_group_ad.ad.final_urls, metrics.impressions, metrics.clicks, metrics.conversions, metrics.ctr FROM ad_group_ad WHERE segments.date DURING {dateRange}{statusScope} ORDER BY metrics.impressions DESC LIMIT {limit}`,
+    defaultDateRange: "LAST_30_DAYS",
+    defaultLimit: 200,
+    statusFields: ["campaign.status", "ad_group.status", "ad_group_ad.status"]
+  },
+  {
+    name: "asset-performance",
+    description: "Performance Max asset performance labels",
+    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, asset_group.name, asset_group.status, asset_group_asset.field_type, asset_group_asset.performance_label, asset.type, asset.text_asset.text, asset.image_asset.full_size.url FROM asset_group_asset WHERE campaign.advertising_channel_type = 'PERFORMANCE_MAX' AND segments.date DURING {dateRange}{statusScope} LIMIT {limit}`,
+    defaultDateRange: "LAST_30_DAYS",
+    defaultLimit: 200,
+    statusFields: ["campaign.status", "asset_group.status"]
+  },
+  {
+    name: "shopping-products",
+    description: "Product-level shopping performance metrics",
+    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, segments.product_title, segments.product_item_id, segments.product_brand, segments.product_type_l1, metrics.clicks, metrics.impressions, metrics.cost_micros, metrics.conversions FROM shopping_performance_view WHERE segments.date DURING {dateRange}{statusScope} ORDER BY metrics.cost_micros DESC LIMIT {limit}`,
+    defaultDateRange: "LAST_30_DAYS",
+    defaultLimit: 200,
+    statusFields: ["campaign.status"]
+  },
+  {
+    name: "account-summary",
+    description: "Account-level totals for a date range",
+    gaqlTemplate: `SELECT customer.id, customer.descriptive_name, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions, metrics.conversions_value FROM customer WHERE segments.date DURING {dateRange} LIMIT 1`,
+    defaultDateRange: "LAST_30_DAYS",
+    defaultLimit: 1
+  }
+];
+function getPreset(name) {
+  return PRESETS.find((p) => p.name === name);
+}
+function buildStatusScope(statusFields, includePaused) {
+  if (!statusFields || statusFields.length === 0) return "";
+  const predicate = includePaused ? "!= 'REMOVED'" : "= 'ENABLED'";
+  return statusFields.map((field) => ` AND ${field} ${predicate}`).join("");
+}
+function expandPreset(preset, params) {
+  const dateRange = params.dateRange ?? preset.defaultDateRange;
+  const limit = params.limit ?? preset.defaultLimit;
+  if (!isValidDateRange(dateRange)) {
+    return {
+      query: "",
+      dateRangeError: `Invalid date range: "${dateRange}". Use a GAQL date literal (e.g. LAST_30_DAYS, TODAY) or BETWEEN 'YYYY-MM-DD' AND 'YYYY-MM-DD'.`
+    };
+  }
+  const statusScope = buildStatusScope(preset.statusFields, params.includePaused ?? false);
+  const query = preset.gaqlTemplate.replace(/\{dateRange\}/g, dateRange).replace(/\{limit\}/g, String(limit)).replace(/\{statusScope\}/g, statusScope);
+  return { query };
+}
+
 // src/commands/ads/google/preflight.ts
 function buildCommand2(query, customerId) {
   return `baker ads google query "${query}" --customer-id ${customerId}`;
 }
+var RUNG_PIN_FIELDS = {
+  "campaign.status": ["campaign.id", "campaign.resource_name"],
+  "ad_group.status": ["ad_group.id", "ad_group.resource_name"],
+  "ad_group_criterion.status": ["ad_group_criterion.criterion_id", "ad_group_criterion.resource_name"],
+  "ad_group_ad.status": ["ad_group_ad.ad.id", "ad_group_ad.resource_name"],
+  "asset_group.status": ["asset_group.id", "asset_group.resource_name"]
+};
+function whereClause(query) {
+  const match = query.match(/\bWHERE\b([\s\S]*)$/i);
+  if (!match?.[1]) return "";
+  let rest = match[1];
+  for (const trailing of [/\bORDER\s+BY\b/i, /\bLIMIT\b/i, /\bPARAMETERS\b/i]) {
+    const idx = rest.search(trailing);
+    if (idx !== -1) rest = rest.slice(0, idx);
+  }
+  return rest;
+}
+function selectClause(query) {
+  return query.split(/\bFROM\b/i)[0] ?? "";
+}
+function mentions(clause, field) {
+  return new RegExp(`(?<![\\w.])${field.replace(/\./g, "\\.")}\\b`, "i").test(clause);
+}
+function analyzeServingChain(query) {
+  const resource = fromResource(query);
+  const chain = resource ? SERVING_CHAINS[resource] : void 0;
+  if (!chain) return null;
+  const where = whereClause(query);
+  if (/ad_group_criterion\.negative\s*=\s*TRUE/i.test(where)) return null;
+  const unscoped = chain.filter((rung) => {
+    if (mentions(where, rung)) return false;
+    return !(RUNG_PIN_FIELDS[rung] ?? []).some((pin) => mentions(where, pin));
+  });
+  const assertsServing = chain.some(
+    (rung) => new RegExp(`${rung.replace(/\./g, "\\.")}\\s*=\\s*'ENABLED'`, "i").test(where)
+  );
+  return { chain, unscoped, assertsServing };
+}
+function rejectPartialChain(query, customerId, analysis) {
+  if (!analysis.assertsServing || analysis.unscoped.length === 0) return null;
+  const added = analysis.unscoped.map((rung) => `${rung} = 'ENABLED'`).join(" AND ");
+  const fixed = query.replace(/\bWHERE\b/i, `WHERE ${added} AND`);
+  return {
+    ok: false,
+    error: {
+      code: "INCOMPLETE_STATUS_CHAIN",
+      message: `This query filters on serving status but leaves ${analysis.unscoped.join(", ")} unscoped. Google Ads has no single serving flag \u2014 a row is live only when its whole chain (${analysis.chain.join(" \u2192 ")}) is ENABLED, so rows under a paused parent will come back looking live.`,
+      fix: {
+        action: "retry_with_modified_query",
+        correctedCommand: buildCommand2(fixed, customerId),
+        explanation: `Add the missing rungs: ${added}. To look at paused entities on purpose, scope every rung explicitly instead (e.g. ${analysis.unscoped.map((rung) => `${rung} != 'REMOVED'`).join(" AND ")}), or use --preset ... --include-paused.`
+      },
+      retryable: false
+    }
+  };
+}
+function annotateUnscopedChain(query, analysis) {
+  if (analysis.assertsServing || analysis.unscoped.length === 0) return { query, warnings: [] };
+  const select = selectClause(query);
+  const missing = analysis.unscoped.filter((rung) => !mentions(select, rung));
+  if (missing.length === 0) return { query, warnings: [] };
+  return {
+    query: query.replace(/SELECT\s+/i, `SELECT ${missing.join(", ")}, `),
+    warnings: [
+      {
+        code: "SERVING_STATUS_ADDED",
+        message: `Added ${missing.join(", ")} to SELECT \u2014 this query does not scope ${analysis.unscoped.join(", ")}, so it returns paused-parent rows that are not serving. Read those columns before calling any row live; filter every rung = 'ENABLED' to get serving rows only.`
+      }
+    ]
+  };
+}
 var SINGLE_ROW_RESOURCES = ["customer"];
 function fromResource(query) {
   const match = query.match(/\bFROM\s+([A-Za-z_][A-Za-z0-9_]*)/i);
@@ -10641,10 +10859,10 @@ function isSingleRowRead(query) {
 }
 function addRequiredCampaignFields(query) {
   if (!/FROM\s+campaign_budget\b/i.test(query)) return { query, warnings: [] };
-  const whereClause2 = query.split(/\bWHERE\b/i)[1] ?? "";
-  const selectClause = query.split(/\bFROM\b/i)[0] ?? "";
-  const selectFields = new Set(selectClause.match(/campaign\.[\w.]+/g) ?? []);
-  const missing = [...new Set(whereClause2.match(/campaign\.[\w.]+/g) ?? [])].filter(
+  const whereClause3 = query.split(/\bWHERE\b/i)[1] ?? "";
+  const selectClause2 = query.split(/\bFROM\b/i)[0] ?? "";
+  const selectFields = new Set(selectClause2.match(/campaign\.[\w.]+/g) ?? []);
+  const missing = [...new Set(whereClause3.match(/campaign\.[\w.]+/g) ?? [])].filter(
     (field) => !selectFields.has(field)
   );
   if (missing.length === 0) return { query, warnings: [] };
@@ -10794,128 +11012,13 @@ function validatePreflight(query, customerId, limit) {
   }
   const { query: autoFixed, warnings: autoFixWarnings } = applyAutoFixes(corrected, limit);
   warnings.push(...autoFixWarnings);
-  return { valid: true, correctedQuery: autoFixed, warnings };
-}
-
-// src/commands/ads/google/presets.ts
-var GAQL_DATE_RANGE_RE = /^(?:TODAY|YESTERDAY|LAST_7_DAYS|LAST_14_DAYS|LAST_30_DAYS|LAST_90_DAYS|THIS_MONTH|LAST_MONTH|THIS_QUARTER|LAST_QUARTER|THIS_YEAR|LAST_YEAR|ALL_TIME|BETWEEN\s+'[0-9]{4}-[0-9]{2}-[0-9]{2}'\s+AND\s+'[0-9]{4}-[0-9]{2}-[0-9]{2}')$/i;
-function isValidDateRange(value) {
-  return GAQL_DATE_RANGE_RE.test(value.trim());
-}
-var PRESETS = [
-  {
-    name: "campaign-performance",
-    description: "Campaign-level metrics overview",
-    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, campaign.advertising_channel_type, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions, metrics.conversions_value, metrics.ctr, metrics.average_cpc FROM campaign WHERE segments.date DURING {dateRange}{statusScope} ORDER BY metrics.cost_micros DESC LIMIT {limit}`,
-    defaultDateRange: "LAST_30_DAYS",
-    defaultLimit: 200,
-    statusFields: ["campaign.status"]
-  },
-  {
-    name: "keyword-analysis",
-    description: "Keyword performance with match type and quality",
-    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, ad_group.id, ad_group.name, ad_group.status, ad_group_criterion.criterion_id, ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ad_group_criterion.status, ad_group_criterion.quality_info.quality_score, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions, metrics.ctr FROM keyword_view WHERE segments.date DURING {dateRange}{statusScope} ORDER BY metrics.impressions DESC LIMIT {limit}`,
-    defaultDateRange: "LAST_30_DAYS",
-    defaultLimit: 200,
-    statusFields: ["campaign.status", "ad_group.status", "ad_group_criterion.status"]
-  },
-  {
-    name: "keyword-serving",
-    description: "Why a keyword is limited \u2014 Google Ads' 'Eligible (Limited) / Below first page bid' column, with the first-page bid estimate, the current max CPC and quality score",
-    gaqlTemplate: `SELECT campaign.id, campaign.name, ad_group.id, ad_group.name, ad_group_criterion.criterion_id, ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ad_group_criterion.status, ad_group_criterion.primary_status, ad_group_criterion.primary_status_reasons, ad_group_criterion.system_serving_status, ad_group_criterion.approval_status, ad_group_criterion.effective_cpc_bid_micros, ad_group_criterion.effective_cpc_bid_source, ad_group_criterion.position_estimates.first_page_cpc_micros, ad_group_criterion.position_estimates.top_of_page_cpc_micros, ad_group_criterion.quality_info.quality_score, ad_group_criterion.quality_info.creative_quality_score, ad_group_criterion.quality_info.post_click_quality_score, ad_group_criterion.quality_info.search_predicted_ctr FROM ad_group_criterion WHERE ad_group_criterion.type = 'KEYWORD' AND ad_group_criterion.negative = FALSE{statusScope} ORDER BY campaign.name LIMIT {limit}`,
-    defaultDateRange: "ALL_TIME",
-    defaultLimit: 500,
-    statusFields: ["campaign.status", "ad_group.status", "ad_group_criterion.status"]
-  },
-  {
-    name: "positive-keywords",
-    description: "Positive (targeting) keywords only \u2014 excludes negatives",
-    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, ad_group.id, ad_group.name, ad_group.status, ad_group_criterion.criterion_id, ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ad_group_criterion.status, ad_group_criterion.negative FROM ad_group_criterion WHERE ad_group_criterion.type = 'KEYWORD' AND ad_group_criterion.negative = FALSE{statusScope} ORDER BY campaign.name LIMIT {limit}`,
-    defaultDateRange: "ALL_TIME",
-    defaultLimit: 500,
-    statusFields: ["campaign.status", "ad_group.status", "ad_group_criterion.status"]
-  },
-  {
-    name: "negative-keywords",
-    description: "Negative keywords only \u2014 campaign and ad group level",
-    gaqlTemplate: `SELECT campaign.id, campaign.name, ad_group.name, ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ad_group_criterion.negative FROM ad_group_criterion WHERE ad_group_criterion.type = 'KEYWORD' AND ad_group_criterion.negative = TRUE AND campaign.status != 'REMOVED' ORDER BY campaign.name LIMIT {limit}`,
-    defaultDateRange: "ALL_TIME",
-    defaultLimit: 500
-  },
-  {
-    name: "negative-keyword-lists",
-    description: "Shared negative keyword lists and the terms inside them (SharedSet members)",
-    gaqlTemplate: `SELECT shared_set.id, shared_set.name, shared_criterion.keyword.text, shared_criterion.keyword.match_type FROM shared_criterion WHERE shared_set.type = 'NEGATIVE_KEYWORDS' AND shared_set.status = 'ENABLED' ORDER BY shared_set.name LIMIT {limit}`,
-    defaultDateRange: "ALL_TIME",
-    defaultLimit: 500
-  },
-  {
-    name: "negative-list-attachments",
-    description: "Which campaigns each shared negative keyword list is attached to",
-    gaqlTemplate: `SELECT campaign.id, campaign.name, shared_set.id, shared_set.name FROM campaign_shared_set WHERE shared_set.type = 'NEGATIVE_KEYWORDS' AND campaign_shared_set.status = 'ENABLED' ORDER BY campaign.name LIMIT {limit}`,
-    defaultDateRange: "ALL_TIME",
-    defaultLimit: 500
-  },
-  {
-    name: "search-terms",
-    description: "Actual user search queries triggering ads",
-    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, ad_group.name, ad_group.status, search_term_view.search_term, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions FROM search_term_view WHERE segments.date DURING {dateRange}{statusScope} ORDER BY metrics.impressions DESC LIMIT {limit}`,
-    defaultDateRange: "LAST_7_DAYS",
-    defaultLimit: 200,
-    statusFields: ["campaign.status", "ad_group.status"]
-  },
-  {
-    name: "ad-copy-performance",
-    description: "Ad headline and description effectiveness",
-    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, ad_group.status, ad_group_ad.status, ad_group_ad.ad.responsive_search_ad.headlines, ad_group_ad.ad.responsive_search_ad.descriptions, ad_group_ad.ad.final_urls, metrics.impressions, metrics.clicks, metrics.conversions, metrics.ctr FROM ad_group_ad WHERE segments.date DURING {dateRange}{statusScope} ORDER BY metrics.impressions DESC LIMIT {limit}`,
-    defaultDateRange: "LAST_30_DAYS",
-    defaultLimit: 200,
-    statusFields: ["campaign.status", "ad_group.status", "ad_group_ad.status"]
-  },
-  {
-    name: "asset-performance",
-    description: "Performance Max asset performance labels",
-    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, asset_group.name, asset_group.status, asset_group_asset.field_type, asset_group_asset.performance_label, asset.type, asset.text_asset.text, asset.image_asset.full_size.url FROM asset_group_asset WHERE campaign.advertising_channel_type = 'PERFORMANCE_MAX' AND segments.date DURING {dateRange}{statusScope} LIMIT {limit}`,
-    defaultDateRange: "LAST_30_DAYS",
-    defaultLimit: 200,
-    statusFields: ["campaign.status", "asset_group.status"]
-  },
-  {
-    name: "shopping-products",
-    description: "Product-level shopping performance metrics",
-    gaqlTemplate: `SELECT campaign.id, campaign.name, campaign.status, segments.product_title, segments.product_item_id, segments.product_brand, segments.product_type_l1, metrics.clicks, metrics.impressions, metrics.cost_micros, metrics.conversions FROM shopping_performance_view WHERE segments.date DURING {dateRange}{statusScope} ORDER BY metrics.cost_micros DESC LIMIT {limit}`,
-    defaultDateRange: "LAST_30_DAYS",
-    defaultLimit: 200,
-    statusFields: ["campaign.status"]
-  },
-  {
-    name: "account-summary",
-    description: "Account-level totals for a date range",
-    gaqlTemplate: `SELECT customer.id, customer.descriptive_name, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions, metrics.conversions_value FROM customer WHERE segments.date DURING {dateRange} LIMIT 1`,
-    defaultDateRange: "LAST_30_DAYS",
-    defaultLimit: 1
-  }
-];
-function getPreset(name) {
-  return PRESETS.find((p) => p.name === name);
-}
-function buildStatusScope(statusFields, includePaused) {
-  if (!statusFields || statusFields.length === 0) return "";
-  const predicate = includePaused ? "!= 'REMOVED'" : "= 'ENABLED'";
-  return statusFields.map((field) => ` AND ${field} ${predicate}`).join("");
-}
-function expandPreset(preset, params) {
-  const dateRange = params.dateRange ?? preset.defaultDateRange;
-  const limit = params.limit ?? preset.defaultLimit;
-  if (!isValidDateRange(dateRange)) {
-    return {
-      query: "",
-      dateRangeError: `Invalid date range: "${dateRange}". Use a GAQL date literal (e.g. LAST_30_DAYS, TODAY) or BETWEEN 'YYYY-MM-DD' AND 'YYYY-MM-DD'.`
-    };
-  }
-  const statusScope = buildStatusScope(preset.statusFields, params.includePaused ?? false);
-  const query = preset.gaqlTemplate.replace(/\{dateRange\}/g, dateRange).replace(/\{limit\}/g, String(limit)).replace(/\{statusScope\}/g, statusScope);
-  return { query };
+  const analysis = analyzeServingChain(autoFixed);
+  if (!analysis) return { valid: true, correctedQuery: autoFixed, warnings };
+  const rejection = rejectPartialChain(autoFixed, customerId, analysis);
+  if (rejection) return { valid: false, warnings: [], error: rejection };
+  const annotated = annotateUnscopedChain(autoFixed, analysis);
+  warnings.push(...annotated.warnings);
+  return { valid: true, correctedQuery: annotated.query, warnings };
 }
 
 // src/commands/ads/google/query.ts
@@ -10944,12 +11047,17 @@ registerSchema({
       description: "Include paused entities in preset results. Off by default: presets return only actually-serving entities. Google Ads has no single serving flag \u2014 an entity serves only when its whole chain (campaign, ad group, ad) is ENABLED, so recommendations should target serving entities unless the user asks about paused ones.",
       required: false
     },
-    limit: { type: "number", description: "Max rows (default 200)", required: false, default: 200 },
+    limit: {
+      type: "number",
+      description: "Max rows in ONE page (default 200), AND the LIMIT added to a query that has none \u2014 so it caps the whole read with --all too. Values up to 10000 are accepted. Any read that fills this cap comes back flagged TRUNCATED_RESULTS \u2014 never count or total from one.",
+      required: false,
+      default: 200
+    },
     "list-presets": { type: "boolean", description: "List all available query presets", required: false },
     cursor: { type: "string", description: "Pagination cursor from previous response", required: false },
     all: {
       type: "boolean",
-      description: "Auto-paginate all results (use with --out for large datasets)",
+      description: "Follow every page until the data set is exhausted (use with --out for large datasets). Needed for a read you may count or total, but not sufficient: it exhausts the pages, not the statement's LIMIT, so pair it with a --limit above the row count you expect (or your own LIMIT) and check the read came back without TRUNCATED_RESULTS.",
       required: false
     },
     out: {
@@ -11004,53 +11112,117 @@ function writeRowsToFile(filePath, rows, fields, append) {
     writeFileSync(filePath, JSON.stringify(rows, null, 2), "utf-8");
   }
 }
+function effectiveRowLimit(finalQuery, limit, all = false) {
+  const match = finalQuery.match(/\bLIMIT\s+(\d+)/i);
+  const statementLimit = match?.[1] ? Number(match[1]) : void 0;
+  if (all) return statementLimit;
+  return statementLimit === void 0 ? limit : Math.min(limit, statementLimit);
+}
+function warningLines(warnings, format) {
+  return warnings.map((w) => {
+    const message = w.message.replace(/\s*\n\s*/g, " ");
+    if (format === "jsonl") return JSON.stringify({ _baker_warning: { code: w.code, message } });
+    if (format === "md") return `> **${w.code}** \u2014 ${message}`;
+    return `# baker ${w.code}: ${message}`;
+  });
+}
+function completenessWarnings(read) {
+  const cap3 = read.effectiveLimit;
+  const filledTheCap = cap3 !== void 0 && cap3 > 0 && read.rowCount >= cap3;
+  if (!read.hasMore && !filledTheCap) return [];
+  const cause = read.hasMore ? `More rows are waiting: the account returned a next-page cursor this run did not follow.` : `The ${read.rowCount} rows returned exactly fill the row cap in force (${cap3}).`;
+  const fix = read.all ? `Every page was followed, so the cap is the LIMIT in the statement itself \u2014 raise it above ${cap3}, or drop it and pass a larger --limit, then re-run.` : `Re-run with --all --out <file> to page through everything, or raise --limit above ${cap3}.`;
+  return [
+    {
+      code: "TRUNCATED_RESULTS",
+      message: `INCOMPLETE READ \u2014 ${cause} These rows are a page, not the data set. Do NOT count, total or describe them as the whole picture. ${fix}`
+    }
+  ];
+}
 function buildQueryEnvelope(rows, fieldDescs, warnings, options) {
-  const envelope = { ok: true, data: rows };
-  if (options.full && Object.keys(fieldDescs).length > 0) {
-    envelope.fields = fieldDescs;
-  }
-  if (options.nextCursor) {
-    envelope.pagination = { hasMore: true, cursor: options.nextCursor };
-  }
-  if (warnings.length > 0) {
-    envelope.warnings = warnings;
-  }
-  if (options.cached) {
-    envelope.cached = true;
-  }
-  return envelope;
+  const notice = summariseWarnings(warnings);
+  return {
+    ok: true,
+    ...options.cached ? { cached: true } : {},
+    ...warnings.length > 0 ? { warnings } : {},
+    ...options.nextCursor ? { pagination: { hasMore: true, cursor: options.nextCursor } } : {},
+    data: rows,
+    ...options.full && Object.keys(fieldDescs).length > 0 ? { fields: fieldDescs } : {},
+    ...notice ? { notice } : {}
+  };
 }
-function outputResults(rows, fieldDescs, warnings, args, cached, nextCursor) {
-  const format = args.output || "json";
-  const fields = Object.keys(rows[0] ?? {});
-  if (format === "csv") {
-    process.stdout.write(`${toCsvRow(fields)}
-`);
-    for (const row of rows) {
-      process.stdout.write(`${toCsvRow(fields.map((f) => String(row[f] ?? "")))}
+function summariseWarnings(warnings) {
+  if (warnings.length === 0) return void 0;
+  const codes = [...new Set(warnings.map((w) => w.code))].join(", ");
+  return `Read the "warnings" above before using these rows: ${codes}.`;
+}
+function buildFileSummary(input) {
+  const notice = summariseWarnings(input.warnings);
+  return {
+    ok: true,
+    fields: {},
+    file: input.file,
+    rows: input.rows,
+    complete: input.complete,
+    ...input.warnings.length > 0 ? { warnings: input.warnings } : {},
+    ...notice ? { notice } : {}
+  };
+}
+var REPEAT_NOTICE_ABOVE_ROWS = 20;
+function emitToStderr(notices) {
+  for (const line of notices) process.stderr.write(`${line}
 `);
-    }
-    return;
-  }
-  if (format === "jsonl") {
-    for (const row of rows) {
-      process.stdout.write(`${JSON.stringify(row)}
+}
+function writeLine(line) {
+  process.stdout.write(`${line}
 `);
-    }
-    return;
+}
+var writeCsvRows = (rows, fields, notices) => {
+  writeLine(toCsvRow(fields));
+  for (const line of notices) writeLine(line);
+  for (const row of rows) writeLine(toCsvRow(fields.map((f) => String(row[f] ?? ""))));
+};
+var writeJsonlRows = (rows, _fields, notices) => {
+  for (const line of notices) writeLine(line);
+  for (const row of rows) writeLine(JSON.stringify(row));
+};
+var writeMdRows = (rows, fields, notices) => {
+  for (const line of notices) writeLine(line);
+  writeLine(`| ${fields.join(" | ")} |`);
+  writeLine(`| ${fields.map(() => "---").join(" | ")} |`);
+  for (const row of rows) writeLine(`| ${fields.map((f) => String(row[f] ?? "")).join(" | ")} |`);
+};
+var ROW_WRITERS = { csv: writeCsvRows, jsonl: writeJsonlRows, md: writeMdRows };
+function writeRows(format, rows, notices) {
+  const write2 = ROW_WRITERS[format] ?? writeMdRows;
+  write2(rows, Object.keys(rows[0] ?? {}), notices);
+  if (rows.length > REPEAT_NOTICE_ABOVE_ROWS) {
+    for (const line of notices) writeLine(line);
   }
-  if (format === "md") {
-    process.stdout.write(`| ${fields.join(" | ")} |
-`);
-    process.stdout.write(`| ${fields.map(() => "---").join(" | ")} |
-`);
-    for (const row of rows) {
-      process.stdout.write(`| ${fields.map((f) => String(row[f] ?? "")).join(" | ")} |
-`);
-    }
+}
+function outputResults(rows, fieldDescs, warnings, args, cached, read) {
+  const format = args.output || "json";
+  const allWarnings = [
+    ...warnings,
+    ...completenessWarnings({
+      rowCount: rows.length,
+      effectiveLimit: read.effectiveLimit,
+      all: read.all,
+      hasMore: Boolean(read.nextCursor)
+    })
+  ];
+  emitToStderr(warningLines(allWarnings, "csv"));
+  if (format === "json") {
+    writeAdsJson(
+      buildQueryEnvelope(rows, fieldDescs, allWarnings, {
+        full: Boolean(args.full),
+        cached,
+        nextCursor: read.nextCursor
+      })
+    );
     return;
   }
-  writeAdsJson(buildQueryEnvelope(rows, fieldDescs, warnings, { full: Boolean(args.full), cached, nextCursor }));
+  writeRows(format, rows, warningLines(allWarnings, format));
 }
 function resolveGaql(args, limit) {
   if (args.preset) {
@@ -11099,8 +11271,8 @@ var SERVING_HIERARCHY_RESOURCES = [
   "search_term_view",
   "shopping_performance_view",
   "asset_group_asset"
-];
-function whereClause(upperQuery) {
+].filter((resource) => !(resource in SERVING_CHAINS));
+function whereClause2(upperQuery) {
   const whereIdx = upperQuery.indexOf(" WHERE ");
   if (whereIdx === -1) return "";
   let rest = upperQuery.slice(whereIdx + 7);
@@ -11124,7 +11296,7 @@ function servingScopeWarnings(args, finalQuery) {
   const fromMatch = upper2.match(/\bFROM\s+([A-Z_]+)/);
   const resource = fromMatch?.[1]?.toLowerCase();
   const hierarchical = resource ? SERVING_HIERARCHY_RESOURCES.includes(resource) : false;
-  const filtersStatus = whereClause(upper2).includes(".STATUS");
+  const filtersStatus = whereClause2(upper2).includes(".STATUS");
   if (hierarchical && !filtersStatus) {
     return [
       {
@@ -11141,11 +11313,12 @@ function parseSelectedFields(gaql) {
   if (!list) return [];
   return list.split(",").map((field) => field.trim()).filter((field) => /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z0-9_]+)*$/.test(field));
 }
-function unobservedSelectedFields(gaql, rows) {
-  const observed = /* @__PURE__ */ new Set();
+function foldObservedFields(rows, observed) {
   for (const row of rows) {
     for (const key of Object.keys(row)) observed.add(key);
   }
+}
+function unobservedFields(gaql, observed) {
   return parseSelectedFields(gaql).filter((field) => {
     if (field.endsWith(".resource_name")) return false;
     if (observed.has(field)) return false;
@@ -11153,8 +11326,13 @@ function unobservedSelectedFields(gaql, rows) {
   });
 }
 function missingFieldWarnings(gaql, rows) {
-  if (rows.length === 0) return [];
-  const missing = unobservedSelectedFields(gaql, rows);
+  const observed = /* @__PURE__ */ new Set();
+  foldObservedFields(rows, observed);
+  return missingFieldWarningsFor(gaql, observed, rows.length);
+}
+function missingFieldWarningsFor(gaql, observed, rowCount2) {
+  if (rowCount2 === 0) return [];
+  const missing = unobservedFields(gaql, observed);
   if (missing.length === 0) return [];
   return [
     {
@@ -11171,6 +11349,7 @@ async function fetchAllPages(body, args, servingOptions) {
   let pageToken = args.cursor;
   let totalRowsWritten = 0;
   let keywordLimits;
+  const observedFields = /* @__PURE__ */ new Set();
   do {
     const requestBody2 = { ...body };
     if (pageToken) requestBody2.pageToken = pageToken;
@@ -11178,11 +11357,11 @@ async function fetchAllPages(body, args, servingOptions) {
     const rows = response.rows ?? [];
     pageToken = response.pageToken;
     if (args.out) {
-      const filePath = resolve(args.out);
       const shouldAppend = args.append || totalRowsWritten > 0;
-      writeRowsToFile(filePath, rows, extractFields(rows), shouldAppend);
+      writeRowsToFile(resolve(args.out), rows, extractFields(rows), shouldAppend);
       totalRowsWritten += rows.length;
       keywordLimits = collectKeywordLimits(rows, servingOptions, keywordLimits);
+      foldObservedFields(rows, observedFields);
     } else {
       allRows = allRows.concat(rows);
     }
@@ -11192,7 +11371,8 @@ async function fetchAllPages(body, args, servingOptions) {
     allRows,
     lastPageToken: pageToken,
     totalRowsWritten,
-    keywordLimits: keywordLimits ?? collectKeywordLimits([], servingOptions)
+    keywordLimits: keywordLimits ?? collectKeywordLimits([], servingOptions),
+    observedFields
   };
 }
 async function executeQuery(finalQuery, args, customerId, limit, warnings, useCache, cacheKey) {
@@ -11202,12 +11382,33 @@ async function executeQuery(finalQuery, args, customerId, limit, warnings, useCa
   if (args.cursor) body.pageToken = args.cursor;
   if (!useCache) body.skipCache = true;
   const servingOptions = keywordServingOptions(finalQuery);
-  const { allRows, lastPageToken, totalRowsWritten, keywordLimits } = await fetchAllPages(body, args, servingOptions);
+  const { allRows, lastPageToken, totalRowsWritten, keywordLimits, observedFields } = await fetchAllPages(
+    body,
+    args,
+    servingOptions
+  );
   if (args.out) {
-    const summary = { ok: true, fields: {}, file: resolve(args.out), rows: totalRowsWritten };
-    const limitWarnings = renderKeywordLimits(keywordLimits);
-    if (limitWarnings.length > 0) summary.warnings = limitWarnings;
-    writeAdsJson(summary);
+    const truncation = completenessWarnings({
+      rowCount: totalRowsWritten,
+      effectiveLimit: effectiveRowLimit(finalQuery, limit, Boolean(args.all)),
+      all: Boolean(args.all),
+      hasMore: Boolean(lastPageToken)
+    });
+    const fileWarnings = [
+      ...warnings,
+      ...renderKeywordLimits(keywordLimits),
+      ...missingFieldWarningsFor(finalQuery, observedFields, totalRowsWritten),
+      ...truncation
+    ];
+    emitToStderr(warningLines(fileWarnings, "csv"));
+    writeAdsJson(
+      buildFileSummary({
+        file: resolve(args.out),
+        rows: totalRowsWritten,
+        warnings: fileWarnings,
+        complete: truncation.length === 0
+      })
+    );
     return;
   }
   if (useCache && allRows.length > 0) {
@@ -11221,9 +11422,16 @@ async function executeQuery(finalQuery, args, customerId, limit, warnings, useCa
     [...warnings, ...missingFieldWarnings(finalQuery, allRows), ...keywordServingWarnings(allRows, servingOptions)],
     args,
     false,
-    lastPageToken
+    {
+      effectiveLimit: effectiveRowLimit(finalQuery, limit, Boolean(args.all)),
+      all: Boolean(args.all),
+      nextCursor: lastPageToken
+    }
   );
 }
+function shouldReadCache(args) {
+  return !args["no-cache"] && !args.out;
+}
 async function validateArgs(args) {
   const customerId = await resolveCustomerId(args);
   const limit = args.limit ? Number(args.limit) : 200;
@@ -11286,10 +11494,14 @@ Examples:
       description: "Include paused entities in preset results (default: serving entities only)",
       required: false
     },
-    limit: { type: "string", description: "Max rows (default 200)", required: false },
+    limit: {
+      type: "string",
+      description: "Max rows in one page (default 200); without --all the read stops there",
+      required: false
+    },
     "list-presets": { type: "boolean", description: "List available presets", required: false },
     cursor: { type: "string", description: "Pagination cursor", required: false },
-    all: { type: "boolean", description: "Auto-paginate all results", required: false },
+    all: { type: "boolean", description: "Follow every page (use with --out for large datasets)", required: false },
     out: { type: "string", description: "File path for output", required: false },
     append: { type: "boolean", description: "Append to file", required: false },
     output: { type: "string", description: "Format: json|csv|jsonl|md", required: false, default: "json" },
@@ -11313,7 +11525,7 @@ Examples:
     const validated = await validateArgs(args);
     if (!validated) return;
     const { customerId, limit, finalQuery, warnings, useCache, cacheKey } = validated;
-    if (useCache) {
+    if (shouldReadCache(args)) {
       const cached = cacheGet("queries", cacheKey);
       if (cached) {
         const fields = extractFields(cached.data);
@@ -11326,7 +11538,8 @@ Examples:
             ...keywordServingWarnings(cached.data, keywordServingOptions(finalQuery))
           ],
           args,
-          true
+          true,
+          { effectiveLimit: effectiveRowLimit(finalQuery, limit, Boolean(args.all)), all: Boolean(args.all) }
         );
         return;
       }
@@ -13402,9 +13615,16 @@ var customerIdArg = { "customer-id": { type: "string", description: "10-digit Go
 var fileArg = {
   file: { type: "string", description: "JSON file with the full op payload (flags override)" }
 };
+var BUDGET_DEMAND_HINTS = [
+  "Check this daily budget against the search volume you measured for these keywords, not against the plan you had before you measured it. A budget many times larger than the traffic the target pool can absorb never spends, and reads to the client as a number nobody costed.",
+  "No volume measured yet? Pull it first \u2014 `baker ads google query --preset search-terms` for what the account already captures, `baker ads google keywords metrics` for the market estimate (those are planner figures, never account performance)."
+];
 var budgetsCommand = defineCommand30({
   meta: { name: "budgets", description: "Stage campaign budget create/update" },
   subCommands: {
+    // Fires where the budget is actually set, rather than on whatever the chat happened to stage
+    // first. A budget several times what the target pool can absorb never spends, and reads to the
+    // client as a plan nobody costed.
     create: defineCommand30({
       meta: { name: "create", description: "Stage a campaign budget" },
       args: {
@@ -13423,7 +13643,7 @@ var budgetsCommand = defineCommand30({
           deliveryMethod: args.delivery,
           explicitlyShared: args.shared || void 0
         });
-        await stageCreate("google.budget.create", customerId, payload);
+        await stageCreate("google.budget.create", customerId, payload, BUDGET_DEMAND_HINTS);
       }
     }),
     update: defineCommand30({
@@ -13443,7 +13663,7 @@ var budgetsCommand = defineCommand30({
           amountMicros: microsFlag(args.amount, "--amount"),
           deliveryMethod: args.delivery
         });
-        await stageUpdate("google.budget.update", customerId, target, payload);
+        await stageUpdate("google.budget.update", customerId, target, payload, BUDGET_DEMAND_HINTS);
       }
     })
   }
@@ -14916,19 +15136,19 @@ function failWriteValidation2(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg2(path40) {
-  if (typeof path40 !== "string" || path40.length === 0) {
+function loadJsonFileArg2(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync4(path40, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path38, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation2(`${path40} must contain a JSON object`);
+      failWriteValidation2(`${path38} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation2(`${path40} is not valid JSON: ${err.message}`);
+      failWriteValidation2(`${path38} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -15013,15 +15233,15 @@ function parseLocaleFlag(value) {
   }
   return { language: match[1], country: match[2].toUpperCase() };
 }
-function loadTargetingFileArg(path40) {
-  if (typeof path40 !== "string" || path40.length === 0) {
+function loadTargetingFileArg(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg2(path40);
+  const parsed = loadJsonFileArg2(path38);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
     failWriteValidation2(
-      `${path40} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+      `${path38} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
   return criteria;
@@ -15056,14 +15276,14 @@ function parseCsvLine(line) {
   cells.push(current);
   return cells.map((cell2) => cell2.trim());
 }
-function parseListFileArg(path40, maxRows) {
-  if (typeof path40 !== "string" || path40.length === 0) {
+function parseListFileArg(path38, maxRows) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return void 0;
   }
-  const raw = readFileSync4(path40, "utf8");
+  const raw = readFileSync4(path38, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation2(`${path40} needs a header row and at least one data row`);
+    failWriteValidation2(`${path38} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -15082,7 +15302,7 @@ function parseListFileArg(path40, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation2(`${path40} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation2(`${path38} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -15178,11 +15398,11 @@ function readPositionals(args) {
 function splitIdList(raw) {
   return raw.split(",").map((id) => id.trim()).filter(Boolean);
 }
-function idsFileEntries(path40) {
-  if (typeof path40 !== "string" || path40.length === 0) {
+function idsFileEntries(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return [];
   }
-  return readFileSync4(path40, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+  return readFileSync4(path38, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
 }
 function requireTargets(args, entity) {
   const positionals = readPositionals(args);
@@ -17803,9 +18023,9 @@ function compactRow(row) {
     ...destination.postUrn ? { postUrn: destination.postUrn } : {}
   };
 }
-function readPath(row, path40) {
+function readPath(row, path38) {
   let current = row;
-  for (const segment of path40.split(".")) {
+  for (const segment of path38.split(".")) {
     const record = asRecord2(current);
     if (!record) return void 0;
     current = record[segment];
@@ -17815,10 +18035,10 @@ function readPath(row, path40) {
 function projectFields(rows, paths) {
   return rows.map((row) => {
     const projected = {};
-    for (const path40 of paths) {
-      const value = readPath(row, path40);
+    for (const path38 of paths) {
+      const value = readPath(row, path38);
       if (value !== void 0) {
-        projected[path40] = value;
+        projected[path38] = value;
       }
     }
     return projected;
@@ -19118,11 +19338,11 @@ var updateStatusSchema = z25.enum(UPDATE_STATUSES);
 function currencyMinimums2(currencyCode) {
   return CURRENCY_MINIMUMS2[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM2;
 }
-function validateDailyBudgetFloor(money, ctx, path40) {
+function validateDailyBudgetFloor(money, ctx, path38) {
   if (money?.currencyCode) {
     const min = currencyMinimums2(money.currencyCode).dailyBudgetMin;
     if (Number(money.amount) < min) {
-      ctx.addIssue({ code: "custom", path: path40, message: `below the ${min} ${money.currencyCode} daily minimum` });
+      ctx.addIssue({ code: "custom", path: path38, message: `below the ${min} ${money.currencyCode} daily minimum` });
     }
   }
 }
@@ -19791,19 +20011,19 @@ function failWriteValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg3(path40) {
-  if (typeof path40 !== "string" || path40.length === 0) {
+function loadJsonFileArg3(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path40, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path38, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation3(`${path40} must contain a JSON object`);
+      failWriteValidation3(`${path38} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation3(`${path40} is not valid JSON: ${err.message}`);
+      failWriteValidation3(`${path38} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -24401,11 +24621,11 @@ function unwrap(response) {
   }
   return response.data;
 }
-async function readAvatars(path40, params) {
-  return unwrap(await apiGet(path40, params));
+async function readAvatars(path38, params) {
+  return unwrap(await apiGet(path38, params));
 }
-async function writeAvatars(path40, body) {
-  return unwrap(await apiPost(path40, body));
+async function writeAvatars(path38, body) {
+  return unwrap(await apiPost(path38, body));
 }
 
 // src/commands/avatars/create.ts
@@ -25151,14 +25371,14 @@ function suggestFamilies(wanted, catalogue, limit = 5) {
   const key = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
   const target = key(wanted);
   if (!target) return [];
-  const words3 = target.split(" ");
+  const words2 = target.split(" ");
   const scored = catalogue.map((family) => {
     const candidate = key(family);
     if (candidate === target) return { family, score: 0 };
     if (candidate.startsWith(target)) return { family, score: 1 };
     if (candidate.includes(target)) return { family, score: 2 };
-    const shared = words3.filter((w) => w.length > 2 && candidate.includes(w)).length;
-    return { family, score: shared > 0 ? 3 + (words3.length - shared) : Number.POSITIVE_INFINITY };
+    const shared = words2.filter((w) => w.length > 2 && candidate.includes(w)).length;
+    return { family, score: shared > 0 ? 3 + (words2.length - shared) : Number.POSITIVE_INFINITY };
   }).filter((c) => Number.isFinite(c.score)).sort((a, b) => a.score - b.score || a.family.localeCompare(b.family));
   return scored.slice(0, limit).map((c) => c.family);
 }
@@ -25239,12 +25459,12 @@ function missingFontFiles(urls, available) {
 function planFontAdoption(sources, families) {
   const wanted = new Map(families.map((family) => [normalizeFamily(family), family]));
   const byFamily = /* @__PURE__ */ new Map();
-  for (const { path: path40, source } of sources) {
-    const dir = posix.dirname(path40);
+  for (const { path: path38, source } of sources) {
+    const dir = posix.dirname(path38);
     for (const face of declaredFontFaces(source)) {
       if (!wanted.has(face.family)) continue;
       const perFile = byFamily.get(face.family) ?? /* @__PURE__ */ new Map();
-      perFile.set(path40, [...perFile.get(path40) ?? [], rebaseFontFaceSrc(face.block, dir)]);
+      perFile.set(path38, [...perFile.get(path38) ?? [], rebaseFontFaceSrc(face.block, dir)]);
       byFamily.set(face.family, perFile);
     }
   }
@@ -26652,10 +26872,10 @@ function estSpeechS(text2) {
 var OBSERVED_WPS_MIN = 1;
 var OBSERVED_WPS_MAX = 6;
 function estSpeechWindowS(text2, startS, endS) {
-  const words3 = wordCount(text2);
+  const words2 = wordCount(text2);
   const window2 = (endS ?? 0) - (startS ?? 0);
-  if (words3 > 0 && window2 > 0.3) {
-    const wps = words3 / window2;
+  if (words2 > 0 && window2 > 0.3) {
+    const wps = words2 / window2;
     if (wps >= OBSERVED_WPS_MIN && wps <= OBSERVED_WPS_MAX) return window2;
   }
   return estSpeechS(text2);
@@ -27511,10 +27731,10 @@ function scrubFloatSentences(text2, floatDescs) {
   if (floatDescs.length === 0 || !text2) return text2;
   const tokenSets = floatDescs.map((d) => new Set(floatTokens(d)));
   const kept = text2.split(/(?<=[.!?])\s+/).filter((sentence) => {
-    const words3 = new Set(floatTokens(sentence));
+    const words2 = new Set(floatTokens(sentence));
     return !tokenSets.some((ts) => {
       let hits = 0;
-      for (const w of words3) if (ts.has(w)) hits++;
+      for (const w of words2) if (ts.has(w)) hits++;
       return hits >= 2;
     });
   }).join(" ").trim();
@@ -33439,12 +33659,12 @@ function collectSideEffects(tree) {
   );
 }
 function readFlowTree(slug) {
-  const path40 = join3(flowsDir(), slug, "_data.json");
-  if (!existsSync5(path40)) {
+  const path38 = join3(flowsDir(), slug, "_data.json");
+  if (!existsSync5(path38)) {
     failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
   }
   try {
-    return JSON.parse(readFileSync9(path40, "utf-8"));
+    return JSON.parse(readFileSync9(path38, "utf-8"));
   } catch (error) {
     failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -33836,10 +34056,10 @@ function parseValueExpression(raw) {
   return parts.map(parsePart);
 }
 function trackingFieldIds() {
-  const path40 = join4(flowsDir(), "..", "tracking.ts");
-  if (!existsSync6(path40)) return null;
+  const path38 = join4(flowsDir(), "..", "tracking.ts");
+  if (!existsSync6(path38)) return null;
   try {
-    const source = readFileSync10(path40, "utf-8");
+    const source = readFileSync10(path38, "utf-8");
     const block2 = source.match(/TRACKING_FIELD_IDS\s*=\s*\[([\s\S]*?)\]\s*as const/)?.[1];
     if (!block2) return null;
     const ids = [...block2.matchAll(/"(tracking\.[a-z0-9_]+)"/g)].map((match) => match[1]);
@@ -34391,13 +34611,13 @@ function specsFromFile(parsed) {
     return `${destField}${type}=${entry?.value ?? ""}`;
   });
 }
-function readSpecFile(path40) {
+function readSpecFile(path38) {
   let raw;
   try {
-    raw = path40 === "-" ? readFileSync11(0, "utf-8") : readFileSync11(path40, "utf-8");
+    raw = path38 === "-" ? readFileSync11(0, "utf-8") : readFileSync11(path38, "utf-8");
   } catch (error) {
     refuse(
-      `Could not read ${path40 === "-" ? "the mapping from stdin" : `"${path40}"`}: ${error instanceof Error ? error.message : String(error)}`
+      `Could not read ${path38 === "-" ? "the mapping from stdin" : `"${path38}"`}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   let parsed;
@@ -34405,7 +34625,7 @@ function readSpecFile(path40) {
     parsed = JSON.parse(raw);
   } catch (error) {
     refuse(
-      `${path40 === "-" ? "stdin" : `"${path40}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      `${path38 === "-" ? "stdin" : `"${path38}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
       'Expected { "map": { "<destField>": "<value>", \u2026 } }'
     );
   }
@@ -34659,18 +34879,18 @@ var ARRAY_FIELDS = [
   "tagIds"
 ];
 var ARRAY_OWNERS = ["", "body"];
-function dropUnsetOptionals(sideEffect, path40) {
+function dropUnsetOptionals(sideEffect, path38) {
   return OPTIONAL_STRINGS.flatMap((key) => {
     if (!(key in sideEffect) || sideEffect[key] !== null && sideEffect[key] !== "") return [];
     delete sideEffect[key];
-    return [{ path: path40, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
+    return [{ path: path38, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
   });
 }
-function fillNulledArrays(target, prefix, path40) {
+function fillNulledArrays(target, prefix, path38) {
   return ARRAY_FIELDS.flatMap((key) => {
     if (!(key in target) || target[key] !== null) return [];
     target[key] = [];
-    return [{ path: path40, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
+    return [{ path: path38, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
   });
 }
 function sideEffectsOf(node) {
@@ -34680,13 +34900,13 @@ function sideEffectsOf(node) {
   );
 }
 function normalizeSideEffect(sideEffect, where) {
-  const path40 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
+  const path38 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
   const arrays = ARRAY_OWNERS.flatMap((owner) => {
     const target = owner ? sideEffect[owner] : sideEffect;
     if (!target || typeof target !== "object") return [];
-    return fillNulledArrays(target, owner ? `${owner}.` : "", path40);
+    return fillNulledArrays(target, owner ? `${owner}.` : "", path38);
   });
-  return [...dropUnsetOptionals(sideEffect, path40), ...arrays];
+  return [...dropUnsetOptionals(sideEffect, path38), ...arrays];
 }
 function normalizeFlowTree(tree) {
   const changes = [];
@@ -35224,10 +35444,10 @@ async function stageOps(ops) {
     handleError2(err);
   }
 }
-async function draftAction2(path40, body, chat) {
+async function draftAction2(path38, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path40, { chatId, ...body });
+    const data = await apiPost(path38, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -37659,9 +37879,9 @@ async function readImageBuffer(pathOrUrl) {
   }
   return readFile20(pathOrUrl);
 }
-async function isDirectory(path40) {
+async function isDirectory(path38) {
   try {
-    const s = await stat4(path40);
+    const s = await stat4(path38);
     return s.isDirectory();
   } catch {
     return false;
@@ -37963,13 +38183,13 @@ function resolveDownloadPath({ baseName, extension, out, outIsDirectory: outIsDi
 }
 function disambiguate(paths) {
   const taken = /* @__PURE__ */ new Set();
-  return paths.map((path40) => {
-    if (!taken.has(path40)) {
-      taken.add(path40);
-      return path40;
+  return paths.map((path38) => {
+    if (!taken.has(path38)) {
+      taken.add(path38);
+      return path38;
     }
-    const ext = extname3(path40);
-    const stem = path40.slice(0, path40.length - ext.length);
+    const ext = extname3(path38);
+    const stem = path38.slice(0, path38.length - ext.length);
     let n = 2;
     while (taken.has(`${stem}-${n}${ext}`)) n += 1;
     const unique = `${stem}-${n}${ext}`;
@@ -38096,10 +38316,10 @@ async function runDownloads(plan) {
   const paths = disambiguate(fetched.map((item) => item.path));
   const downloaded = [];
   for (const [index, item] of fetched.entries()) {
-    const path40 = paths[index] ?? item.path;
+    const path38 = paths[index] ?? item.path;
     try {
-      await atomicWrite(path40, item.buffer);
-      downloaded.push({ input: item.input, output: path40, bytes: item.buffer.length, contentType: item.contentType });
+      await atomicWrite(path38, item.buffer);
+      downloaded.push({ input: item.input, output: path38, bytes: item.buffer.length, contentType: item.contentType });
     } catch (err) {
       failed.push({ input: item.input, error: failureMessage(err, "Write failed") });
     }
@@ -41059,7 +41279,7 @@ import { defineCommand as defineCommand166 } from "citty";
 
 // src/commands/landing/critique.ts
 import { readdir as readdir9, stat as stat6 } from "fs/promises";
-import path29 from "path";
+import path28 from "path";
 import { defineCommand as defineCommand156 } from "citty";
 
 // src/engine/landing/lib/constants.ts
@@ -41262,11 +41482,6 @@ var RULE_META = {
     severity: "block",
     note: "Gradient text is a top AI tell. Emphasis comes from weight or size, not a clipped gradient fill."
   },
-  "copied-reference-copy": {
-    family: "originality",
-    severity: "block",
-    note: "This line is lifted from a section you consulted in the inspiration library. Reference sections are for structure and mechanism, never words \u2014 a visitor who has seen the original reads this as a clone, and the claim is not yours to make. Rewrite it from the client's own offer."
-  },
   "broken-image": {
     family: "integrity",
     severity: "block",
@@ -41447,64 +41662,6 @@ var SEVERITY_WEIGHT = {
   advisory: 0.05
 };
 
-// src/engine/landing/lib/originality.ts
-var MIN_COMPARABLE_LENGTH = 12;
-var NEAR_MATCH_RATIO = 0.8;
-function normalize(value) {
-  return value.toLowerCase().replace(/[‘’“”]/g, "'").replace(/[^a-z0-9']+/g, " ").trim();
-}
-function words2(value) {
-  return normalize(value).split(" ").filter(Boolean);
-}
-function copyOverlapRatio(candidate, reference) {
-  const referenceWords = words2(reference);
-  if (referenceWords.length === 0) return 0;
-  const candidateWords = new Set(words2(candidate));
-  const shared = referenceWords.filter((word) => candidateWords.has(word)).length;
-  return shared / referenceWords.length;
-}
-function isVerbatimReuse(candidate, reference) {
-  const normalizedCandidate = normalize(candidate);
-  const normalizedReference = normalize(reference);
-  if (normalizedReference.length < MIN_COMPARABLE_LENGTH) return false;
-  if (normalizedCandidate.includes(normalizedReference)) return true;
-  return copyOverlapRatio(candidate, reference) >= NEAR_MATCH_RATIO;
-}
-function extractVisibleStrings(text2) {
-  const found = [];
-  const lines = text2.split("\n");
-  for (const [index, line] of lines.entries()) {
-    for (const match of line.matchAll(/>([^<>{}]{12,200})</g)) {
-      const value = match[1]?.trim();
-      if (value && /[a-zA-Z]{3}/.test(value)) found.push({ value, line: index + 1 });
-    }
-  }
-  return found;
-}
-function detectOriginality(sources, references) {
-  if (references.length === 0) return [];
-  const findings = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const source of sources) {
-    for (const { value, line } of extractVisibleStrings(source.text)) {
-      for (const reference of references) {
-        const hit = reference.copyStrings.find((copy) => isVerbatimReuse(value, copy));
-        if (!hit) continue;
-        const key = `${source.path}:${line}:${normalize(hit)}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        findings.push({
-          id: "copied-reference-copy",
-          snippet: value.slice(0, 120),
-          file: source.path,
-          line
-        });
-      }
-    }
-  }
-  return findings;
-}
-
 // src/engine/landing/lib/rules.ts
 var cap2 = (m, i) => m[i] ?? "";
 var num2 = (m, i) => Number(m[i] ?? 0);
@@ -42032,16 +42189,7 @@ function dedupe(findings) {
 }
 
 // src/engine/landing/lib/critique.ts
-var FAMILIES = [
-  "typography",
-  "color",
-  "borders_depth",
-  "motion",
-  "spacing",
-  "copy",
-  "integrity",
-  "originality"
-];
+var FAMILIES = ["typography", "color", "borders_depth", "motion", "spacing", "copy", "integrity"];
 function round4(n) {
   return Math.round(n * 100) / 100;
 }
@@ -42060,7 +42208,6 @@ function critiqueLanding(input) {
   const raws = [];
   for (const source of sources) raws.push(...detectSource(source));
   raws.push(...detectPage(sources));
-  raws.push(...detectOriginality(sources, input.references ?? []));
   for (const raw of raws) {
     const meta = RULE_META[raw.id];
     if (!meta) continue;
@@ -42098,82 +42245,41 @@ function describeCounts(findings) {
   return [b ? `${b} block` : "", w ? `${w} warn` : "", a ? `${a} advisory` : ""].filter(Boolean).join(", ");
 }
 
-// src/engine/landing/lib/referenceStore.ts
-import { mkdir as mkdir8, readFile as readFile21, writeFile as writeFile12 } from "fs/promises";
-import path26 from "path";
-var REFERENCES_FILE = ".cache/inspiration-refs.json";
-var REFERENCE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-async function readReferences(projectRoot) {
-  try {
-    const raw = await readFile21(path26.join(projectRoot, REFERENCES_FILE), "utf8");
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed)) return [];
-    const cutoff = Date.now() - REFERENCE_TTL_MS;
-    return parsed.filter((entry) => {
-      if (typeof entry !== "object" || entry === null) return false;
-      const candidate = entry;
-      if (typeof candidate.sectionId !== "string" || !Array.isArray(candidate.copyStrings)) return false;
-      const at = Date.parse(candidate.consultedAt ?? "");
-      return Number.isNaN(at) ? true : at >= cutoff;
-    });
-  } catch {
-    return [];
-  }
-}
-async function recordReference(projectRoot, reference) {
-  return await recordReferences(projectRoot, [reference]);
-}
-async function recordReferences(projectRoot, references) {
-  if (references.length === 0) return true;
-  try {
-    const existing = await readReferences(projectRoot);
-    const replaced = new Set(references.map((reference) => reference.sectionId));
-    const merged = [...existing.filter((entry) => !replaced.has(entry.sectionId)), ...references];
-    const file = path26.join(projectRoot, REFERENCES_FILE);
-    await mkdir8(path26.dirname(file), { recursive: true });
-    await writeFile12(file, `${JSON.stringify(merged, null, 2)}
-`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/commands/landing/snapshot.ts
-import { mkdir as mkdir9, rename as rename2, writeFile as writeFile13 } from "fs/promises";
-import path27 from "path";
+import { mkdir as mkdir8, rename as rename2, writeFile as writeFile12 } from "fs/promises";
+import path26 from "path";
 var CRITIC_VERSION = "2";
 function critiqueCacheDir(projectRoot) {
-  return path27.join(projectRoot, ".cache", "landing-critique");
+  return path26.join(projectRoot, ".cache", "landing-critique");
 }
 function snapshotPath(projectRoot, slug) {
-  return path27.join(critiqueCacheDir(projectRoot), `${slug}.json`);
+  return path26.join(critiqueCacheDir(projectRoot), `${slug}.json`);
 }
 async function writeCritiqueSnapshot(projectRoot, snapshot) {
-  await mkdir9(critiqueCacheDir(projectRoot), { recursive: true });
+  await mkdir8(critiqueCacheDir(projectRoot), { recursive: true });
   const dest = snapshotPath(projectRoot, snapshot.slug);
   const tmp = `${dest}.tmp`;
-  await writeFile13(tmp, `${JSON.stringify(snapshot, null, 2)}
+  await writeFile12(tmp, `${JSON.stringify(snapshot, null, 2)}
 `, "utf8");
   await rename2(tmp, dest);
 }
 
 // src/commands/landing/source-version.ts
-import { readdir as readdir8, readFile as readFile22, stat as stat5 } from "fs/promises";
-import path28 from "path";
+import { readdir as readdir8, readFile as readFile21, stat as stat5 } from "fs/promises";
+import path27 from "path";
 async function landingSourceRelPaths(landingDir) {
   const rel = [];
-  if (await isFile(path28.join(landingDir, "index.astro"))) rel.push("index.astro");
-  const componentsDir = path28.join(landingDir, "_components");
+  if (await isFile(path27.join(landingDir, "index.astro"))) rel.push("index.astro");
+  const componentsDir = path27.join(landingDir, "_components");
   for (const abs of await walkAstro(componentsDir)) {
-    rel.push(path28.relative(landingDir, abs).split(path28.sep).join("/"));
+    rel.push(path27.relative(landingDir, abs).split(path27.sep).join("/"));
   }
   return rel.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
 }
 async function readLandingSources(landingDir) {
   const rel = await landingSourceRelPaths(landingDir);
   const out = [];
-  for (const r of rel) out.push({ path: r, text: await readFile22(path28.join(landingDir, r), "utf8") });
+  for (const r of rel) out.push({ path: r, text: await readFile21(path27.join(landingDir, r), "utf8") });
   return out;
 }
 async function computeLandingSourceSha(landingDir) {
@@ -42182,7 +42288,7 @@ async function computeLandingSourceSha(landingDir) {
   for (const r of rel) {
     let bytes;
     try {
-      bytes = await readFile22(path28.join(landingDir, r));
+      bytes = await readFile21(path27.join(landingDir, r));
     } catch {
       bytes = Buffer.alloc(0);
     }
@@ -42206,7 +42312,7 @@ async function walkAstro(dir) {
   }
   const out = [];
   for (const entry of entries) {
-    const abs = path28.join(dir, entry.name);
+    const abs = path27.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkAstro(abs));
     else if (entry.isFile() && entry.name.endsWith(".astro")) out.push(abs);
   }
@@ -42267,14 +42373,14 @@ var critiqueCommand2 = defineCommand156({
           { availableSlugs: await listLandingSlugs(projectRoot) }
         );
       }
-      if (!await isDir(path29.resolve(projectRoot, "src", "pages", slug))) {
+      if (!await isDir(path28.resolve(projectRoot, "src", "pages", slug))) {
         fail5("NOT_FOUND", `No landing at src/pages/${slug}/`, {
           availableSlugs: await listLandingSlugs(projectRoot)
         });
       }
     }
-    const [brand, references] = await Promise.all([loadBrandTokens(projectRoot), readReferences(projectRoot)]);
-    const results = await Promise.all(slugs.map((slug) => critiqueOne(projectRoot, slug, brand, references)));
+    const brand = await loadBrandTokens(projectRoot);
+    const results = await Promise.all(slugs.map((slug) => critiqueOne(projectRoot, slug, brand)));
     const landings = results.map(({ slug, report }) => ({
       slug,
       overall: report.overall,
@@ -42305,10 +42411,10 @@ var critiqueCommand2 = defineCommand156({
     );
   }
 });
-async function critiqueOne(projectRoot, slug, brand, references) {
-  const landingDir = path29.resolve(projectRoot, "src", "pages", slug);
+async function critiqueOne(projectRoot, slug, brand) {
+  const landingDir = path28.resolve(projectRoot, "src", "pages", slug);
   const [sources, sourceSha] = await Promise.all([readLandingSources(landingDir), computeLandingSourceSha(landingDir)]);
-  const report = critiqueLanding({ slug, sources, brand, references });
+  const report = critiqueLanding({ slug, sources, brand });
   let snapshotFailed = false;
   try {
     await writeCritiqueSnapshot(projectRoot, {
@@ -42326,7 +42432,7 @@ async function critiqueOne(projectRoot, slug, brand, references) {
 }
 async function listLandingSlugs(projectRoot) {
   try {
-    const entries = await readdir9(path29.join(projectRoot, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir9(path28.join(projectRoot, "src", "pages"), { withFileTypes: true });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
   } catch {
     return [];
@@ -42359,7 +42465,7 @@ import { defineCommand as defineCommand157 } from "citty";
 
 // src/commands/landing/inspiration/shared.ts
 var INSPIRATION_HINTS = {
-  adapt: "Reference only. Re-express this in the client's BRAND.md palette, type and imagery register. Reusing a headline, subhead or CTA verbatim is a Tier 0 message-match failure (references/gotchas.md) and `baker landing critique` will block the publish.",
+  adapt: "Reference only. Re-express this in the client's BRAND.md palette, type and imagery register. Reusing a headline, subhead or CTA verbatim is a Tier 0 message-match failure (references/gotchas.md).",
   structureNotCopy: "Take the structural decision, not the furniture: what the eye hits first, the grid ratio, what was deliberately left out. Your copy must come from the client's own offer."
 };
 function favoritesScopeHints(health, resultCount) {
@@ -42477,12 +42583,12 @@ var addCommand = defineCommand157({
 });
 
 // src/commands/landing/inspiration/code.ts
-import { mkdir as mkdir10, writeFile as writeFile14 } from "fs/promises";
-import path30 from "path";
+import { mkdir as mkdir9, writeFile as writeFile13 } from "fs/promises";
+import path29 from "path";
 import { defineCommand as defineCommand158 } from "citty";
 registerSchema({
   command: "landing.inspiration.code",
-  description: "Write a reference section's standalone HTML+CSS to .baker/inspiration/<id>/ so you can read how it is built. Reference only \u2014 the structure is the lesson, the words are not yours to reuse. Consulting a section records it, and `baker landing critique` blocks a publish that ships its copy verbatim.",
+  description: "Write a reference section's standalone HTML+CSS to .baker/inspiration/<id>/ so you can read how it is built. Reference only \u2014 the structure is the lesson, the words are not yours to reuse.",
   args: {
     id: { type: "string", description: "Section id from search", required: true },
     full: { type: "boolean", description: "Print the markup inline as well as writing it", required: false }
@@ -42501,30 +42607,19 @@ var codeCommand = defineCommand158({
     try {
       const id = args.id;
       const data = await apiGet("/api/landing-inspiration/section-code", { id });
-      const dir = path30.join(process.cwd(), ".baker", "inspiration", id);
-      await mkdir10(dir, { recursive: true });
-      const file = path30.join(dir, "section.html");
-      await writeFile14(file, data.html);
-      const recorded = await recordReference(process.cwd(), {
-        sectionId: id,
-        sourceUrl: data.sourceUrl,
-        copyStrings: data.copyStrings,
-        consultedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
+      const dir = path29.join(process.cwd(), ".baker", "inspiration", id);
+      await mkdir9(dir, { recursive: true });
+      const file = path29.join(dir, "section.html");
+      await writeFile13(file, data.html);
       const hints = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
       const fidelity = fidelityHint(data.fidelity);
       if (fidelity) hints.push(fidelity);
       if (data.fidelityNote) hints.push(data.fidelityNote);
-      if (!recorded) {
-        hints.push(
-          "Could not record this reference (.cache/ not writable?) \u2014 the originality check at publish will not be able to see it, so be especially careful not to reuse its copy."
-        );
-      }
       writeJson({
         ok: true,
         data: {
           id,
-          file: path30.relative(process.cwd(), file),
+          file: path29.relative(process.cwd(), file),
           bytes: data.html.length,
           fidelity: data.fidelity,
           reproduction_notes: data.reproductionNotes,
@@ -42779,25 +42874,8 @@ var pageCommand2 = defineCommand160({
 });
 
 // src/commands/landing/inspiration/scrape.ts
-import { readFile as readFile23 } from "fs/promises";
-import path34 from "path";
 import { defineCommand as defineCommand161 } from "citty";
 
-// src/engine/landing/lib/capturedReferences.ts
-var MAX_STRINGS_PER_SECTION = 40;
-function bodyOf(markup) {
-  const body = markup.indexOf("<body");
-  return body === -1 ? markup : markup.slice(body);
-}
-function capturedCopyStrings(markup) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const { value } of extractVisibleStrings(bodyOf(markup))) {
-    seen.add(value);
-    if (seen.size >= MAX_STRINGS_PER_SECTION) break;
-  }
-  return [...seen];
-}
-
 // src/engine/landing-library/proxyFailure.ts
 var PROXY_STATUS = 407;
 var PROXY_NET_ERRORS = [
@@ -42972,8 +43050,8 @@ function classifyCaptureFailure(error) {
 }
 
 // src/engine/landing-library/run.ts
-import { mkdir as mkdir11, writeFile as writeFile16 } from "fs/promises";
-import path32 from "path";
+import { mkdir as mkdir10, writeFile as writeFile15 } from "fs/promises";
+import path31 from "path";
 
 // ../proxy/src/preflight.ts
 import http from "http";
@@ -44388,11 +44466,11 @@ async function renderBundleToPng(browser, html, viewportWidth, options = {}) {
 }
 
 // src/engine/landing-library/report.ts
-import { writeFile as writeFile15 } from "fs/promises";
-import path31 from "path";
+import { writeFile as writeFile14 } from "fs/promises";
+import path30 from "path";
 async function writeCaptureReport(manifest, outDir) {
-  const file = path31.join(outDir, "report.html");
-  await writeFile15(file, renderReport(manifest));
+  const file = path30.join(outDir, "report.html");
+  await writeFile14(file, renderReport(manifest));
   return file;
 }
 function escapeHtml3(value) {
@@ -44570,32 +44648,32 @@ async function reproducePage(args) {
   const { browser, page, outDir, pageUrl, livePageShot } = args;
   const built = await buildSectionBundle(page, "body", pageUrl).catch(() => null);
   if (!built) return { bundle: null, fidelity: null };
-  await writeFile16(path32.join(outDir, "page.html"), built.html);
+  await writeFile15(path31.join(outDir, "page.html"), built.html);
   const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width, {
     wholePage: true,
     timeoutMs: 6e4
   });
   if (!rendered || !livePageShot) return { bundle: "page.html", fidelity: null };
-  await writeFile16(path32.join(outDir, "page-rendered.png"), rendered);
+  await writeFile15(path31.join(outDir, "page-rendered.png"), rendered);
   const { score, note } = await scoreFidelity(livePageShot, rendered);
   return { bundle: "page.html", fidelity: score, ...note ? { fidelityNote: note } : {} };
 }
 async function captureOneSection(args) {
   const { browser, page, candidate, sectionsDir, outDir, pageUrl, withCode } = args;
-  const dir = path32.join(sectionsDir, String(candidate.index).padStart(2, "0"));
-  await mkdir11(dir, { recursive: true });
+  const dir = path31.join(sectionsDir, String(candidate.index).padStart(2, "0"));
+  await mkdir10(dir, { recursive: true });
   const desktop = await captureSection(page, candidate);
-  if (desktop) await writeFile16(path32.join(dir, "desktop.png"), desktop);
+  if (desktop) await writeFile15(path31.join(dir, "desktop.png"), desktop);
   const visualHash = desktop ? await perceptualHash(desktop) : null;
   const motion = await collectMotion(page, candidate.selector);
   const built = withCode ? await buildSectionBundle(page, candidate.selector, pageUrl) : null;
   let fidelity = null;
   let fidelityNote;
   if (built) {
-    await writeFile16(path32.join(dir, "section.html"), built.html);
+    await writeFile15(path31.join(dir, "section.html"), built.html);
     const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width);
     if (rendered && desktop) {
-      await writeFile16(path32.join(dir, "section-rendered.png"), rendered);
+      await writeFile15(path31.join(dir, "section-rendered.png"), rendered);
       const result = await scoreFidelity(desktop, rendered);
       fidelity = result.score;
       fidelityNote = result.note;
@@ -44603,9 +44681,9 @@ async function captureOneSection(args) {
   }
   return {
     ...candidate,
-    desktopShot: desktop ? path32.relative(outDir, path32.join(dir, "desktop.png")) : null,
+    desktopShot: desktop ? path31.relative(outDir, path31.join(dir, "desktop.png")) : null,
     mobileShot: null,
-    bundle: built ? path32.relative(outDir, path32.join(dir, "section.html")) : null,
+    bundle: built ? path31.relative(outDir, path31.join(dir, "section.html")) : null,
     fidelity,
     ...fidelityNote ? { fidelityNote } : {},
     ...built ? { cssStats: built.stats } : {},
@@ -44624,9 +44702,9 @@ async function captureMobileShots(args) {
     for (const section of sections) {
       const shot = await captureSectionOnMobile(mobile.page, section);
       if (!shot) continue;
-      const file = path32.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
-      await writeFile16(file, shot);
-      section.mobileShot = path32.relative(outDir, file);
+      const file = path31.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
+      await writeFile15(file, shot);
+      section.mobileShot = path31.relative(outDir, file);
     }
   } finally {
     await mobile.context.close();
@@ -44641,10 +44719,10 @@ async function captureMotionTakes(args) {
   const filmOne = async (section) => {
     const take = await captureMotionTake(browser, pageUrl, section.selector).catch(() => null);
     if (!take) return;
-    const dir = path32.join(sectionsDir, String(section.index).padStart(2, "0"));
-    const file = path32.join(dir, "motion-filmstrip.png");
-    await writeFile16(file, take.filmstrip);
-    section.motionFilmstrip = path32.relative(outDir, file);
+    const dir = path31.join(sectionsDir, String(section.index).padStart(2, "0"));
+    const file = path31.join(dir, "motion-filmstrip.png");
+    await writeFile15(file, take.filmstrip);
+    section.motionFilmstrip = path31.relative(outDir, file);
     log(`  [${section.index}] ${section.motion.summary}`);
   };
   const queue = [...moving];
@@ -44701,7 +44779,7 @@ async function captureAlternateViews(args) {
 async function reproduceWholePage(args) {
   const { browser, page, outDir, pageUrl, withCode, log } = args;
   const fullPage = await page.screenshot({ type: "png", fullPage: true }).catch(() => null);
-  if (fullPage) await writeFile16(path32.join(outDir, "full-page.png"), fullPage);
+  if (fullPage) await writeFile15(path31.join(outDir, "full-page.png"), fullPage);
   if (!withCode) return { bundle: null, fidelity: null };
   const reproduction = await reproducePage({ browser, page, outDir, pageUrl, livePageShot: fullPage });
   log(`page reproduction: ${reproduction.fidelity === null ? "unavailable" : reproduction.fidelity.toFixed(2)}`);
@@ -44772,7 +44850,7 @@ async function openViaLadder(args) {
 async function scrapeLanding(options) {
   const timeoutMs = options.timeoutMs ?? 45e3;
   const log = options.onProgress ?? (() => void 0);
-  const sectionsDir = path32.join(options.outDir, "sections");
+  const sectionsDir = path31.join(options.outDir, "sections");
   const nonPublic = refuseNonPublicUrl(options.url);
   if (nonPublic) {
     throw new BlockedPageError({
@@ -44792,7 +44870,7 @@ async function scrapeLanding(options) {
   const withMotion = options.motion !== false && !escalated;
   const renderBrowser = options.code === false ? null : await launchBrowser();
   try {
-    await mkdir11(sectionsDir, { recursive: true });
+    await mkdir10(sectionsDir, { recursive: true });
     const sections = await captureSections({
       browser: renderBrowser ?? browser,
       page,
@@ -44834,7 +44912,7 @@ async function scrapeLanding(options) {
       security: prepared.security,
       captureTier: tier
     };
-    await writeFile16(path32.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile15(path31.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
     if (options.report !== false) {
       const reportPath = await writeCaptureReport(manifest, options.outDir);
@@ -44849,28 +44927,28 @@ async function scrapeLanding(options) {
 
 // src/commands/landing/inspiration/captureOut.ts
 import { existsSync as existsSync9 } from "fs";
-import path33 from "path";
+import path32 from "path";
 var SCRATCH_DIR = ".baker";
 function isWithin(parent, target) {
-  const relative = path33.relative(parent, target);
-  return relative === "" || !relative.startsWith("..") && !path33.isAbsolute(relative);
+  const relative = path32.relative(parent, target);
+  return relative === "" || !relative.startsWith("..") && !path32.isAbsolute(relative);
 }
 function findRepoRoot(from) {
-  let dir = path33.resolve(from);
+  let dir = path32.resolve(from);
   for (; ; ) {
-    if (existsSync9(path33.join(dir, ".git"))) return dir;
-    const parent = path33.dirname(dir);
+    if (existsSync9(path32.join(dir, ".git"))) return dir;
+    const parent = path32.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function checkCaptureOut(out, options) {
   const { cwd, repoRoot } = options;
-  const resolved = path33.resolve(cwd, out);
+  const resolved = path32.resolve(cwd, out);
   if (repoRoot === null || !isWithin(repoRoot, resolved)) return { ok: true };
-  const scratch = path33.join(repoRoot, SCRATCH_DIR);
+  const scratch = path32.join(repoRoot, SCRATCH_DIR);
   if (isWithin(scratch, resolved)) return { ok: true };
-  const suggestion = path33.posix.join(SCRATCH_DIR, "teardowns", path33.basename(resolved) || "capture");
+  const suggestion = path32.posix.join(SCRATCH_DIR, "teardowns", path32.basename(resolved) || "capture");
   return {
     ok: false,
     error: {
@@ -44893,29 +44971,8 @@ var RETRYABLE_FAILURES = /* @__PURE__ */ new Set([
   // would blacklist a page that was never actually judged.
   "PROXY_UNAVAILABLE"
 ]);
-async function recordCapture(manifest, outDir) {
-  const consultedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const references = [];
-  for (const section of manifest.sections) {
-    if (!section.bundle) continue;
-    try {
-      const markup = await readFile23(path34.join(outDir, section.bundle), "utf8");
-      const copyStrings = capturedCopyStrings(markup);
-      if (copyStrings.length === 0) continue;
-      references.push({
-        sectionId: `local:${manifest.finalUrl}#${section.index}`,
-        sourceUrl: manifest.finalUrl,
-        copyStrings,
-        consultedAt
-      });
-    } catch {
-    }
-  }
-  const written = await recordReferences(process.cwd(), references);
-  return written ? references.length : 0;
-}
 function captureHints(args) {
-  const { manifest, outDir, report, recorded } = args;
+  const { manifest, outDir, report } = args;
   const shots = manifest.sections.filter((section) => section.desktopShot !== null).length;
   const anyScored = manifest.sections.some((section) => section.fidelity !== null);
   const hints = [];
@@ -44935,14 +44992,11 @@ function captureHints(args) {
     );
   }
   hints.push(INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt);
-  hints.push(
-    recorded > 0 ? `${recorded} sections are recorded for the originality check \u2014 \`baker landing critique\` will block a publish that ships their copy.` : "Nothing from this capture is recorded for the originality check, so it cannot see this page. Be especially careful not to reuse its copy."
-  );
   return hints;
 }
 registerSchema({
   command: "landing.inspiration.scrape",
-  description: "Start here when the user points at a specific page and wants it now: capture one landing page into a directory of section screenshots, standalone HTML bundles, a whole-page reproduction and motion filmstrips. Returns when the capture is done, unlike `add`. Read the screenshots. Also records every captured section for the originality check.",
+  description: "Start here when the user points at a specific page and wants it now: capture one landing page into a directory of section screenshots, standalone HTML bundles, a whole-page reproduction and motion filmstrips. Returns when the capture is done, unlike `add`. Read the screenshots.",
   args: {
     url: { type: "string", description: "Page to capture", required: true },
     out: { type: "string", description: "Output directory under .baker/", required: true },
@@ -45010,7 +45064,6 @@ var scrapeCommand = defineCommand161({
 `)
       });
       const scored = manifest.sections.map((section) => section.fidelity).filter((value) => value !== null).sort((a, b) => a - b);
-      const recorded = await recordCapture(manifest, args.out);
       writeJson({
         ok: true,
         data: {
@@ -45031,7 +45084,7 @@ var scrapeCommand = defineCommand161({
           certificate_verified: false,
           ...manifest.security.certificateNotes.length > 0 ? { certificate_notes: manifest.security.certificateNotes } : {}
         },
-        hints: captureHints({ manifest, outDir: args.out, report: args.report, recorded })
+        hints: captureHints({ manifest, outDir: args.out, report: args.report })
       });
     } catch (error) {
       const failure = classifyCaptureFailure(error);
@@ -45069,12 +45122,12 @@ var scrapeCommand = defineCommand161({
 });
 
 // src/commands/landing/inspiration/search.ts
-import path36 from "path";
+import path34 from "path";
 import { defineCommand as defineCommand162 } from "citty";
 
 // src/commands/landing/inspiration/shot.ts
-import { mkdir as mkdir12, writeFile as writeFile17 } from "fs/promises";
-import path35 from "path";
+import { mkdir as mkdir11, writeFile as writeFile16 } from "fs/promises";
+import path33 from "path";
 import sharp6 from "sharp";
 var READABLE_SHOT = {
   maxWidth: 1440,
@@ -45100,9 +45153,9 @@ async function downloadReadableShot(url, file) {
     const response = await fetch(url);
     if (!response.ok) return null;
     const shot = await toReadableShot(Buffer.from(await response.arrayBuffer()));
-    await mkdir12(path35.dirname(file), { recursive: true });
-    await writeFile17(file, shot);
-    return path35.relative(process.cwd(), file);
+    await mkdir11(path33.dirname(file), { recursive: true });
+    await writeFile16(file, shot);
+    return path33.relative(process.cwd(), file);
   } catch {
     return null;
   }
@@ -45194,13 +45247,13 @@ function buildSearchBody(args) {
   return body;
 }
 async function downloadShots(results) {
-  const dir = path36.join(process.cwd(), ".baker", "inspiration");
+  const dir = path34.join(process.cwd(), ".baker", "inspiration");
   const saved = /* @__PURE__ */ new Map();
   await Promise.all(
     results.map(async (result) => {
       const file = await downloadReadableShot(
         result.desktopShotUrl,
-        path36.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
+        path34.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
       );
       if (file) saved.set(result.id, file);
     })
@@ -45428,7 +45481,7 @@ var sequencesCommand = defineCommand163({
 });
 
 // src/commands/landing/inspiration/view.ts
-import path37 from "path";
+import path35 from "path";
 import { defineCommand as defineCommand164 } from "citty";
 registerSchema({
   command: "landing.inspiration.view",
@@ -45461,12 +45514,12 @@ var viewCommand2 = defineCommand164({
       const id = args.id;
       const data = await apiGet("/api/landing-inspiration/section", { id });
       const section = data.section;
-      const dir = path37.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path35.join(process.cwd(), ".baker", "inspiration", id);
       const ext = READABLE_SHOT.extension;
       const [desktop, mobile, filmstrip] = await Promise.all([
-        downloadReadableShot(section.desktopShotUrl, path37.join(dir, `desktop.${ext}`)),
-        downloadReadableShot(section.mobileShotUrl, path37.join(dir, `mobile.${ext}`)),
-        downloadReadableShot(section.motionFilmstripUrl, path37.join(dir, `motion-filmstrip.${ext}`))
+        downloadReadableShot(section.desktopShotUrl, path35.join(dir, `desktop.${ext}`)),
+        downloadReadableShot(section.mobileShotUrl, path35.join(dir, `mobile.${ext}`)),
+        downloadReadableShot(section.motionFilmstripUrl, path35.join(dir, `motion-filmstrip.${ext}`))
       ]);
       const full = args.full;
       const hints = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
@@ -45533,7 +45586,7 @@ var inspirationCommand = defineCommand165({
 
 Start here: \`baker landing inspiration search "<what you want to see>"\` during research, BEFORE you write the Direction Contract.
 
-This is inspiration, never a clipboard. Take the mechanism \u2014 what the eye hits first, what proof arrives before the ask, how the grid is split. The words are never yours to reuse: shipping a reference's headline is a Tier 0 message-match failure and \`baker landing critique\` will block the publish.
+This is inspiration, never a clipboard. Take the mechanism \u2014 what the eye hits first, what proof arrives before the ask, how the grid is split. The words are never yours to reuse: shipping a reference's headline is a Tier 0 message-match failure.
 
 Subcommands:
   baker landing inspiration search "<query>"  \u2014 search by look, section type, composition, register or motion; saves screenshots you can Read
@@ -47315,8 +47368,8 @@ var listCommand15 = defineCommand183({
 });
 
 // src/commands/scheduled-actions/templates.ts
-import { readFile as readFile24 } from "fs/promises";
-import path38 from "path";
+import { readFile as readFile22 } from "fs/promises";
+import path36 from "path";
 import { defineCommand as defineCommand184 } from "citty";
 registerSchema({
   command: "scheduled-actions.templates",
@@ -47419,7 +47472,7 @@ Full guide: __tooling__/docs/tools/baker/scheduled-actions.md`
       }
       if (save.length > 0) {
         const briefFile = flag("brief-file");
-        const brief = briefFile.length > 0 ? await readFile24(path38.resolve(briefFile), "utf8") : flag("brief");
+        const brief = briefFile.length > 0 ? await readFile22(path36.resolve(briefFile), "utf8") : flag("brief");
         if (brief.trim().length === 0) {
           failValidation4("--brief-file (preferred) or --brief is required: the brief is the recipe.");
         }
@@ -47890,7 +47943,7 @@ function parseImageRefs(spec) {
 }
 var defaultDeps = {
   ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
-  upload: (path40) => uploadLocalImage({ file: path40, contentType: detectImageContentType(path40), source: "uploaded" })
+  upload: (path38) => uploadLocalImage({ file: path38, contentType: detectImageContentType(path38), source: "uploaded" })
 };
 async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   const refs = parseImageRefs(spec);
@@ -47910,10 +47963,10 @@ async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   }
   return { imageIds, added };
 }
-function uploadFailure(path40) {
+function uploadFailure(path38) {
   return (error) => {
     if (error instanceof ApiError) throw error;
-    throw new ApiError("VALIDATION_ERROR", `Could not read "${path40}" as an image.`);
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path38}" as an image.`);
   };
 }
 
@@ -48975,10 +49028,10 @@ async function stageOp4(op) {
     handleError5(err);
   }
 }
-async function draftAction3(path40, body, chat) {
+async function draftAction3(path38, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path40, { chatId, ...body });
+    const data = await apiPost(path38, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -50085,7 +50138,7 @@ var groupCommand2 = defineCommand209({
 // src/commands/videos/ingest.ts
 import { mkdtemp as mkdtemp2, rm as rm7, stat as stat7 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import path39 from "path";
+import path37 from "path";
 import { defineCommand as defineCommand210 } from "citty";
 
 // src/lib/streamUpload.ts
@@ -50436,7 +50489,7 @@ function ingestUrl(args) {
 }
 async function downloadThenIngest(args, country) {
   const vimeoCookie = captureVimeoCookie();
-  const workDir = await mkdtemp2(path39.join(tmpdir3(), "videos-ingest-"));
+  const workDir = await mkdtemp2(path37.join(tmpdir3(), "videos-ingest-"));
   try {
     const probe = await probeYtDlp({ url: args.url, country, vimeoCookie, cookieDir: workDir });
     if (isAudioOnly(probe.info)) {
@@ -50572,7 +50625,7 @@ var searchCommand4 = defineCommand211({
 var tagsCommand6 = makeTagsCommand("videos", "video", "/api/videos/tags");
 
 // src/commands/videos/upload.ts
-import { readFile as readFile25, stat as stat8 } from "fs/promises";
+import { readFile as readFile23, stat as stat8 } from "fs/promises";
 import { basename as basename3, extname as extname4 } from "path";
 import { defineCommand as defineCommand212 } from "citty";
 var MIME_MAP = {
@@ -50669,7 +50722,7 @@ var uploadCommand2 = defineCommand212({
         originalFilename,
         descriptionContext
       });
-      const fileBuffer = await readFile25(filePath);
+      const fileBuffer = await readFile23(filePath);
       const uploadResponse = await fetch(uploadUrl, {
         method: "PUT",
         headers: { "Content-Type": contentType },
@@ -52056,7 +52109,7 @@ function unknownFlagEnvelope(unknown, commandPath, suggestion) {
   };
 }
 function commandPathOf(root, argv) {
-  const path40 = [];
+  const path38 = [];
   let command = root;
   for (const token of argv) {
     if (token === "--" || token.startsWith("-")) {
@@ -52067,10 +52120,10 @@ function commandPathOf(root, argv) {
     if (next === void 0 || typeof next !== "object") {
       break;
     }
-    path40.push(token);
+    path38.push(token);
     command = next;
   }
-  return path40.join(" ");
+  return path38.join(" ");
 }
 function refuseUnknownFlags(root, argv) {
   const unknown = findUnknownFlags(root, argv);