@koda-sl/baker-cli 0.113.2 → 0.114.0-dev.249eaa8ed

package/dist/cli.js

@@ -12,10 +12,10 @@ import {
   generateCatalog,
   resolveConcurrency,
   validateCanvasDeep
-} from "./chunk-7K2YAWUT.js";
+} from "./chunk-5AWO4BHJ.js";
 
 // src/cli.ts
-import { defineCommand as defineCommand155, runMain } from "citty";
+import { defineCommand as defineCommand157, runMain } from "citty";
 
 // src/commands/actions/index.ts
 import { defineCommand as defineCommand18 } from "citty";
@@ -2847,10 +2847,10 @@ Examples:
 });
 
 // src/commands/ads/index.ts
-import { defineCommand as defineCommand80 } from "citty";
+import { defineCommand as defineCommand82 } from "citty";
 
 // src/commands/ads/google/index.ts
-import { defineCommand as defineCommand29 } from "citty";
+import { defineCommand as defineCommand31 } from "citty";
 
 // src/commands/ads/google/accounts.ts
 import { defineCommand as defineCommand19 } from "citty";
@@ -3268,6 +3268,28 @@ function buildCommand(query, ctx) {
   return `baker ads google query "${query}" --customer-id ${ctx.customerId}`;
 }
 var CORRECTION_RULES = [
+  // 0. EXPECTED_REFERENCED_FIELD_IN_SELECT_CLAUSE — some resources (e.g. campaign_budget)
+  // require fields filtered in WHERE to also be selected. The error names the exact field,
+  // so add it to SELECT and retry. Kept first: field-specific rules below must not shadow
+  // this with an unrelated rewrite when the named field happens to match their pattern.
+  {
+    matchApiError: /must be present in SELECT clause:\s*'([\w.]+)'/i,
+    fix: (ctx) => {
+      const field = ctx.apiErrorMessage?.match(/must be present in SELECT clause:\s*'([\w.]+)'/i)?.[1];
+      if (!field) {
+        return {
+          action: "add_required_field",
+          explanation: "Add the field named in the error to the SELECT clause and retry"
+        };
+      }
+      const corrected = ctx.originalQuery.replace(/SELECT\s+/i, `SELECT ${field}, `);
+      return {
+        action: "add_required_field",
+        correctedCommand: buildCommand(corrected, ctx),
+        explanation: `${field} is used in WHERE but this resource requires it in SELECT too \u2014 added it`
+      };
+    }
+  },
   // 1. bare keyword.text → ad_group_criterion.keyword.text (leaves <resource>.keyword.text untouched)
   {
     matchQuery: /(?<![\w.])keyword\.text\b/,
@@ -3503,6 +3525,20 @@ var CORRECTION_RULES = [
       };
     }
   },
+  // 15b. asset.<type>_asset.final_urls → asset.final_urls (final URLs live on the asset
+  // itself; the typed sub-message only carries type-specific fields like link_text)
+  {
+    matchQuery: /asset\.\w+_asset\.final_(mobile_)?urls\b/,
+    matchApiError: /asset\.\w+_asset\.final_(mobile_)?urls/i,
+    fix: (ctx) => {
+      const corrected = ctx.originalQuery.replace(/asset\.\w+_asset\.final_(mobile_)?urls\b/g, "asset.final_$1urls");
+      return {
+        action: "retry_with_modified_query",
+        correctedCommand: buildCommand(corrected, ctx),
+        explanation: "Final URLs are on the asset itself \u2014 use asset.final_urls, not asset.<type>_asset.final_urls"
+      };
+    }
+  },
   // 16. Rate limit / quota
   {
     matchApiError: /RESOURCE_EXHAUSTED|quota.*exceeded|rate.*limit/i,
@@ -3630,6 +3666,7 @@ var CORRECTION_RULES = [
 
 // src/commands/ads/google/error-parser.ts
 function mapErrorCode(message) {
+  if (/must be present in SELECT clause/i.test(message)) return "MISSING_SELECT_FIELD";
   if (/field.*not.*found|unrecognized.*field|not.*valid.*field/i.test(message)) return "FIELD_NOT_FOUND";
   if (/not.*valid.*resource|cannot.*select.*from/i.test(message)) return "WRONG_RESOURCE";
   if (/operator|CONTAINS|LIKE/i.test(message)) return "INVALID_OPERATOR";
@@ -3835,11 +3872,1112 @@ Examples:
   }
 });
 
+// src/commands/ads/google/draft.ts
+import { defineCommand as defineCommand22 } from "citty";
+
+// src/commands/ads/google/write-shared.ts
+import { readFileSync as readFileSync3 } from "fs";
+
+// ../api/src/ads-google/limits.ts
+var GOOGLE_ADS_LIMITS = {
+  budget: {
+    nameMax: 255,
+    amountMicrosMin: 1
+  },
+  campaign: {
+    nameMax: 255
+  },
+  adGroup: {
+    nameMax: 255
+  },
+  keyword: {
+    textMax: 80,
+    wordsMax: 10
+  },
+  responsiveSearchAd: {
+    headlinesMin: 3,
+    headlinesMax: 15,
+    headlineTextMax: 30,
+    descriptionsMin: 2,
+    descriptionsMax: 4,
+    descriptionTextMax: 90,
+    pathMax: 15
+  },
+  responsiveDisplayAd: {
+    headlinesMin: 1,
+    headlinesMax: 5,
+    headlineTextMax: 30,
+    longHeadlineTextMax: 90,
+    descriptionsMin: 1,
+    descriptionsMax: 5,
+    descriptionTextMax: 90,
+    businessNameMax: 25
+  },
+  sharedSet: {
+    nameMax: 255
+  },
+  asset: {
+    sitelinkLinkTextMax: 25,
+    sitelinkDescriptionMax: 35,
+    calloutTextMax: 25,
+    structuredSnippetHeaderMax: 25,
+    structuredSnippetValuesMin: 3,
+    structuredSnippetValuesMax: 10
+  },
+  conversionAction: {
+    nameMax: 255
+  },
+  audience: {
+    nameMax: 255
+  },
+  biddingStrategy: {
+    nameMax: 255
+  },
+  label: {
+    nameMax: 255
+  }
+};
+var KEYWORD_MATCH_TYPES = ["EXACT", "PHRASE", "BROAD"];
+var ADVERTISING_CHANNEL_TYPES = [
+  "SEARCH",
+  "DISPLAY",
+  "SHOPPING",
+  "VIDEO",
+  "PERFORMANCE_MAX",
+  "DEMAND_GEN",
+  "MULTI_CHANNEL",
+  "LOCAL",
+  "SMART",
+  "TRAVEL",
+  "HOTEL",
+  "DISCOVERY"
+];
+var ADVERTISING_CHANNEL_SUB_TYPES = [
+  "SEARCH_MOBILE_APP",
+  "DISPLAY_MOBILE_APP",
+  "SEARCH_EXPRESS",
+  "DISPLAY_EXPRESS",
+  "SHOPPING_SMART_ADS",
+  "DISPLAY_GMAIL_AD",
+  "DISPLAY_SMART_CAMPAIGN",
+  "VIDEO_OUTSTREAM",
+  "VIDEO_ACTION",
+  "VIDEO_NON_SKIPPABLE",
+  "APP_CAMPAIGN",
+  "APP_CAMPAIGN_FOR_ENGAGEMENT",
+  "LOCAL_CAMPAIGN",
+  "SHOPPING_COMPARISON_LISTING_ADS",
+  "SEARCH_MOBILE_APP_ENGAGEMENT",
+  "TRAVEL_ACTIVITIES"
+];
+var BIDDING_STRATEGY_TYPES = [
+  "MANUAL_CPC",
+  "MAXIMIZE_CONVERSIONS",
+  "MAXIMIZE_CONVERSION_VALUE",
+  "TARGET_SPEND",
+  "TARGET_CPA",
+  "TARGET_ROAS",
+  "TARGET_IMPRESSION_SHARE",
+  "MANUAL_CPM",
+  "MANUAL_CPV",
+  "PERCENT_CPC"
+];
+var BUDGET_DELIVERY_METHODS = ["STANDARD", "ACCELERATED"];
+var AD_GROUP_TYPES = [
+  "SEARCH_STANDARD",
+  "DISPLAY_STANDARD",
+  "SHOPPING_PRODUCT_ADS",
+  "VIDEO_BUMPER",
+  "VIDEO_TRUE_VIEW_IN_STREAM",
+  "VIDEO_TRUE_VIEW_IN_DISPLAY",
+  "VIDEO_NON_SKIPPABLE_IN_STREAM",
+  "VIDEO_OUTSTREAM",
+  "DEMAND_GEN_AD"
+];
+var SHARED_SET_TYPES = [
+  "NEGATIVE_KEYWORDS",
+  "NEGATIVE_PLACEMENTS",
+  "ACCOUNT_LEVEL_NEGATIVE_KEYWORDS"
+];
+var STAGEABLE_CREATE_STATUSES2 = ["ENABLED", "PAUSED"];
+var PINNED_FIELDS = ["HEADLINE_1", "HEADLINE_2", "HEADLINE_3", "DESCRIPTION_1", "DESCRIPTION_2"];
+var CONVERSION_ACTION_CATEGORIES = [
+  "DEFAULT",
+  "PAGE_VIEW",
+  "PURCHASE",
+  "SIGNUP",
+  "LEAD",
+  "DOWNLOAD",
+  "ADD_TO_CART",
+  "BEGIN_CHECKOUT",
+  "SUBSCRIBE_PAID",
+  "PHONE_CALL_LEAD",
+  "SUBMIT_LEAD_FORM",
+  "BOOK_APPOINTMENT",
+  "REQUEST_QUOTE",
+  "CONTACT"
+];
+var CONVERSION_ACTION_TYPES = [
+  "WEBPAGE",
+  "UPLOAD_CLICKS",
+  "UPLOAD_CALLS",
+  "WEBSITE_CALL",
+  "GOOGLE_ANALYTICS_4_CUSTOM"
+];
+var CONVERSION_COUNTING_TYPES = ["ONE_PER_CLICK", "MANY_PER_CLICK"];
+var USER_LIST_TYPES = ["CRM_BASED", "RULE_BASED", "LOGICAL", "BASIC", "LOOKALIKE"];
+var ASSET_FIELD_TYPES = [
+  "SITELINK",
+  "CALLOUT",
+  "STRUCTURED_SNIPPET",
+  "CALL",
+  "PRICE",
+  "PROMOTION",
+  "MOBILE_APP",
+  "HEADLINE",
+  "DESCRIPTION",
+  "LOGO",
+  "MARKETING_IMAGE",
+  "BUSINESS_NAME"
+];
+var DEVICE_TYPES = ["MOBILE", "TABLET", "DESKTOP", "CONNECTED_TV", "OTHER"];
+var DAYS_OF_WEEK = ["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"];
+var CAMPAIGN_OBJECTIVES = [
+  "SALES",
+  "LEADS",
+  "WEBSITE_TRAFFIC",
+  "PRODUCT_BRAND_CONSIDERATION",
+  "BRAND_AWARENESS_REACH",
+  "APP_PROMOTION",
+  "LOCAL_STORE_VISITS"
+];
+var MICROS_PER_UNIT = 1e6;
+function toMicros(amount) {
+  return Math.round(amount * MICROS_PER_UNIT);
+}
+var PLAYBOOK_DAILY_BUDGET_FLOOR_MICROS = 10 * MICROS_PER_UNIT;
+var TEMP_REF_REGEX2 = /^g_temp_[A-Za-z0-9_-]{2,}$/;
+var NUMERIC_ID_REGEX2 = /^\d+$/;
+var RESOURCE_NAME_REGEX = /^customers\/\d+\/[A-Za-z]+\/[-\w~]+$/;
+var GEO_TARGET_CONSTANT_REGEX = /^geoTargetConstants\/\d+$/;
+var LANGUAGE_CONSTANT_REGEX = /^languageConstants\/\d+$/;
+
+// ../api/src/ads-google/ops.ts
+import { z as z8 } from "zod";
+var tempRefSchema2 = z8.string().regex(TEMP_REF_REGEX2, "expected a g_temp_* reference");
+var refSchema = z8.union([
+  z8.string().regex(RESOURCE_NAME_REGEX, "expected a customers/\u2026/\u2026/\u2026 resource name"),
+  z8.string().regex(NUMERIC_ID_REGEX2, "expected a numeric id"),
+  tempRefSchema2
+]);
+var targetRefSchema = refSchema;
+var microsSchema = z8.number().int().positive("expected a positive micros amount");
+var httpsUrlSchema2 = z8.string().url().refine((u) => u.startsWith("https://"), "final URLs must be https");
+var customerIdSchema = z8.string().regex(NUMERIC_ID_REGEX2, "customerId must be the bare numeric customer id");
+var stageableStatusSchema2 = z8.enum(STAGEABLE_CREATE_STATUSES2);
+var matchTypeSchema = z8.enum(KEYWORD_MATCH_TYPES);
+var keywordTextSchema = z8.string().min(1).max(GOOGLE_ADS_LIMITS.keyword.textMax).refine((t) => t.trim().split(/\s+/).length <= GOOGLE_ADS_LIMITS.keyword.wordsMax, "keyword exceeds 10 words");
+var budgetCreateSchema = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.budget.nameMax),
+  amountMicros: microsSchema,
+  deliveryMethod: z8.enum(BUDGET_DELIVERY_METHODS).default("STANDARD"),
+  explicitlyShared: z8.boolean().default(false)
+});
+var budgetUpdateSchema = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.budget.nameMax).optional(),
+  amountMicros: microsSchema.optional(),
+  deliveryMethod: z8.enum(BUDGET_DELIVERY_METHODS).optional()
+}).refine((p) => Object.values(p).some((v) => v !== void 0), "update needs at least one field");
+var biddingConfigSchema = z8.object({
+  type: z8.enum(BIDDING_STRATEGY_TYPES),
+  targetCpaMicros: microsSchema.optional(),
+  targetRoas: z8.number().positive().optional(),
+  cpcBidCeilingMicros: microsSchema.optional(),
+  enhancedCpcEnabled: z8.boolean().optional()
+}).superRefine((p, ctx) => {
+  if (p.type === "TARGET_CPA" && p.targetCpaMicros === void 0) {
+    ctx.addIssue({ code: "custom", path: ["targetCpaMicros"], message: "TARGET_CPA needs targetCpaMicros" });
+  }
+  if (p.type === "TARGET_ROAS" && p.targetRoas === void 0) {
+    ctx.addIssue({ code: "custom", path: ["targetRoas"], message: "TARGET_ROAS needs targetRoas" });
+  }
+});
+var networkSettingsSchema = z8.object({
+  targetGoogleSearch: z8.boolean().optional(),
+  targetSearchNetwork: z8.boolean().optional(),
+  targetContentNetwork: z8.boolean().optional(),
+  targetPartnerSearchNetwork: z8.boolean().optional()
+});
+var dateSchema = z8.string().regex(/^\d{4}-\d{2}-\d{2}$/, "expected a YYYY-MM-DD date");
+var campaignCreateSchema2 = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.campaign.nameMax),
+  channelType: z8.enum(ADVERTISING_CHANNEL_TYPES),
+  channelSubType: z8.enum(ADVERTISING_CHANNEL_SUB_TYPES).optional(),
+  budget: refSchema,
+  /** Inline standard bidding, or a portfolio strategy ref via biddingStrategy. */
+  bidding: biddingConfigSchema.optional(),
+  biddingStrategy: refSchema.optional(),
+  networkSettings: networkSettingsSchema.optional(),
+  startDate: dateSchema.optional(),
+  endDate: dateSchema.optional(),
+  /** Advisory Google Ads UI objective — drives warnings, not sent to the API. */
+  objective: z8.enum(CAMPAIGN_OBJECTIVES).optional(),
+  status: stageableStatusSchema2.default("PAUSED")
+}).superRefine((p, ctx) => {
+  if (!p.bidding && !p.biddingStrategy) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["bidding"],
+      message: "set an inline bidding strategy or reference a portfolio biddingStrategy"
+    });
+  }
+  if (p.bidding && p.biddingStrategy) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["bidding"],
+      message: "use inline bidding OR a portfolio biddingStrategy, not both"
+    });
+  }
+  if (p.channelType === "PERFORMANCE_MAX" && p.bidding && p.bidding.type === "MANUAL_CPC") {
+    ctx.addIssue({ code: "custom", path: ["bidding"], message: "Performance Max does not support Manual CPC" });
+  }
+  if (p.startDate && p.endDate && p.endDate <= p.startDate) {
+    ctx.addIssue({ code: "custom", path: ["endDate"], message: "endDate must be after startDate" });
+  }
+});
+var campaignUpdateSchema2 = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.campaign.nameMax).optional(),
+  budget: refSchema.optional(),
+  bidding: biddingConfigSchema.optional(),
+  networkSettings: networkSettingsSchema.optional(),
+  startDate: dateSchema.optional(),
+  endDate: dateSchema.optional(),
+  status: z8.enum(["ENABLED", "PAUSED", "REMOVED"]).optional()
+}).refine((p) => Object.values(p).some((v) => v !== void 0), "update needs at least one field");
+var adGroupCreateSchema = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.adGroup.nameMax),
+  campaign: refSchema,
+  type: z8.enum(AD_GROUP_TYPES).default("SEARCH_STANDARD"),
+  cpcBidMicros: microsSchema.optional(),
+  status: stageableStatusSchema2.default("PAUSED")
+});
+var adGroupUpdateSchema = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.adGroup.nameMax).optional(),
+  cpcBidMicros: microsSchema.optional(),
+  status: z8.enum(["ENABLED", "PAUSED", "REMOVED"]).optional()
+}).refine((p) => Object.values(p).some((v) => v !== void 0), "update needs at least one field");
+var keywordAddSchema = z8.object({
+  adGroup: refSchema,
+  text: keywordTextSchema,
+  matchType: matchTypeSchema,
+  cpcBidMicros: microsSchema.optional(),
+  finalUrls: z8.array(httpsUrlSchema2).optional(),
+  status: stageableStatusSchema2.default("ENABLED")
+});
+var keywordUpdateSchema = z8.object({
+  cpcBidMicros: microsSchema.optional(),
+  finalUrls: z8.array(httpsUrlSchema2).optional(),
+  status: z8.enum(["ENABLED", "PAUSED", "REMOVED"]).optional()
+}).refine((p) => Object.values(p).some((v) => v !== void 0), "update needs at least one field");
+var negativeKeywordAddSchema = z8.object({
+  level: z8.enum(["adGroup", "campaign"]),
+  parent: refSchema,
+  text: keywordTextSchema,
+  matchType: matchTypeSchema
+});
+var sharedSetCreateSchema = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.sharedSet.nameMax),
+  type: z8.enum(SHARED_SET_TYPES).default("NEGATIVE_KEYWORDS")
+});
+var sharedSetMemberAddSchema = z8.object({
+  sharedSet: refSchema,
+  text: keywordTextSchema,
+  matchType: matchTypeSchema
+});
+var campaignSharedSetAttachSchema = z8.object({
+  campaign: refSchema,
+  sharedSet: refSchema
+});
+var adTextAssetSchema = z8.object({
+  text: z8.string().min(1),
+  pinnedField: z8.enum(PINNED_FIELDS).optional()
+});
+var responsiveSearchAdSchema = z8.object({
+  format: z8.literal("responsiveSearch"),
+  headlines: z8.array(
+    adTextAssetSchema.refine(
+      (a) => a.text.length <= GOOGLE_ADS_LIMITS.responsiveSearchAd.headlineTextMax,
+      "headline exceeds 30 chars"
+    )
+  ).min(GOOGLE_ADS_LIMITS.responsiveSearchAd.headlinesMin).max(GOOGLE_ADS_LIMITS.responsiveSearchAd.headlinesMax),
+  descriptions: z8.array(
+    adTextAssetSchema.refine(
+      (a) => a.text.length <= GOOGLE_ADS_LIMITS.responsiveSearchAd.descriptionTextMax,
+      "description exceeds 90 chars"
+    )
+  ).min(GOOGLE_ADS_LIMITS.responsiveSearchAd.descriptionsMin).max(GOOGLE_ADS_LIMITS.responsiveSearchAd.descriptionsMax),
+  path1: z8.string().max(GOOGLE_ADS_LIMITS.responsiveSearchAd.pathMax).optional(),
+  path2: z8.string().max(GOOGLE_ADS_LIMITS.responsiveSearchAd.pathMax).optional(),
+  finalUrls: z8.array(httpsUrlSchema2).min(1)
+});
+var responsiveDisplayAdSchema = z8.object({
+  format: z8.literal("responsiveDisplay"),
+  headlines: z8.array(z8.object({ text: z8.string().min(1).max(GOOGLE_ADS_LIMITS.responsiveDisplayAd.headlineTextMax) })).min(1).max(5),
+  longHeadline: z8.object({ text: z8.string().min(1).max(GOOGLE_ADS_LIMITS.responsiveDisplayAd.longHeadlineTextMax) }),
+  descriptions: z8.array(z8.object({ text: z8.string().min(1).max(GOOGLE_ADS_LIMITS.responsiveDisplayAd.descriptionTextMax) })).min(1).max(5),
+  businessName: z8.string().min(1).max(GOOGLE_ADS_LIMITS.responsiveDisplayAd.businessNameMax),
+  marketingImageAssets: z8.array(refSchema).optional(),
+  logoImageAssets: z8.array(refSchema).optional(),
+  finalUrls: z8.array(httpsUrlSchema2).min(1)
+});
+var performanceMaxAssetGroupSchema = z8.object({
+  format: z8.literal("performanceMaxAssetGroup"),
+  name: z8.string().min(1).max(255),
+  headlines: z8.array(z8.object({ text: z8.string().min(1).max(30) })).min(3).max(15),
+  descriptions: z8.array(z8.object({ text: z8.string().min(1).max(90) })).min(2).max(5),
+  finalUrls: z8.array(httpsUrlSchema2).min(1),
+  imageAssets: z8.array(refSchema).optional(),
+  logoAssets: z8.array(refSchema).optional()
+});
+var callAdSchema = z8.object({
+  format: z8.literal("call"),
+  countryCode: z8.string().length(2),
+  phoneNumber: z8.string().min(3),
+  headline1: z8.string().min(1).max(30),
+  headline2: z8.string().min(1).max(30),
+  description1: z8.string().min(1).max(90),
+  description2: z8.string().min(1).max(90),
+  businessName: z8.string().min(1).max(25),
+  finalUrls: z8.array(httpsUrlSchema2).min(1)
+});
+var appAdSchema = z8.object({
+  format: z8.literal("app"),
+  headlines: z8.array(z8.object({ text: z8.string().min(1).max(30) })).min(1),
+  descriptions: z8.array(z8.object({ text: z8.string().min(1).max(90) })).min(1)
+});
+var videoAdSchema = z8.object({
+  format: z8.literal("video"),
+  youtubeVideoId: z8.string().min(1),
+  finalUrls: z8.array(httpsUrlSchema2).min(1)
+});
+var demandGenAdSchema = z8.object({
+  format: z8.literal("demandGen"),
+  headlines: z8.array(z8.object({ text: z8.string().min(1).max(40) })).min(1).max(5),
+  descriptions: z8.array(z8.object({ text: z8.string().min(1).max(90) })).min(1).max(5),
+  businessName: z8.string().min(1).max(25),
+  finalUrls: z8.array(httpsUrlSchema2).min(1),
+  imageAssets: z8.array(refSchema).optional()
+});
+var adContentSchema = z8.discriminatedUnion("format", [
+  responsiveSearchAdSchema,
+  responsiveDisplayAdSchema,
+  performanceMaxAssetGroupSchema,
+  callAdSchema,
+  appAdSchema,
+  videoAdSchema,
+  demandGenAdSchema
+]);
+var adCreateSchema = z8.object({
+  adGroup: refSchema,
+  status: stageableStatusSchema2.default("PAUSED"),
+  content: adContentSchema
+});
+var adUpdateSchema = z8.object({
+  status: z8.enum(["ENABLED", "PAUSED", "REMOVED"]).optional(),
+  /** Whole-content replacement for RSA-like formats; re-validated against adContentSchema. */
+  content: z8.record(z8.string(), z8.unknown()).optional()
+}).refine((p) => Object.values(p).some((v) => v !== void 0), "update needs at least one field");
+var textAssetSchema = z8.object({ type: z8.literal("text"), text: z8.string().min(1) });
+var imageAssetSchema = z8.object({
+  type: z8.literal("image"),
+  imageId: z8.string().min(1),
+  name: z8.string().optional()
+});
+var youtubeVideoAssetSchema = z8.object({
+  type: z8.literal("youtubeVideo"),
+  youtubeVideoId: z8.string().min(1),
+  name: z8.string().optional()
+});
+var sitelinkAssetSchema = z8.object({
+  type: z8.literal("sitelink"),
+  linkText: z8.string().min(1).max(GOOGLE_ADS_LIMITS.asset.sitelinkLinkTextMax),
+  description1: z8.string().max(GOOGLE_ADS_LIMITS.asset.sitelinkDescriptionMax).optional(),
+  description2: z8.string().max(GOOGLE_ADS_LIMITS.asset.sitelinkDescriptionMax).optional(),
+  finalUrls: z8.array(httpsUrlSchema2).min(1)
+});
+var calloutAssetSchema = z8.object({
+  type: z8.literal("callout"),
+  calloutText: z8.string().min(1).max(GOOGLE_ADS_LIMITS.asset.calloutTextMax)
+});
+var structuredSnippetAssetSchema = z8.object({
+  type: z8.literal("structuredSnippet"),
+  header: z8.string().min(1).max(GOOGLE_ADS_LIMITS.asset.structuredSnippetHeaderMax),
+  values: z8.array(z8.string().min(1)).min(GOOGLE_ADS_LIMITS.asset.structuredSnippetValuesMin).max(GOOGLE_ADS_LIMITS.asset.structuredSnippetValuesMax)
+});
+var callToActionAssetSchema = z8.object({ type: z8.literal("callToAction"), callToAction: z8.string().min(1) });
+var assetCreateSchema = z8.discriminatedUnion("type", [
+  textAssetSchema,
+  imageAssetSchema,
+  youtubeVideoAssetSchema,
+  sitelinkAssetSchema,
+  calloutAssetSchema,
+  structuredSnippetAssetSchema,
+  callToActionAssetSchema
+]);
+var assetLinkAttachSchema = z8.object({
+  level: z8.enum(["campaign", "adGroup", "customer"]),
+  parent: refSchema.optional(),
+  asset: refSchema,
+  fieldType: z8.enum(ASSET_FIELD_TYPES)
+}).superRefine((value, ctx) => {
+  if (value.level !== "customer" && !value.parent) {
+    ctx.addIssue({
+      code: z8.ZodIssueCode.custom,
+      path: ["parent"],
+      message: `parent is required for a ${value.level}-level asset link (--parent-ref)`
+    });
+  }
+});
+var audienceCreateSchema2 = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.audience.nameMax),
+  type: z8.enum(USER_LIST_TYPES).default("BASIC"),
+  description: z8.string().optional(),
+  /** Customer-match members (crm-based) — file-first for large lists. */
+  members: z8.array(z8.record(z8.string(), z8.string())).optional(),
+  sourceFileRef: z8.string().optional()
+});
+var audienceCriterionAttachSchema = z8.object({
+  level: z8.enum(["campaign", "adGroup"]),
+  parent: refSchema,
+  userList: refSchema,
+  negative: z8.boolean().default(false)
+});
+var conversionActionCreateSchema = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.conversionAction.nameMax),
+  type: z8.enum(CONVERSION_ACTION_TYPES).default("WEBPAGE"),
+  category: z8.enum(CONVERSION_ACTION_CATEGORIES).default("DEFAULT"),
+  countingType: z8.enum(CONVERSION_COUNTING_TYPES).default("ONE_PER_CLICK"),
+  defaultValueMicros: microsSchema.optional(),
+  defaultCurrencyCode: z8.string().length(3).optional(),
+  clickThroughLookbackWindowDays: z8.number().int().positive().optional(),
+  viewThroughLookbackWindowDays: z8.number().int().positive().optional(),
+  status: z8.enum(["ENABLED", "PAUSED"]).default("ENABLED")
+});
+var conversionActionUpdateSchema = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.conversionAction.nameMax).optional(),
+  category: z8.enum(CONVERSION_ACTION_CATEGORIES).optional(),
+  countingType: z8.enum(CONVERSION_COUNTING_TYPES).optional(),
+  defaultValueMicros: microsSchema.optional(),
+  status: z8.enum(["ENABLED", "REMOVED", "HIDDEN"]).optional()
+}).refine((p) => Object.values(p).some((v) => v !== void 0), "update needs at least one field");
+var biddingStrategyCreateSchema = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.biddingStrategy.nameMax),
+  config: biddingConfigSchema
+}).superRefine((p, ctx) => {
+  if (p.config.type === "MANUAL_CPC") {
+    ctx.addIssue({ code: "custom", path: ["config", "type"], message: "portfolio strategies cannot be Manual CPC" });
+  }
+});
+var biddingStrategyUpdateSchema = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.biddingStrategy.nameMax).optional(),
+  config: biddingConfigSchema.optional()
+}).refine((p) => Object.values(p).some((v) => v !== void 0), "update needs at least one field");
+var labelCreateSchema = z8.object({
+  name: z8.string().min(1).max(GOOGLE_ADS_LIMITS.label.nameMax),
+  backgroundColor: z8.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
+  description: z8.string().optional()
+});
+var labelAttachSchema = z8.object({
+  level: z8.enum(["campaign", "adGroup", "ad"]),
+  parent: refSchema,
+  label: refSchema
+});
+var locationCriterionSchema = z8.object({
+  criterionType: z8.literal("location"),
+  geoTargetConstant: z8.union([z8.string().regex(GEO_TARGET_CONSTANT_REGEX), z8.string().regex(NUMERIC_ID_REGEX2)])
+});
+var languageCriterionSchema = z8.object({
+  criterionType: z8.literal("language"),
+  languageConstant: z8.union([z8.string().regex(LANGUAGE_CONSTANT_REGEX), z8.string().regex(NUMERIC_ID_REGEX2)])
+});
+var adScheduleCriterionSchema = z8.object({
+  criterionType: z8.literal("adSchedule"),
+  dayOfWeek: z8.enum(DAYS_OF_WEEK),
+  startHour: z8.number().int().min(0).max(23),
+  startMinute: z8.enum(["ZERO", "FIFTEEN", "THIRTY", "FORTY_FIVE"]).default("ZERO"),
+  endHour: z8.number().int().min(0).max(24),
+  endMinute: z8.enum(["ZERO", "FIFTEEN", "THIRTY", "FORTY_FIVE"]).default("ZERO")
+});
+var deviceCriterionSchema = z8.object({
+  criterionType: z8.literal("device"),
+  device: z8.enum(DEVICE_TYPES),
+  bidModifier: z8.number().min(0.1).max(10).optional()
+});
+var campaignCriterionAddSchema = z8.object({
+  campaign: refSchema,
+  negative: z8.boolean().default(false),
+  criterion: z8.discriminatedUnion("criterionType", [
+    locationCriterionSchema,
+    languageCriterionSchema,
+    adScheduleCriterionSchema,
+    deviceCriterionSchema
+  ])
+});
+var GOOGLE_DRAFT_OP_KINDS = [
+  "google.budget.create",
+  "google.budget.update",
+  "google.campaign.create",
+  "google.campaign.update",
+  "google.campaign.pause",
+  "google.campaign.resume",
+  "google.campaign.remove",
+  "google.adGroup.create",
+  "google.adGroup.update",
+  "google.adGroup.pause",
+  "google.adGroup.resume",
+  "google.adGroup.remove",
+  "google.keyword.add",
+  "google.keyword.update",
+  "google.keyword.remove",
+  "google.negativeKeyword.add",
+  "google.negativeKeyword.remove",
+  "google.sharedSet.create",
+  "google.sharedSetMember.add",
+  "google.sharedSetMember.remove",
+  "google.campaignSharedSet.attach",
+  "google.campaignSharedSet.detach",
+  "google.ad.create",
+  "google.ad.update",
+  "google.ad.pause",
+  "google.ad.resume",
+  "google.ad.remove",
+  "google.asset.create",
+  "google.assetLink.attach",
+  "google.assetLink.detach",
+  "google.audience.create",
+  "google.audienceCriterion.attach",
+  "google.audienceCriterion.detach",
+  "google.conversionAction.create",
+  "google.conversionAction.update",
+  "google.biddingStrategy.create",
+  "google.biddingStrategy.update",
+  "google.label.create",
+  "google.label.attach",
+  "google.campaignCriterion.add",
+  "google.campaignCriterion.remove"
+];
+var googleDraftOpKindSchema = z8.enum(GOOGLE_DRAFT_OP_KINDS);
+function createOp2(kind, payload) {
+  return z8.object({ kind: z8.literal(kind), customerId: customerIdSchema, payload });
+}
+function updateOp2(kind, payload) {
+  return z8.object({ kind: z8.literal(kind), customerId: customerIdSchema, target: targetRefSchema, payload });
+}
+function targetOp(kind) {
+  return z8.object({ kind: z8.literal(kind), customerId: customerIdSchema, target: targetRefSchema });
+}
+var googleDraftOpInputSchema = z8.discriminatedUnion("kind", [
+  createOp2("google.budget.create", budgetCreateSchema),
+  updateOp2("google.budget.update", budgetUpdateSchema),
+  createOp2("google.campaign.create", campaignCreateSchema2),
+  updateOp2("google.campaign.update", campaignUpdateSchema2),
+  targetOp("google.campaign.pause"),
+  targetOp("google.campaign.resume"),
+  targetOp("google.campaign.remove"),
+  createOp2("google.adGroup.create", adGroupCreateSchema),
+  updateOp2("google.adGroup.update", adGroupUpdateSchema),
+  targetOp("google.adGroup.pause"),
+  targetOp("google.adGroup.resume"),
+  targetOp("google.adGroup.remove"),
+  createOp2("google.keyword.add", keywordAddSchema),
+  updateOp2("google.keyword.update", keywordUpdateSchema),
+  targetOp("google.keyword.remove"),
+  createOp2("google.negativeKeyword.add", negativeKeywordAddSchema),
+  targetOp("google.negativeKeyword.remove"),
+  createOp2("google.sharedSet.create", sharedSetCreateSchema),
+  createOp2("google.sharedSetMember.add", sharedSetMemberAddSchema),
+  targetOp("google.sharedSetMember.remove"),
+  createOp2("google.campaignSharedSet.attach", campaignSharedSetAttachSchema),
+  targetOp("google.campaignSharedSet.detach"),
+  createOp2("google.ad.create", adCreateSchema),
+  updateOp2("google.ad.update", adUpdateSchema),
+  targetOp("google.ad.pause"),
+  targetOp("google.ad.resume"),
+  targetOp("google.ad.remove"),
+  createOp2("google.asset.create", assetCreateSchema),
+  createOp2("google.assetLink.attach", assetLinkAttachSchema),
+  targetOp("google.assetLink.detach"),
+  createOp2("google.audience.create", audienceCreateSchema2),
+  createOp2("google.audienceCriterion.attach", audienceCriterionAttachSchema),
+  targetOp("google.audienceCriterion.detach"),
+  createOp2("google.conversionAction.create", conversionActionCreateSchema),
+  updateOp2("google.conversionAction.update", conversionActionUpdateSchema),
+  createOp2("google.biddingStrategy.create", biddingStrategyCreateSchema),
+  updateOp2("google.biddingStrategy.update", biddingStrategyUpdateSchema),
+  createOp2("google.label.create", labelCreateSchema),
+  createOp2("google.label.attach", labelAttachSchema),
+  createOp2("google.campaignCriterion.add", campaignCriterionAddSchema),
+  targetOp("google.campaignCriterion.remove")
+]);
+
+// ../api/src/ads-google/wire.ts
+import { z as z9 } from "zod";
+var googleWriteModeSchema = z9.enum(["live", "simulated"]);
+var googleDraftOpResultSchema = z9.object({
+  status: z9.enum(["applied", "simulated", "failed", "skipped"]),
+  resourceName: z9.string().optional(),
+  error: z9.string().optional(),
+  skippedBecause: z9.string().optional(),
+  executedAt: z9.number().optional()
+});
+var googleDraftStageRequestSchema = z9.object({
+  chatId: z9.string(),
+  op: googleDraftOpInputSchema
+});
+var googleDraftStageResponseSchema = z9.object({
+  staged: z9.literal(true),
+  ref: z9.string(),
+  kind: googleDraftOpKindSchema,
+  mode: googleWriteModeSchema,
+  dependsOn: z9.array(z9.string()),
+  summary: z9.string(),
+  warnings: z9.array(z9.string()),
+  /** True when the op amended an already-staged op in place instead of appending a new one. */
+  amended: z9.boolean().optional()
+});
+var GOOGLE_DRAFT_BATCH_MAX = 500;
+var googleDraftStageBatchRequestSchema = z9.object({
+  chatId: z9.string(),
+  ops: z9.array(googleDraftOpInputSchema).min(1).max(GOOGLE_DRAFT_BATCH_MAX)
+});
+var googleDraftStageBatchResponseSchema = z9.object({
+  staged: z9.literal(true),
+  mode: googleWriteModeSchema,
+  count: z9.number(),
+  ops: z9.array(
+    z9.object({
+      ref: z9.string(),
+      kind: googleDraftOpKindSchema,
+      dependsOn: z9.array(z9.string()),
+      summary: z9.string(),
+      warnings: z9.array(z9.string())
+    })
+  )
+});
+var googleDraftOpViewSchema = z9.object({
+  ref: z9.string(),
+  kind: googleDraftOpKindSchema,
+  customerId: z9.string(),
+  target: z9.string().optional(),
+  dependsOn: z9.array(z9.string()),
+  summary: z9.string(),
+  stagedAt: z9.number(),
+  result: googleDraftOpResultSchema.optional()
+});
+var googleDraftListRequestSchema = z9.object({
+  chatId: z9.string()
+});
+var googleDraftAdvisorySchema = z9.object({
+  scope: z9.enum(["campaign", "adGroup"]),
+  message: z9.string()
+});
+var googleDraftStatusCollectionSchema = z9.object({
+  label: z9.string(),
+  added: z9.number(),
+  removed: z9.number(),
+  existing: z9.number()
+});
+var googleDraftChangeOperationSchema = z9.enum(["create", "update", "pause", "resume", "remove"]);
+var googleDraftStatusNodeSchema = z9.lazy(
+  () => z9.object({
+    entity: z9.string(),
+    name: z9.string(),
+    operation: googleDraftChangeOperationSchema.optional(),
+    existing: z9.boolean(),
+    collections: z9.array(googleDraftStatusCollectionSchema),
+    children: z9.array(googleDraftStatusNodeSchema)
+  })
+);
+var googleDraftListResponseSchema = z9.object({
+  status: z9.enum(["active", "publishing", "applied", "discarded", "none"]),
+  mode: googleWriteModeSchema,
+  count: z9.number(),
+  ops: z9.array(googleDraftOpViewSchema),
+  /** Grouped campaign ▸ ad group ▸ ad tree for the readable CLI status view. */
+  tree: z9.array(googleDraftStatusNodeSchema).optional(),
+  /** Non-blocking completeness advisories for the whole draft. */
+  advisories: z9.array(googleDraftAdvisorySchema).optional()
+});
+var googleDraftRemoveRequestSchema = z9.object({
+  chatId: z9.string(),
+  ref: z9.string()
+});
+var googleDraftRemoveResponseSchema = z9.object({
+  /** The requested ref plus any dependents removed by cascade. */
+  removed: z9.array(z9.string())
+});
+var googleDraftClearRequestSchema = z9.object({
+  chatId: z9.string()
+});
+var googleDraftClearResponseSchema = z9.object({
+  cleared: z9.number()
+});
+var googleFieldErrorSchema = z9.object({
+  path: z9.string(),
+  message: z9.string()
+});
+var googleDraftErrorResponseSchema = z9.object({
+  code: z9.string(),
+  error: z9.string(),
+  fields: z9.array(googleFieldErrorSchema).optional()
+});
+
+// src/commands/ads/google/draft-status.ts
+var OPERATION_LABELS = {
+  create: "Creating",
+  update: "Updating",
+  pause: "Pausing",
+  resume: "Resuming",
+  remove: "Removing"
+};
+function badge(node) {
+  const label = node.operation ? OPERATION_LABELS[node.operation] : void 0;
+  if (label) {
+    return label;
+  }
+  return node.existing ? "on Google Ads" : "staged";
+}
+function collectionLine(collection) {
+  const parts = [];
+  if (collection.added > 0) {
+    parts.push(`+${collection.added}`);
+  }
+  if (collection.existing > 0) {
+    parts.push(`${collection.existing} existing`);
+  }
+  if (collection.removed > 0) {
+    parts.push(`-${collection.removed}`);
+  }
+  return parts.length > 0 ? `${collection.label}: ${parts.join(", ")}` : void 0;
+}
+function renderNode(node, depth, lines) {
+  const indent = "  ".repeat(depth);
+  lines.push(`${indent}\u2022 ${node.name} \xB7 ${badge(node)}`);
+  for (const collection of node.collections) {
+    const line = collectionLine(collection);
+    if (line) {
+      lines.push(`${indent}    ${line}`);
+    }
+  }
+  for (const child of node.children) {
+    renderNode(child, depth + 1, lines);
+  }
+}
+var RESOURCE_ENTITIES = /* @__PURE__ */ new Set([
+  "sharedSet",
+  "biddingStrategy",
+  "audience",
+  "conversionAction",
+  "label",
+  "budget",
+  "asset"
+]);
+function renderSection(title, nodes, lines) {
+  if (nodes.length === 0) {
+    return;
+  }
+  lines.push("");
+  lines.push(title);
+  for (const node of nodes) {
+    renderNode(node, 1, lines);
+  }
+}
+function renderAdvisories(data, lines) {
+  const advisories = data.advisories ?? [];
+  if (advisories.length === 0) {
+    return;
+  }
+  lines.push("");
+  lines.push("Advisories (non-blocking \u2014 build these out for a higher-performance campaign)");
+  for (const advisory of advisories) {
+    lines.push(`  \u2022 ${advisory.message}`);
+  }
+}
+function renderDraftStatus(data) {
+  if (data.status === "none" || data.count === 0) {
+    return "No staged Google Ads changes on this chat.";
+  }
+  const modeNote = data.mode === "live" ? "Live \u2014 publishing writes directly to Google Ads." : "Simulated \u2014 publishing completes the whole draft without calling Google Ads.";
+  const lines = [
+    `Google Ads \u2014 ${data.count} staged change${data.count === 1 ? "" : "s"} \xB7 ${data.mode}`,
+    modeNote
+  ];
+  const tree = data.tree ?? [];
+  renderSection(
+    "Shared resources",
+    tree.filter((node) => RESOURCE_ENTITIES.has(node.entity)),
+    lines
+  );
+  renderSection(
+    "Campaigns",
+    tree.filter((node) => node.entity === "campaign"),
+    lines
+  );
+  const rest = tree.filter((node) => !RESOURCE_ENTITIES.has(node.entity) && node.entity !== "campaign");
+  renderSection("Other", rest, lines);
+  renderAdvisories(data, lines);
+  return lines.join("\n");
+}
+
+// src/commands/ads/google/write-shared.ts
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function requireCustomerId(args) {
+  const raw = args["customer-id"] ?? args.customerId;
+  if (!raw || !/^\d{10}$/.test(raw)) {
+    failWriteValidation("pass --customer-id as the 10-digit Google Ads customer id (no dashes)");
+  }
+  return raw;
+}
+function requireTarget(args, entity) {
+  const positional = Array.isArray(args._) ? args._[0] : void 0;
+  const target = args.id ?? args.target ?? positional;
+  if (typeof target !== "string" || target.length === 0) {
+    failWriteValidation(`pass the ${entity} resource name or id as the positional argument`);
+  }
+  return target;
+}
+function requireStringFlag(value, flag) {
+  if (typeof value !== "string" || value.length === 0) {
+    failWriteValidation(`${flag} is required`);
+  }
+  return value;
+}
+function microsFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const num = Number(value);
+  if (Number.isNaN(num) || num <= 0) {
+    failWriteValidation(`${flag} must be a positive amount (major currency units, e.g. 50 or 50.00)`);
+  }
+  return toMicros(num);
+}
+function listFlag(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  const items = value.split(",").map((v) => v.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+var MATCH_TYPES = /* @__PURE__ */ new Set(["EXACT", "PHRASE", "BROAD"]);
+function parseKeywordEntry(raw, defaultMatch) {
+  const colon = raw.lastIndexOf(":");
+  if (colon > 0) {
+    const suffix = raw.slice(colon + 1).trim().toUpperCase();
+    if (MATCH_TYPES.has(suffix)) {
+      return { text: raw.slice(0, colon).trim(), matchType: suffix };
+    }
+    failWriteValidation(`"${raw}": ":${raw.slice(colon + 1)}" is not a match type (EXACT | PHRASE | BROAD)`);
+  }
+  if (!defaultMatch) {
+    failWriteValidation(`"${raw}" has no match type \u2014 add a :EXACT/:PHRASE/:BROAD suffix or pass --match-type`);
+  }
+  return { text: raw, matchType: defaultMatch };
+}
+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(path12) {
+  if (typeof path12 !== "string" || path12.length === 0) {
+    return [];
+  }
+  return readFileSync3(path12, "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;
+  const raw = [...rawTextEntries(args.text), ...rawFileEntries(args.file)];
+  if (raw.length === 0) {
+    failWriteValidation("pass keywords via --text (comma-separated) and/or --file (one per line)");
+  }
+  if (raw.length > GOOGLE_DRAFT_BATCH_MAX) {
+    failWriteValidation(`${raw.length} keywords exceeds the batch limit of ${GOOGLE_DRAFT_BATCH_MAX}`);
+  }
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    const entry = parseKeywordEntry(item, defaultMatch);
+    const key = `${entry.text}\0${entry.matchType}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+function loadJsonFileArg(path12) {
+  if (typeof path12 !== "string" || path12.length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync3(path12, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failWriteValidation(`${path12} must contain a JSON object`);
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      failWriteValidation(`${path12} is not valid JSON: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function mergePayload(file, flags) {
+  const merged = { ...file };
+  for (const [key, value] of Object.entries(flags)) {
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function handleGoogleError(err) {
+  if (err instanceof ApiError) {
+    writeJsonEnvelope({ ok: false, error: { code: err.code ?? "API_ERROR", message: err.message } });
+    process.exit(1);
+  }
+  writeJsonEnvelope({
+    ok: false,
+    error: { code: "UNKNOWN", message: err instanceof Error ? err.message : String(err) }
+  });
+  process.exit(1);
+}
+async function stageGoogleOp(raw) {
+  const preflight = googleDraftOpInputSchema.safeParse(raw);
+  if (!preflight.success) {
+    const fields = preflight.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message }));
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: fields.map((f) => f.path ? `${f.path}: ${f.message}` : f.message).join("; "),
+        fields
+      }
+    });
+    process.exit(1);
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/google/draft/stage", { chatId, op: preflight.data });
+    writeJsonEnvelope(response);
+  } catch (err) {
+    handleGoogleError(err);
+  }
+}
+async function stageCreate(kind, customerId, payload) {
+  await stageGoogleOp({ kind, customerId, payload });
+}
+async function stageGoogleOps(rawOps) {
+  if (rawOps.length === 1 && rawOps[0]) {
+    await stageGoogleOp(rawOps[0]);
+    return;
+  }
+  const ops = [];
+  for (const [index, raw] of rawOps.entries()) {
+    const preflight = googleDraftOpInputSchema.safeParse(raw);
+    if (!preflight.success) {
+      const fields = preflight.error.issues.map((issue) => ({
+        path: `ops[${index}].${issue.path.join(".")}`,
+        message: issue.message
+      }));
+      writeJsonEnvelope({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: fields.map((f) => `${f.path}: ${f.message}`).join("; "),
+          fields
+        }
+      });
+      process.exit(1);
+    }
+    ops.push(preflight.data);
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/google/draft/stage-batch", { chatId, ops });
+    writeJsonEnvelope(response);
+  } catch (err) {
+    handleGoogleError(err);
+  }
+}
+async function stageUpdate(kind, customerId, target, payload) {
+  await stageGoogleOp({ kind, customerId, target, payload });
+}
+async function stageTarget(kind, customerId, target) {
+  await stageGoogleOp({ kind, customerId, target });
+}
+async function draftAction(path12, body) {
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost(path12, { chatId, ...body });
+    writeJsonEnvelope(response);
+  } catch (err) {
+    handleGoogleError(err);
+  }
+}
+async function draftListAction(json) {
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/google/draft", { chatId });
+    if (json || !response.ok || !response.data) {
+      writeJsonEnvelope(response);
+      return;
+    }
+    process.stdout.write(`${renderDraftStatus(response.data)}
+`);
+  } catch (err) {
+    handleGoogleError(err);
+  }
+}
+
+// src/commands/ads/google/draft.ts
+var draftCommand2 = defineCommand22({
+  meta: { name: "draft", description: "List, remove, or clear staged Google Ads write ops for this chat" },
+  subCommands: {
+    list: defineCommand22({
+      meta: {
+        name: "list",
+        description: "Review everything staged as a campaign \u25B8 ad group \u25B8 ad tree (--json for the raw envelope)"
+      },
+      args: { json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable tree" } },
+      run: async ({ args }) => {
+        await draftListAction(args.json === true);
+      }
+    }),
+    remove: defineCommand22({
+      meta: { name: "remove", description: "Remove one staged op (cascades to dependents)" },
+      args: { ref: { type: "positional", description: "Staged op ref (g_temp_* or target)", required: false } },
+      run: async ({ args }) => {
+        await draftAction("/api/ads/google/draft/remove", { ref: requireTarget(args, "op") });
+      }
+    }),
+    clear: defineCommand22({
+      meta: { name: "clear", description: "Discard all staged ops on this chat" },
+      run: async () => {
+        await draftAction("/api/ads/google/draft/clear", {});
+      }
+    })
+  }
+});
+
 // src/commands/ads/google/keywords/index.ts
-import { defineCommand as defineCommand26 } from "citty";
+import { defineCommand as defineCommand27 } from "citty";
 
 // src/commands/ads/google/keywords/discover.ts
-import { defineCommand as defineCommand22 } from "citty";
+import { defineCommand as defineCommand23 } from "citty";
 
 // src/geo-context.ts
 var GOOGLE_ADS_LOCATIONS = [
@@ -4114,7 +5252,7 @@ function handleKeywordError(err) {
   writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
   process.exit(1);
 }
-var discoverCommand = defineCommand22({
+var discoverCommand = defineCommand23({
   meta: {
     name: "discover",
     description: `Discover new keyword ideas from seed keywords or competitor URLs.
@@ -4176,7 +5314,7 @@ Examples:
 });
 
 // src/commands/ads/google/keywords/languages.ts
-import { defineCommand as defineCommand23 } from "citty";
+import { defineCommand as defineCommand24 } from "citty";
 registerSchema({
   command: "ads.google.keywords.languages",
   description: "List all supported language IDs for --language flag in Google Ads keyword commands.",
@@ -4186,7 +5324,7 @@ var FIELDS = {
   id: "Language ID to pass as --language",
   name: "Language name"
 };
-var languagesCommand = defineCommand23({
+var languagesCommand = defineCommand24({
   meta: {
     name: "languages",
     description: "List all supported language IDs for --language flag."
@@ -4197,7 +5335,7 @@ var languagesCommand = defineCommand23({
 });
 
 // src/commands/ads/google/keywords/locations.ts
-import { defineCommand as defineCommand24 } from "citty";
+import { defineCommand as defineCommand25 } from "citty";
 registerSchema({
   command: "ads.google.keywords.locations",
   description: "List all supported geo target IDs for --location flag in Google Ads keyword commands.",
@@ -4207,7 +5345,7 @@ var FIELDS2 = {
   id: "Geo target ID to pass as --location",
   name: "Country/region name"
 };
-var locationsCommand = defineCommand24({
+var locationsCommand = defineCommand25({
   meta: {
     name: "locations",
     description: "List all supported geo target IDs for --location flag."
@@ -4218,7 +5356,7 @@ var locationsCommand = defineCommand24({
 });
 
 // src/commands/ads/google/keywords/metrics.ts
-import { defineCommand as defineCommand25 } from "citty";
+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.",
@@ -4242,7 +5380,7 @@ registerSchema({
     output: { type: "string", description: "Format: json|csv|jsonl|md", required: false, default: "json" }
   }
 });
-var metricsCommand = defineCommand25({
+var metricsCommand = defineCommand26({
   meta: {
     name: "metrics",
     description: `Get historical search metrics for specific keywords.
@@ -4329,7 +5467,7 @@ Examples:
 });
 
 // src/commands/ads/google/keywords/index.ts
-var keywordsCommand = defineCommand26({
+var keywordsCommand = defineCommand27({
   meta: {
     name: "keywords",
     description: `Keyword research tools. Subcommands: discover, metrics, locations, languages.
@@ -4349,8 +5487,8 @@ Examples:
 });
 
 // src/commands/ads/google/library/index.ts
-import { defineCommand as defineCommand27 } from "citty";
-var listAdvertisers = defineCommand27({
+import { defineCommand as defineCommand28 } from "citty";
+var listAdvertisers = defineCommand28({
   meta: {
     name: "list-advertisers",
     description: "List tracked Google advertisers and their accounts"
@@ -4367,7 +5505,7 @@ var listAdvertisers = defineCommand27({
     }
   }
 });
-var syncStatus = defineCommand27({
+var syncStatus = defineCommand28({
   meta: {
     name: "sync-status",
     description: "Check the sync status and ad counts of a Google account"
@@ -4387,7 +5525,7 @@ var syncStatus = defineCommand27({
     writeAdsJson({ ok: true, data });
   }
 });
-var searchAds = defineCommand27({
+var searchAds = defineCommand28({
   meta: {
     name: "search-ads",
     description: "Search and filter Google ads for an account"
@@ -4444,7 +5582,7 @@ var searchAds = defineCommand27({
     }
   }
 });
-var searchAdvertiser = defineCommand27({
+var searchAdvertiser = defineCommand28({
   meta: {
     name: "search-advertiser",
     description: "Search for an advertiser on the Google Ads Transparency Center"
@@ -4479,7 +5617,7 @@ var searchAdvertiser = defineCommand27({
 function sleep(ms) {
   return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
-var track = defineCommand27({
+var track = defineCommand28({
   meta: {
     name: "track",
     description: "Track a new Google advertiser (from search results). Waits for initial sync to complete before returning."
@@ -4537,7 +5675,7 @@ var track = defineCommand27({
     process.exit(1);
   }
 });
-var sync = defineCommand27({
+var sync = defineCommand28({
   meta: {
     name: "sync",
     description: "Trigger an immediate sync for a Google account. Waits for completion before returning."
@@ -4581,7 +5719,7 @@ var sync = defineCommand27({
     process.exit(1);
   }
 });
-var searchCompetitors = defineCommand27({
+var searchCompetitors = defineCommand28({
   meta: {
     name: "search-competitors",
     description: "Search for competitors running Google ads for a keyword (DataForSEO)"
@@ -4613,7 +5751,7 @@ var searchCompetitors = defineCommand27({
     }
   }
 });
-var library = defineCommand27({
+var library = defineCommand28({
   meta: {
     name: "library",
     description: "Manage and search the Google Ads Library"
@@ -4630,9 +5768,9 @@ var library = defineCommand27({
 });
 
 // src/commands/ads/google/query.ts
-import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 import { resolve } from "path";
-import { defineCommand as defineCommand28 } from "citty";
+import { defineCommand as defineCommand29 } from "citty";
 
 // src/commands/ads/google/preflight.ts
 function buildCommand2(query, customerId) {
@@ -4653,6 +5791,24 @@ function applyAutoFixes(query, limit) {
     corrected = corrected.replace(/shopping_performance_view\.product_(\w+)/g, "segments.product_$1");
     warnings.push({ code: "FIELD_RENAMED", message: "shopping_performance_view.product_* \u2192 segments.product_*" });
   }
+  if (/asset\.\w+_asset\.final_(mobile_)?urls\b/.test(corrected)) {
+    corrected = corrected.replace(/asset\.\w+_asset\.final_(mobile_)?urls\b/g, "asset.final_$1urls");
+    warnings.push({ code: "FIELD_RENAMED", message: "asset.<type>_asset.final_urls \u2192 asset.final_urls" });
+  }
+  if (/FROM\s+campaign_budget\b/i.test(corrected)) {
+    const whereClause = corrected.split(/\bWHERE\b/i)[1] ?? "";
+    const selectClause = corrected.split(/\bFROM\b/i)[0] ?? "";
+    const missing = [...new Set(whereClause.match(/campaign\.[\w.]+/g) ?? [])].filter(
+      (field) => !selectClause.includes(field)
+    );
+    if (missing.length > 0) {
+      corrected = corrected.replace(/SELECT\s+/i, `SELECT ${missing.join(", ")}, `);
+      warnings.push({
+        code: "REQUIRED_FIELD_ADDED",
+        message: `Added ${missing.join(", ")} to SELECT \u2014 campaign_budget queries must select campaign fields used in WHERE`
+      });
+    }
+  }
   if (/campaign\.status\s*=\s*'ACTIVE'/i.test(corrected)) {
     corrected = corrected.replace(/campaign\.status\s*=\s*'ACTIVE'/gi, "campaign.status = 'ENABLED'");
     warnings.push({ code: "ENUM_CORRECTED", message: "campaign.status ACTIVE \u2192 ENABLED" });
@@ -4924,7 +6080,7 @@ function writeRowsToFile(filePath, rows, fields, append) {
 `, "utf-8");
     }
   } else if (append && existsSync3(filePath)) {
-    const existing = JSON.parse(readFileSync3(filePath, "utf-8"));
+    const existing = JSON.parse(readFileSync4(filePath, "utf-8"));
     writeFileSync2(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync2(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -5088,7 +6244,7 @@ function handleQueryError(err, finalQuery, customerId) {
   });
   process.exit(1);
 }
-var queryCommand = defineCommand28({
+var queryCommand = defineCommand29({
   meta: {
     name: "query",
     description: `Run GAQL queries against Google Ads. Supports raw GAQL, presets, pagination, file export, and caching.
@@ -5145,8 +6301,546 @@ Examples:
   }
 });
 
+// src/commands/ads/google/write-commands.ts
+import { defineCommand as defineCommand30 } from "citty";
+var customerIdArg = { "customer-id": { type: "string", description: "10-digit Google Ads customer id" } };
+var fileArg = {
+  file: { type: "string", description: "JSON file with the full op payload (flags override)" }
+};
+var budgetsCommand = defineCommand30({
+  meta: { name: "budgets", description: "Stage campaign budget create/update" },
+  subCommands: {
+    create: defineCommand30({
+      meta: { name: "create", description: "Stage a campaign budget" },
+      args: {
+        ...customerIdArg,
+        ...fileArg,
+        name: { type: "string", description: "Budget name" },
+        amount: { type: "string", description: "Daily amount in major currency units (e.g. 50)" },
+        delivery: { type: "string", description: "STANDARD | ACCELERATED" },
+        shared: { type: "boolean", description: "Explicitly shared budget" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        const payload = mergePayload(loadJsonFileArg(args.file), {
+          name: args.name,
+          amountMicros: microsFlag(args.amount, "--amount"),
+          deliveryMethod: args.delivery,
+          explicitlyShared: args.shared || void 0
+        });
+        await stageCreate("google.budget.create", customerId, payload);
+      }
+    }),
+    update: defineCommand30({
+      meta: { name: "update", description: "Stage a budget update" },
+      args: {
+        ...customerIdArg,
+        ...fileArg,
+        name: { type: "string" },
+        amount: { type: "string", description: "New daily amount in major currency units" },
+        delivery: { type: "string" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        const target = requireTarget(args, "budget");
+        const payload = mergePayload(loadJsonFileArg(args.file), {
+          name: args.name,
+          amountMicros: microsFlag(args.amount, "--amount"),
+          deliveryMethod: args.delivery
+        });
+        await stageUpdate("google.budget.update", customerId, target, payload);
+      }
+    })
+  }
+});
+function biddingFromFlags(args) {
+  const type = args["bidding-strategy"];
+  if (!type) {
+    return void 0;
+  }
+  return {
+    type,
+    targetCpaMicros: microsFlag(args["target-cpa"], "--target-cpa"),
+    targetRoas: args["target-roas"] !== void 0 ? Number(args["target-roas"]) : void 0
+  };
+}
+var campaignsCommand = defineCommand30({
+  meta: { name: "campaigns", description: "Stage campaign create/update/pause/resume/remove" },
+  subCommands: {
+    create: defineCommand30({
+      meta: { name: "create", description: "Stage a campaign" },
+      args: {
+        ...customerIdArg,
+        ...fileArg,
+        name: { type: "string" },
+        "channel-type": {
+          type: "string",
+          description: "SEARCH | DISPLAY | SHOPPING | VIDEO | PERFORMANCE_MAX | DEMAND_GEN | \u2026"
+        },
+        "sub-type": { type: "string", description: "Advertising channel sub-type" },
+        "budget-ref": { type: "string", description: "Budget ref (g_temp_*, id, or resource name)" },
+        "bidding-strategy": {
+          type: "string",
+          description: "MANUAL_CPC | MAXIMIZE_CONVERSIONS | TARGET_CPA | TARGET_ROAS | \u2026"
+        },
+        "target-cpa": { type: "string", description: "Target CPA (major units) for TARGET_CPA" },
+        "target-roas": { type: "string", description: "Target ROAS (e.g. 4.0) for TARGET_ROAS" },
+        objective: { type: "string", description: "Advisory UI objective (SALES, LEADS, \u2026)" },
+        "start-date": { type: "string", description: "YYYY-MM-DD" },
+        "end-date": { type: "string", description: "YYYY-MM-DD" },
+        status: { type: "string", description: "ENABLED | PAUSED (default PAUSED)" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        const payload = mergePayload(loadJsonFileArg(args.file), {
+          name: args.name,
+          channelType: args["channel-type"],
+          channelSubType: args["sub-type"],
+          budget: args["budget-ref"],
+          bidding: biddingFromFlags(args),
+          objective: args.objective,
+          startDate: args["start-date"],
+          endDate: args["end-date"],
+          status: args.status
+        });
+        await stageCreate("google.campaign.create", customerId, payload);
+      }
+    }),
+    update: defineCommand30({
+      meta: { name: "update", description: "Stage a campaign update" },
+      args: {
+        ...customerIdArg,
+        ...fileArg,
+        name: { type: "string" },
+        "budget-ref": { type: "string" },
+        "bidding-strategy": { type: "string" },
+        "target-cpa": { type: "string" },
+        "target-roas": { type: "string" },
+        status: { type: "string" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        const target = requireTarget(args, "campaign");
+        const payload = mergePayload(loadJsonFileArg(args.file), {
+          name: args.name,
+          budget: args["budget-ref"],
+          bidding: biddingFromFlags(args),
+          status: args.status
+        });
+        await stageUpdate("google.campaign.update", customerId, target, payload);
+      }
+    }),
+    pause: statusCommand2("google.campaign.pause", "campaign"),
+    resume: statusCommand2("google.campaign.resume", "campaign"),
+    remove: statusCommand2("google.campaign.remove", "campaign")
+  }
+});
+function statusCommand2(kind, entity) {
+  return defineCommand30({
+    meta: { name: kind.split(".")[2], description: `Stage a ${entity} ${kind.split(".")[2]}` },
+    args: {
+      ...customerIdArg,
+      id: { type: "positional", description: `${entity} resource name or id`, required: false }
+    },
+    run: async ({ args }) => {
+      const customerId = requireCustomerId(args);
+      await stageTarget(kind, customerId, requireTarget(args, entity));
+    }
+  });
+}
+var adGroupsCommand = defineCommand30({
+  meta: { name: "ad-groups", description: "Stage ad group create/update/pause/resume/remove" },
+  subCommands: {
+    create: defineCommand30({
+      meta: { name: "create", description: "Stage an ad group" },
+      args: {
+        ...customerIdArg,
+        ...fileArg,
+        name: { type: "string" },
+        "campaign-ref": { type: "string", description: "Campaign ref (g_temp_*, id, or resource name)" },
+        type: { type: "string", description: "Ad group type (default SEARCH_STANDARD)" },
+        "cpc-bid": { type: "string", description: "Default CPC bid in major units" },
+        status: { type: "string" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        const payload = mergePayload(loadJsonFileArg(args.file), {
+          name: args.name,
+          campaign: args["campaign-ref"],
+          type: args.type,
+          cpcBidMicros: microsFlag(args["cpc-bid"], "--cpc-bid"),
+          status: args.status
+        });
+        await stageCreate("google.adGroup.create", customerId, payload);
+      }
+    }),
+    update: defineCommand30({
+      meta: { name: "update", description: "Stage an ad group update" },
+      args: {
+        ...customerIdArg,
+        ...fileArg,
+        name: { type: "string" },
+        "cpc-bid": { type: "string" },
+        status: { type: "string" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        const target = requireTarget(args, "ad group");
+        const payload = mergePayload(loadJsonFileArg(args.file), {
+          name: args.name,
+          cpcBidMicros: microsFlag(args["cpc-bid"], "--cpc-bid"),
+          status: args.status
+        });
+        await stageUpdate("google.adGroup.update", customerId, target, payload);
+      }
+    }),
+    pause: statusCommand2("google.adGroup.pause", "ad group"),
+    resume: statusCommand2("google.adGroup.resume", "ad group"),
+    remove: statusCommand2("google.adGroup.remove", "ad group")
+  }
+});
+var keywordWriteSubcommands = {
+  add: defineCommand30({
+    meta: { name: "add", description: "Add keyword(s) to an ad group \u2014 one --text or a whole batch" },
+    args: {
+      ...customerIdArg,
+      "ad-group-ref": { type: "string", description: "Ad group ref (g_temp_*, id, or resource name)" },
+      text: {
+        type: "string",
+        description: 'Keyword text \u2014 comma-separate for a batch, optional ":EXACT|:PHRASE|:BROAD" suffix per entry'
+      },
+      file: { type: "string", description: "Text file with one keyword[:MATCH_TYPE] per line" },
+      "match-type": { type: "string", description: "Default match type: EXACT | PHRASE | BROAD" },
+      "cpc-bid": { type: "string", description: "Keyword CPC bid in major units (applies to all)" },
+      "final-url": { type: "string", description: "Keyword-level final URL (applies to all)" }
+    },
+    run: async ({ args }) => {
+      const customerId = requireCustomerId(args);
+      const adGroup = requireStringFlag(args["ad-group-ref"], "--ad-group-ref");
+      const cpcBidMicros = microsFlag(args["cpc-bid"], "--cpc-bid");
+      const finalUrls = args["final-url"] ? [args["final-url"]] : void 0;
+      await stageGoogleOps(
+        keywordEntries(args).map((entry) => ({
+          kind: "google.keyword.add",
+          customerId,
+          payload: { adGroup, text: entry.text, matchType: entry.matchType, cpcBidMicros, finalUrls }
+        }))
+      );
+    }
+  }),
+  update: defineCommand30({
+    meta: { name: "update", description: "Update a keyword" },
+    args: { ...customerIdArg, "cpc-bid": { type: "string" }, status: { type: "string" } },
+    run: async ({ args }) => {
+      const customerId = requireCustomerId(args);
+      await stageUpdate("google.keyword.update", customerId, requireTarget(args, "keyword"), {
+        cpcBidMicros: microsFlag(args["cpc-bid"], "--cpc-bid"),
+        status: args.status
+      });
+    }
+  }),
+  remove: statusCommand2("google.keyword.remove", "keyword")
+};
+var negativeKeywordsCommand = defineCommand30({
+  meta: { name: "negative-keywords", description: "Stage negative keyword add/remove (ad-group or campaign level)" },
+  subCommands: {
+    add: defineCommand30({
+      meta: { name: "add", description: "Add negative keyword(s) \u2014 one --text or a whole batch" },
+      args: {
+        ...customerIdArg,
+        level: { type: "string", description: "adGroup | campaign" },
+        "parent-ref": { type: "string", description: "Ad group or campaign ref" },
+        text: {
+          type: "string",
+          description: 'Keyword text \u2014 comma-separate for a batch, optional ":MATCH_TYPE" suffix per entry'
+        },
+        file: { type: "string", description: "Text file with one keyword[:MATCH_TYPE] per line" },
+        "match-type": { type: "string", description: "Default match type: EXACT | PHRASE | BROAD" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        const level = requireStringFlag(args.level, "--level");
+        const parent = requireStringFlag(args["parent-ref"], "--parent-ref");
+        await stageGoogleOps(
+          keywordEntries(args).map((entry) => ({
+            kind: "google.negativeKeyword.add",
+            customerId,
+            payload: { level, parent, text: entry.text, matchType: entry.matchType }
+          }))
+        );
+      }
+    }),
+    remove: statusCommand2("google.negativeKeyword.remove", "negative keyword")
+  }
+});
+var keywordListsCommand = defineCommand30({
+  meta: {
+    name: "keyword-lists",
+    description: "Stage shared negative keyword lists (create/add/attach/detach). Build at least one shared negative list (brand, competitor, junk-intent terms) and attach it to every campaign to protect spend."
+  },
+  subCommands: {
+    create: defineCommand30({
+      meta: { name: "create", description: "Create a shared negative keyword list" },
+      args: {
+        ...customerIdArg,
+        name: { type: "string" },
+        type: {
+          type: "string",
+          description: "NEGATIVE_KEYWORDS (default) | NEGATIVE_PLACEMENTS | ACCOUNT_LEVEL_NEGATIVE_KEYWORDS"
+        }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        await stageCreate("google.sharedSet.create", customerId, {
+          name: requireStringFlag(args.name, "--name"),
+          type: args.type
+        });
+      }
+    }),
+    add: defineCommand30({
+      meta: { name: "add", description: "Add keyword(s) to a shared list \u2014 one --text or a whole batch" },
+      args: {
+        ...customerIdArg,
+        "list-ref": { type: "string", description: "Shared set ref" },
+        text: {
+          type: "string",
+          description: 'Keyword text \u2014 comma-separate for a batch, optional ":MATCH_TYPE" suffix per entry'
+        },
+        file: { type: "string", description: "Text file with one keyword[:MATCH_TYPE] per line" },
+        "match-type": { type: "string", description: "Default match type: EXACT | PHRASE | BROAD" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        const sharedSet = requireStringFlag(args["list-ref"], "--list-ref");
+        await stageGoogleOps(
+          keywordEntries(args).map((entry) => ({
+            kind: "google.sharedSetMember.add",
+            customerId,
+            payload: { sharedSet, text: entry.text, matchType: entry.matchType }
+          }))
+        );
+      }
+    }),
+    attach: defineCommand30({
+      meta: { name: "attach", description: "Attach a keyword list to a campaign" },
+      args: { ...customerIdArg, "campaign-ref": { type: "string" }, "list-ref": { type: "string" } },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        await stageCreate("google.campaignSharedSet.attach", customerId, {
+          campaign: requireStringFlag(args["campaign-ref"], "--campaign-ref"),
+          sharedSet: requireStringFlag(args["list-ref"], "--list-ref")
+        });
+      }
+    }),
+    detach: statusCommand2("google.campaignSharedSet.detach", "campaign shared set")
+  }
+});
+function rsaContentFromFlags(args) {
+  const headlines = listFlag(args.headlines);
+  const descriptions = listFlag(args.descriptions);
+  if (!headlines || !descriptions) {
+    failWriteValidation("responsive search ads need --headlines and --descriptions (comma-separated), or use --file");
+  }
+  const finalUrls = listFlag(args["final-url"]);
+  if (!finalUrls) {
+    failWriteValidation("--final-url is required for a responsive search ad");
+  }
+  return {
+    format: "responsiveSearch",
+    headlines: headlines.map((text) => ({ text })),
+    descriptions: descriptions.map((text) => ({ text })),
+    path1: args.path1,
+    path2: args.path2,
+    finalUrls
+  };
+}
+var adsCommand = defineCommand30({
+  meta: { name: "ads", description: "Stage ad create/update/pause/resume/remove" },
+  subCommands: {
+    create: defineCommand30({
+      meta: {
+        name: "create",
+        description: "Stage an ad (responsive search via flags; other formats via --file). RSA needs 3\u201315 headlines and 2\u20134 descriptions \u2014 give Google 8\u201312 varied headlines to test, and stage 2\u20134 ads per ad group."
+      },
+      args: {
+        ...customerIdArg,
+        ...fileArg,
+        "ad-group-ref": { type: "string", description: "Ad group ref" },
+        format: {
+          type: "string",
+          description: "responsiveSearch (default) | responsiveDisplay | performanceMaxAssetGroup | call | app | video | demandGen"
+        },
+        headlines: { type: "string", description: "Comma-separated headlines (RSA)" },
+        descriptions: { type: "string", description: "Comma-separated descriptions (RSA)" },
+        path1: { type: "string" },
+        path2: { type: "string" },
+        "final-url": { type: "string", description: "Comma-separated final URLs" },
+        status: { type: "string" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        const file = loadJsonFileArg(args.file);
+        const format = args.format ?? "responsiveSearch";
+        const content = file.content ?? (format === "responsiveSearch" ? rsaContentFromFlags(args) : failWriteValidation(`--format ${format} needs --file with the ad content`));
+        await stageCreate("google.ad.create", customerId, {
+          adGroup: requireStringFlag(args["ad-group-ref"] ?? file.adGroup, "--ad-group-ref"),
+          status: args.status ?? file.status,
+          content
+        });
+      }
+    }),
+    update: defineCommand30({
+      meta: { name: "update", description: "Stage an ad update" },
+      args: { ...customerIdArg, ...fileArg, status: { type: "string" } },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        const file = loadJsonFileArg(args.file);
+        await stageUpdate(
+          "google.ad.update",
+          customerId,
+          requireTarget(args, "ad"),
+          mergePayload(file, { status: args.status })
+        );
+      }
+    }),
+    pause: statusCommand2("google.ad.pause", "ad"),
+    resume: statusCommand2("google.ad.resume", "ad"),
+    remove: statusCommand2("google.ad.remove", "ad")
+  }
+});
+function fileCreateCommand(name, kind, description) {
+  return defineCommand30({
+    meta: { name, description },
+    args: { ...customerIdArg, ...fileArg },
+    run: async ({ args }) => {
+      const customerId = requireCustomerId(args);
+      const payload = loadJsonFileArg(args.file);
+      if (Object.keys(payload).length === 0) {
+        failWriteValidation(`${kind} needs --file with the op payload`);
+      }
+      await stageGoogleOp({ kind, customerId, payload });
+    }
+  });
+}
+var assetsCommand = defineCommand30({
+  meta: {
+    name: "assets",
+    description: "Stage asset create + asset-link attach/detach (via --file). For a high-performance Search campaign add \u22654 sitelinks, \u22653 callouts, and \u22651 structured snippet per campaign."
+  },
+  subCommands: {
+    create: fileCreateCommand(
+      "create",
+      "google.asset.create",
+      "Stage an asset (text/image/sitelink/callout/structuredSnippet/\u2026)"
+    ),
+    attach: fileCreateCommand("attach", "google.assetLink.attach", "Attach an asset to a campaign/adGroup/customer"),
+    detach: statusCommand2("google.assetLink.detach", "asset link")
+  }
+});
+var audiencesCommand = defineCommand30({
+  meta: { name: "audiences", description: "Stage audience (user list) create + criterion attach/detach (via --file)" },
+  subCommands: {
+    create: fileCreateCommand("create", "google.audience.create", "Stage a user-list audience"),
+    attach: fileCreateCommand(
+      "attach",
+      "google.audienceCriterion.attach",
+      "Target/exclude an audience on a campaign/adGroup"
+    ),
+    detach: statusCommand2("google.audienceCriterion.detach", "audience criterion")
+  }
+});
+var conversionsCommand = defineCommand30({
+  meta: { name: "conversions", description: "Stage conversion action create/update (via --file)" },
+  subCommands: {
+    create: fileCreateCommand("create", "google.conversionAction.create", "Stage a conversion action"),
+    update: defineCommand30({
+      meta: { name: "update", description: "Stage a conversion action update" },
+      args: { ...customerIdArg, ...fileArg },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        await stageUpdate(
+          "google.conversionAction.update",
+          customerId,
+          requireTarget(args, "conversion action"),
+          loadJsonFileArg(args.file)
+        );
+      }
+    })
+  }
+});
+var biddingStrategiesCommand = defineCommand30({
+  meta: { name: "bidding-strategies", description: "Stage portfolio bidding strategy create/update (via --file)" },
+  subCommands: {
+    create: fileCreateCommand("create", "google.biddingStrategy.create", "Stage a portfolio bidding strategy"),
+    update: defineCommand30({
+      meta: { name: "update", description: "Stage a portfolio bidding strategy update" },
+      args: { ...customerIdArg, ...fileArg },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        await stageUpdate(
+          "google.biddingStrategy.update",
+          customerId,
+          requireTarget(args, "bidding strategy"),
+          loadJsonFileArg(args.file)
+        );
+      }
+    })
+  }
+});
+var labelsCommand = defineCommand30({
+  meta: { name: "labels", description: "Stage label create + attach (via --file)" },
+  subCommands: {
+    create: defineCommand30({
+      meta: { name: "create", description: "Create a label" },
+      args: {
+        ...customerIdArg,
+        name: { type: "string" },
+        "background-color": { type: "string" },
+        description: { type: "string" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        await stageCreate("google.label.create", customerId, {
+          name: requireStringFlag(args.name, "--name"),
+          backgroundColor: args["background-color"],
+          description: args.description
+        });
+      }
+    }),
+    attach: fileCreateCommand("attach", "google.label.attach", "Attach a label to a campaign/adGroup/ad")
+  }
+});
+var campaignCriteriaCommand = defineCommand30({
+  meta: {
+    name: "campaign-criteria",
+    description: "Stage campaign criteria (location/language/adSchedule/device) add/remove (via --file)"
+  },
+  subCommands: {
+    add: fileCreateCommand("add", "google.campaignCriterion.add", "Add a campaign criterion"),
+    remove: statusCommand2("google.campaignCriterion.remove", "campaign criterion")
+  }
+});
+var googleWriteCommands = {
+  budgets: budgetsCommand,
+  campaigns: campaignsCommand,
+  "ad-groups": adGroupsCommand,
+  "negative-keywords": negativeKeywordsCommand,
+  "keyword-lists": keywordListsCommand,
+  ads: adsCommand,
+  assets: assetsCommand,
+  audiences: audiencesCommand,
+  conversions: conversionsCommand,
+  "bidding-strategies": biddingStrategiesCommand,
+  labels: labelsCommand,
+  "campaign-criteria": campaignCriteriaCommand
+};
+
 // src/commands/ads/google/index.ts
-var googleCommand = defineCommand29({
+var keywordsWithWrites = defineCommand31({
+  meta: keywordsCommand.meta,
+  subCommands: { ...keywordsCommand.subCommands, ...keywordWriteSubcommands }
+});
+var googleCommand = defineCommand31({
   meta: {
     name: "google",
     description: `Google Ads commands. Query campaigns, keywords, search terms, and more via GAQL.
@@ -5161,20 +6855,28 @@ Examples:
   baker ads google query --preset campaign-performance --customer-id 1234567890
   baker ads google currency --customer-id 1234567890
   baker ads google keywords discover --customer-id 1234567890 --seeds "running shoes"
-  baker ads google library list-advertisers    \u2014 list tracked Google advertisers`
+  baker ads google library list-advertisers    \u2014 list tracked Google advertisers
+
+Staged writes (never touch Google until the chat is published):
+  baker ads google budgets create --customer-id 1234567890 --name "Search" --amount 50
+  baker ads google campaigns create --customer-id 1234567890 --name "Brand" --channel-type SEARCH --budget-ref g_temp_\u2026 --bidding-strategy MANUAL_CPC
+  baker ads google keyword-lists create --customer-id 1234567890 --name "Brand exclusions"
+  baker ads google draft list                  \u2014 review staged Google Ads changes`
   },
   subCommands: {
     accounts: accountsCommand,
     currency: currencyCommand,
     changes: changesCommand,
     query: queryCommand,
-    keywords: keywordsCommand,
-    library
+    keywords: keywordsWithWrites,
+    library,
+    ...googleWriteCommands,
+    draft: draftCommand2
   }
 });
 
 // src/commands/ads/linkedin/index.ts
-import { defineCommand as defineCommand49 } from "citty";
+import { defineCommand as defineCommand51 } from "citty";
 
 // src/commands/ads/linkedin/schemas.ts
 registerSchema({
@@ -5835,7 +7537,7 @@ registerSchema({
 });
 
 // src/commands/ads/linkedin/account.ts
-import { defineCommand as defineCommand30 } from "citty";
+import { defineCommand as defineCommand32 } from "citty";
 
 // src/commands/ads/linkedin/shared.ts
 var DAY_MS2 = 864e5;
@@ -5938,7 +7640,7 @@ function resolveStatusFilter(args) {
 }
 
 // src/commands/ads/linkedin/account.ts
-var accountCommand = defineCommand30({
+var accountCommand = defineCommand32({
   meta: {
     name: "account",
     description: `Single LinkedIn ad account detail (currency, status, type).
@@ -5972,9 +7674,9 @@ Examples:
 });
 
 // src/commands/ads/linkedin/accounts.ts
-import { defineCommand as defineCommand31 } from "citty";
+import { defineCommand as defineCommand33 } from "citty";
 var ACCOUNTS_TTL_MS = 60 * 60 * 1e3;
-var accountsCommand2 = defineCommand31({
+var accountsCommand2 = defineCommand33({
   meta: {
     name: "accounts",
     description: `List LinkedIn ad accounts in this company's connected scope.
@@ -6022,7 +7724,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/analytics.ts
-import { defineCommand as defineCommand32 } from "citty";
+import { defineCommand as defineCommand34 } from "citty";
 
 // src/commands/ads/linkedin/presets.ts
 var INTENTS = {
@@ -6294,7 +7996,7 @@ function numberOf(v) {
   }
   return 0;
 }
-var analyticsCommand = defineCommand32({
+var analyticsCommand = defineCommand34({
   meta: {
     name: "analytics",
     description: `Performance reporting \u2014 the workhorse for AI agents.
@@ -6421,8 +8123,8 @@ Examples \u2014 common AI questions:
 });
 
 // src/commands/ads/linkedin/audience-size.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { defineCommand as defineCommand33 } from "citty";
+import { readFileSync as readFileSync5 } from "fs";
+import { defineCommand as defineCommand35 } from "citty";
 function loadTargeting(args) {
   const inline = args.targeting;
   if (inline) {
@@ -6435,7 +8137,7 @@ function loadTargeting(args) {
   const file = args["targeting-file"];
   if (file) {
     try {
-      return JSON.parse(readFileSync4(file, "utf-8"));
+      return JSON.parse(readFileSync5(file, "utf-8"));
     } catch (e) {
       handleLinkedinError(
         new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
@@ -6444,7 +8146,7 @@ function loadTargeting(args) {
   }
   handleLinkedinError(new Error("Pass --targeting-file <path> or --targeting '{...JSON...}'"));
 }
-var audienceSizeCommand = defineCommand33({
+var audienceSizeCommand = defineCommand35({
   meta: {
     name: "audience-size",
     description: `Estimate audience size for a targeting payload \u2014 pre-launch sanity check.
@@ -6489,7 +8191,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/audit.ts
-import { defineCommand as defineCommand34 } from "citty";
+import { defineCommand as defineCommand36 } from "citty";
 var SEVERITY_RANK = {
   critical: 0,
   high: 1,
@@ -6548,7 +8250,7 @@ function noteOf(f) {
   const fix = f.fix?.explanation ?? "";
   return [fix, ev].filter(Boolean).join(" \u2014 ");
 }
-var auditCommand = defineCommand34({
+var auditCommand = defineCommand36({
   meta: {
     name: "audit",
     description: `Run a LinkedIn Ads playbook audit \u2014 30+ checks across Settings, Tracking,
@@ -6614,8 +8316,8 @@ Examples:
 });
 
 // src/commands/ads/linkedin/bid-pricing.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { defineCommand as defineCommand35 } from "citty";
+import { readFileSync as readFileSync6 } from "fs";
+import { defineCommand as defineCommand37 } from "citty";
 function loadTargeting2(args) {
   const inline = args.targeting;
   if (inline) {
@@ -6628,7 +8330,7 @@ function loadTargeting2(args) {
   const file = args["targeting-file"];
   if (file) {
     try {
-      return JSON.parse(readFileSync5(file, "utf-8"));
+      return JSON.parse(readFileSync6(file, "utf-8"));
     } catch (e) {
       handleLinkedinError(
         new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
@@ -6637,7 +8339,7 @@ function loadTargeting2(args) {
   }
   handleLinkedinError(new Error("Pass --targeting-file <path> or --targeting '{...JSON...}'"));
 }
-var bidPricingCommand = defineCommand35({
+var bidPricingCommand = defineCommand37({
   meta: {
     name: "bid-pricing",
     description: `Get LinkedIn's suggested bid range for a targeting + objective + cost type.
@@ -6687,40 +8389,40 @@ Examples:
 });
 
 // src/commands/ads/linkedin/campaign-groups.ts
-import { defineCommand as defineCommand37 } from "citty";
+import { defineCommand as defineCommand39 } from "citty";
 
 // src/commands/ads/linkedin/write-commands.ts
-import { defineCommand as defineCommand36 } from "citty";
+import { defineCommand as defineCommand38 } from "citty";
 
 // src/commands/ads/linkedin/write-shared.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 function bareAccountId(args) {
   const raw = resolveAccountIdArg(args);
   return raw.replace(/^urn:li:sponsoredAccount:/, "").replace(/^sponsoredAccount:/, "");
 }
-function failWriteValidation(message) {
+function failWriteValidation2(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg(path12) {
+function loadJsonFileArg2(path12) {
   if (typeof path12 !== "string" || path12.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync6(path12, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path12, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation(`${path12} must contain a JSON object`);
+      failWriteValidation2(`${path12} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation(`${path12} is not valid JSON: ${err.message}`);
+      failWriteValidation2(`${path12} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
 }
-function mergePayload(file, flags) {
+function mergePayload2(file, flags) {
   const merged = { ...file };
   for (const [key, value] of Object.entries(flags)) {
     if (value !== void 0) {
@@ -6737,7 +8439,7 @@ function parseMoneyFlag(amount, currency, flag) {
     return { amount: String(amount) };
   }
   if (typeof currency !== "string" || currency.length !== 3) {
-    failWriteValidation(`${flag} got an invalid --currency (expected a 3-letter code like EUR)`);
+    failWriteValidation2(`${flag} got an invalid --currency (expected a 3-letter code like EUR)`);
   }
   return { amount: String(amount), currencyCode: currency.toUpperCase() };
 }
@@ -6751,7 +8453,7 @@ function parseDateFlag(value, flag) {
   }
   const parsed = Date.parse(raw);
   if (Number.isNaN(parsed)) {
-    failWriteValidation(`${flag} must be an ISO date (2026-07-10) or epoch milliseconds`);
+    failWriteValidation2(`${flag} must be an ISO date (2026-07-10) or epoch milliseconds`);
   }
   return parsed;
 }
@@ -6766,7 +8468,7 @@ function parseOnOffFlag(value, flag) {
   if (raw === "off" || raw === "false") {
     return false;
   }
-  failWriteValidation(`${flag} must be on|off`);
+  failWriteValidation2(`${flag} must be on|off`);
 }
 function parseLocaleFlag(value) {
   if (value === void 0 || value === null || value === "") {
@@ -6774,7 +8476,7 @@ function parseLocaleFlag(value) {
   }
   const match = /^([a-z]{2})[_-]([A-Za-z]{2})$/.exec(String(value));
   if (!match) {
-    failWriteValidation("--locale must look like en_US (language_COUNTRY)");
+    failWriteValidation2("--locale must look like en_US (language_COUNTRY)");
   }
   return { language: match[1], country: match[2].toUpperCase() };
 }
@@ -6782,10 +8484,10 @@ function loadTargetingFileArg(path12) {
   if (typeof path12 !== "string" || path12.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg(path12);
+  const parsed = loadJsonFileArg2(path12);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
-    failWriteValidation(
+    failWriteValidation2(
       `${path12} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
@@ -6825,10 +8527,10 @@ function parseListFileArg(path12, maxRows) {
   if (typeof path12 !== "string" || path12.length === 0) {
     return void 0;
   }
-  const raw = readFileSync6(path12, "utf8");
+  const raw = readFileSync7(path12, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation(`${path12} needs a header row and at least one data row`);
+    failWriteValidation2(`${path12} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -6847,7 +8549,7 @@ function parseListFileArg(path12, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation(`${path12} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation2(`${path12} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -6883,10 +8585,10 @@ async function stageStatusChange(input) {
   const payload = input.kind === "creative.update" ? { intendedStatus: input.status } : { status: input.status };
   await stageOp({ kind: input.kind, accountId: input.accountId, target: input.target, payload });
 }
-function requireTarget(args, entity) {
+function requireTarget2(args, entity) {
   const target = args.id ?? args.target;
   if (typeof target !== "string" || target.length === 0) {
-    failWriteValidation(`pass the ${entity} id or URN as the positional argument`);
+    failWriteValidation2(`pass the ${entity} id or URN as the positional argument`);
   }
   return target;
 }
@@ -6905,7 +8607,7 @@ function runScheduleFromFlags(args) {
   }
   return { ...start !== void 0 ? { start } : {}, ...end !== void 0 ? { end } : {} };
 }
-var campaignGroupsCreateCommand = defineCommand36({
+var campaignGroupsCreateCommand = defineCommand38({
   meta: {
     name: "create",
     description: `Stage a new campaign group. ${STAGED_NOTE}
@@ -6923,7 +8625,7 @@ Example: baker ads linkedin campaign-groups create --name "Q3 ABM" --start 2026-
   },
   run: async ({ args }) => {
     const accountId = bareAccountId(args);
-    const payload = mergePayload(loadJsonFileArg(args.file), {
+    const payload = mergePayload2(loadJsonFileArg2(args.file), {
       name: args.name,
       runSchedule: runScheduleFromFlags(args),
       totalBudget: parseMoneyFlag(args["total-budget"], args.currency, "--total-budget"),
@@ -6932,7 +8634,7 @@ Example: baker ads linkedin campaign-groups create --name "Q3 ABM" --start 2026-
     await stageOp({ kind: "campaignGroup.create", accountId, payload });
   }
 });
-var campaignGroupsUpdateCommand = defineCommand36({
+var campaignGroupsUpdateCommand = defineCommand38({
   meta: {
     name: "update",
     description: `Stage changes to an existing campaign group. ${STAGED_NOTE}
@@ -6952,7 +8654,7 @@ Example: baker ads linkedin campaign-groups update 635137195 --total-budget 8000
   },
   run: async ({ args }) => {
     const accountId = bareAccountId(args);
-    const payload = mergePayload(loadJsonFileArg(args.file), {
+    const payload = mergePayload2(loadJsonFileArg2(args.file), {
       name: args.name,
       runSchedule: runScheduleFromFlags(args),
       totalBudget: parseMoneyFlag(args["total-budget"], args.currency, "--total-budget"),
@@ -6961,7 +8663,7 @@ Example: baker ads linkedin campaign-groups update 635137195 --total-budget 8000
     await stageOp({
       kind: "campaignGroup.update",
       accountId,
-      target: requireTarget(args, "campaign group"),
+      target: requireTarget2(args, "campaign group"),
       payload
     });
   }
@@ -7010,7 +8712,7 @@ var campaignFlagArgs = {
   status: { type: "string", description: "DRAFT|ACTIVE|PAUSED" },
   file: { type: "string", description: "JSON file with the full payload; flags override file keys" }
 };
-var campaignsCreateCommand = defineCommand36({
+var campaignsCreateCommand = defineCommand38({
   meta: {
     name: "create",
     description: `Stage a new campaign. ${STAGED_NOTE}
@@ -7020,14 +8722,14 @@ Example: baker ads linkedin campaigns create --name "ABM Tier-1" --group li_temp
   args: campaignFlagArgs,
   run: async ({ args }) => {
     const accountId = bareAccountId(args);
-    const payload = mergePayload(loadJsonFileArg(args.file), campaignPayloadFromFlags(args));
+    const payload = mergePayload2(loadJsonFileArg2(args.file), campaignPayloadFromFlags(args));
     if (payload.locale === void 0) {
       payload.locale = { country: "US", language: "en" };
     }
     await stageOp({ kind: "campaign.create", accountId, payload });
   }
 });
-var campaignsUpdateCommand = defineCommand36({
+var campaignsUpdateCommand = defineCommand38({
   meta: {
     name: "update",
     description: `Stage changes to an existing campaign (budget, bid, targeting, flags, schedule, status). ${STAGED_NOTE}
@@ -7045,18 +8747,18 @@ Example: baker ads linkedin campaigns update 123456 --daily-budget 100 --currenc
     flags.type = void 0;
     flags.locale = void 0;
     flags.associatedEntity = void 0;
-    const payload = mergePayload(loadJsonFileArg(args.file), flags);
+    const payload = mergePayload2(loadJsonFileArg2(args.file), flags);
     await stageOp({
       kind: "campaign.update",
       accountId,
-      target: requireTarget(args, "campaign"),
+      target: requireTarget2(args, "campaign"),
       payload
     });
   }
 });
 function statusSugarCommand(entity, kind, name) {
   const status = name === "pause" ? "PAUSED" : name === "resume" ? "ACTIVE" : "ARCHIVED";
-  return defineCommand36({
+  return defineCommand38({
     meta: {
       name,
       description: `Stage a status change to ${status}. ${STAGED_NOTE}
@@ -7070,7 +8772,7 @@ Example: baker ads linkedin ${entity} ${name} 123456`
       await stageStatusChange({
         kind,
         accountId: bareAccountId(args),
-        target: requireTarget(args, entity.replace(/-/g, " ").replace(/s$/, "")),
+        target: requireTarget2(args, entity.replace(/-/g, " ").replace(/s$/, "")),
         status
       });
     }
@@ -7084,7 +8786,7 @@ var campaignGroupsResumeCommand = statusSugarCommand("campaign-groups", "campaig
 var creativesPauseCommand = statusSugarCommand("creatives", "creative.update", "pause");
 var creativesResumeCommand = statusSugarCommand("creatives", "creative.update", "resume");
 function duplicateCommand(entity, cliGroup) {
-  return defineCommand36({
+  return defineCommand38({
     meta: {
       name: "duplicate",
       description: `Stage a copy of an existing ${entity} as a new DRAFT create (playbook: duplicate, never link-to-original). ${STAGED_NOTE}
@@ -7099,14 +8801,14 @@ Example: baker ads linkedin ${cliGroup} duplicate 123456 --name "New variant"`
     run: async ({ args }) => {
       try {
         const chatId = requireChatId();
-        const overrides = mergePayload(loadJsonFileArg(args.file), { name: args.name });
+        const overrides = mergePayload2(loadJsonFileArg2(args.file), { name: args.name });
         const response = await apiPost(
           "/api/ads/linkedin/draft/duplicate",
           {
             chatId,
             accountId: bareAccountId(args),
             entity,
-            sourceId: requireTarget(args, entity),
+            sourceId: requireTarget2(args, entity),
             ...Object.keys(overrides).length > 0 ? { overrides } : {}
           }
         );
@@ -7119,7 +8821,7 @@ Example: baker ads linkedin ${cliGroup} duplicate 123456 --name "New variant"`
 }
 var campaignsDuplicateCommand = duplicateCommand("campaign", "campaigns");
 var campaignGroupsDuplicateCommand = duplicateCommand("campaignGroup", "campaign-groups");
-var creativesDuplicateCommand = defineCommand36({
+var creativesDuplicateCommand = defineCommand38({
   meta: {
     name: "duplicate",
     description: `Stage a copy of an existing ad, optionally with new content \u2014 the ONLY way to change copy/media/URL on a live ad (LinkedIn makes ad content immutable). ${STAGED_NOTE}
@@ -7157,10 +8859,10 @@ Examples:
   run: async ({ args }) => {
     try {
       const chatId = requireChatId();
-      const file = loadJsonFileArg(args.file);
+      const file = loadJsonFileArg2(args.file);
       const fileContent = file.content !== null && typeof file.content === "object" && !Array.isArray(file.content) ? file.content : {};
       const content = { ...fileContent, ...creativeContentPatch(args) };
-      const overrides = mergePayload(file, {
+      const overrides = mergePayload2(file, {
         campaign: args.campaign,
         intendedStatus: args["intended-status"] ? String(args["intended-status"]).toUpperCase() : void 0,
         content: Object.keys(content).length > 0 ? content : void 0
@@ -7171,7 +8873,7 @@ Examples:
           chatId,
           accountId: bareAccountId(args),
           entity: "creative",
-          sourceId: requireTarget(args, "creative"),
+          sourceId: requireTarget2(args, "creative"),
           ...Object.keys(overrides).length > 0 ? { overrides } : {},
           ...args.replace ? { replace: true } : {}
         }
@@ -7196,7 +8898,7 @@ var CREATIVE_FORMATS = [
   "event",
   "article"
 ];
-var creativesCreateCommand = defineCommand36({
+var creativesCreateCommand = defineCommand38({
   meta: {
     name: "create",
     description: `Stage a new creative (ad). ${STAGED_NOTE}
@@ -7232,13 +8934,13 @@ Examples:
   run: async ({ args }) => {
     const accountId = bareAccountId(args);
     if (!args.campaign) {
-      failWriteValidation("--campaign is required (id, URN, or li_temp_* ref)");
+      failWriteValidation2("--campaign is required (id, URN, or li_temp_* ref)");
     }
     const format = args.format ? String(args.format) : void 0;
     if (!format || !CREATIVE_FORMATS.includes(format)) {
-      failWriteValidation(`--format must be one of ${CREATIVE_FORMATS.join("|")}`);
+      failWriteValidation2(`--format must be one of ${CREATIVE_FORMATS.join("|")}`);
     }
-    const content = mergePayload(loadJsonFileArg(args.file), {
+    const content = mergePayload2(loadJsonFileArg2(args.file), {
       format,
       commentary: args.intro,
       imageId: args["image-id"],
@@ -7297,7 +8999,7 @@ function creativeContentPatch(args) {
   }
   return patch;
 }
-var creativesUpdateCommand = defineCommand36({
+var creativesUpdateCommand = defineCommand38({
   meta: {
     name: "update",
     description: `Stage changes to an existing creative, or amend a creative staged in this chat by passing its li_temp_* ref. ${STAGED_NOTE}
@@ -7329,13 +9031,13 @@ Examples:
   },
   run: async ({ args }) => {
     const accountId = bareAccountId(args);
-    const target = requireTarget(args, "creative");
-    const file = loadJsonFileArg(args.file);
+    const target = requireTarget2(args, "creative");
+    const file = loadJsonFileArg2(args.file);
     const contentPatch = creativeContentPatch(args);
     const intendedStatus = args["intended-status"] ? String(args["intended-status"]).toUpperCase() : void 0;
     const fileContent = file.content !== null && typeof file.content === "object" && !Array.isArray(file.content) ? file.content : {};
     const content = { ...fileContent, ...contentPatch };
-    const payload = mergePayload(file, {
+    const payload = mergePayload2(file, {
       intendedStatus,
       name: args.name,
       content: Object.keys(content).length > 0 ? content : void 0
@@ -7345,7 +9047,7 @@ Examples:
 });
 var AUDIENCE_TYPES2 = ["company-list", "user-list", "retargeting", "engagement"];
 var INLINE_ROWS_MAX = 1e4;
-var audiencesCreateCommand = defineCommand36({
+var audiencesCreateCommand = defineCommand38({
   meta: {
     name: "create",
     description: `Stage a new matched audience. ${STAGED_NOTE}
@@ -7362,7 +9064,7 @@ Example: baker ads linkedin audiences create --name "ABM Tier-1" --type company-
   run: async ({ args }) => {
     const accountId = bareAccountId(args);
     const list = parseListFileArg(args["list-file"], INLINE_ROWS_MAX);
-    const raw = args.file ? loadJsonFileArg(args.file) : void 0;
+    const raw = args.file ? loadJsonFileArg2(args.file) : void 0;
     await stageOp({
       kind: "audience.create",
       accountId,
@@ -7375,7 +9077,7 @@ Example: baker ads linkedin audiences create --name "ABM Tier-1" --type company-
     });
   }
 });
-var audiencesUploadCommand = defineCommand36({
+var audiencesUploadCommand = defineCommand38({
   meta: {
     name: "upload",
     description: `Stage a list upload into an existing audience segment. ${STAGED_NOTE}
@@ -7390,20 +9092,20 @@ Example: baker ads linkedin audiences upload urn:li:dmpSegment:42 --list-file mo
     const accountId = bareAccountId(args);
     const list = parseListFileArg(args["list-file"], INLINE_ROWS_MAX);
     if (!list) {
-      failWriteValidation("--list-file is required");
+      failWriteValidation2("--list-file is required");
     }
     await stageOp({
       kind: "audience.uploadList",
       accountId,
       payload: {
-        segment: requireTarget(args, "audience segment"),
+        segment: requireTarget2(args, "audience segment"),
         listColumns: list.columns,
         listRows: list.rows
       }
     });
   }
 });
-var audiencesCommand = defineCommand36({
+var audiencesCommand2 = defineCommand38({
   meta: {
     name: "audiences",
     description: "Stage LinkedIn matched-audience changes (create lists, upload rows). Staged until publish \u2014 never hits the API directly."
@@ -7413,7 +9115,7 @@ var audiencesCommand = defineCommand36({
     upload: audiencesUploadCommand
   }
 });
-var conversionsCreateCommand = defineCommand36({
+var conversionsCreateCommand = defineCommand38({
   meta: {
     name: "create",
     description: `Stage a new conversion rule. ${STAGED_NOTE}
@@ -7432,7 +9134,7 @@ Example: baker ads linkedin conversions create --name "Demo booked" --type LEAD
   },
   run: async ({ args }) => {
     const accountId = bareAccountId(args);
-    const payload = mergePayload(loadJsonFileArg(args.file), {
+    const payload = mergePayload2(loadJsonFileArg2(args.file), {
       name: args.name,
       type: args.type ? String(args.type).toUpperCase() : void 0,
       conversionMethod: args.method ? String(args.method).toUpperCase() : void 0,
@@ -7444,7 +9146,7 @@ Example: baker ads linkedin conversions create --name "Demo booked" --type LEAD
     await stageOp({ kind: "conversion.create", accountId, payload });
   }
 });
-var conversionsUpdateCommand = defineCommand36({
+var conversionsUpdateCommand = defineCommand38({
   meta: {
     name: "update",
     description: `Stage changes to a conversion rule (windows, name, enabled). ${STAGED_NOTE}
@@ -7462,7 +9164,7 @@ Example: baker ads linkedin conversions update 104988516 --post-click-window 30
   },
   run: async ({ args }) => {
     const accountId = bareAccountId(args);
-    const payload = mergePayload(loadJsonFileArg(args.file), {
+    const payload = mergePayload2(loadJsonFileArg2(args.file), {
       name: args.name,
       postClickAttributionWindowSize: args["post-click-window"] ? Number(args["post-click-window"]) : void 0,
       viewThroughAttributionWindowSize: args["view-window"] ? Number(args["view-window"]) : void 0,
@@ -7472,12 +9174,12 @@ Example: baker ads linkedin conversions update 104988516 --post-click-window 30
     await stageOp({
       kind: "conversion.update",
       accountId,
-      target: requireTarget(args, "conversion rule"),
+      target: requireTarget2(args, "conversion rule"),
       payload
     });
   }
 });
-var leadFormsCreateCommand = defineCommand36({
+var leadFormsCreateCommand = defineCommand38({
   meta: {
     name: "create",
     description: `Stage a new Lead Gen Form from a JSON file. ${STAGED_NOTE}
@@ -7490,11 +9192,11 @@ The file needs: name, headline (\u226460), privacyPolicyUrl, questions[] (\u2264
   },
   run: async ({ args }) => {
     const accountId = bareAccountId(args);
-    const payload = mergePayload(loadJsonFileArg(args.file), { name: args.name });
+    const payload = mergePayload2(loadJsonFileArg2(args.file), { name: args.name });
     await stageOp({ kind: "leadForm.create", accountId, payload });
   }
 });
-var leadFormsUpdateCommand = defineCommand36({
+var leadFormsUpdateCommand = defineCommand38({
   meta: {
     name: "update",
     description: `Stage changes to a Lead Gen Form from a JSON file. ${STAGED_NOTE}`
@@ -7507,16 +9209,16 @@ var leadFormsUpdateCommand = defineCommand36({
   },
   run: async ({ args }) => {
     const accountId = bareAccountId(args);
-    const payload = mergePayload({ raw: loadJsonFileArg(args.file) }, { name: args.name });
+    const payload = mergePayload2({ raw: loadJsonFileArg2(args.file) }, { name: args.name });
     await stageOp({
       kind: "leadForm.update",
       accountId,
-      target: requireTarget(args, "lead form"),
+      target: requireTarget2(args, "lead form"),
       payload
     });
   }
 });
-var leadFormsCommand = defineCommand36({
+var leadFormsCommand = defineCommand38({
   meta: {
     name: "lead-forms",
     description: "Stage LinkedIn Lead Gen Form changes (file-first). Staged until publish \u2014 never hits the API directly."
@@ -7528,7 +9230,7 @@ var leadFormsCommand = defineCommand36({
 });
 
 // src/commands/ads/linkedin/campaign-groups.ts
-var campaignGroupsCommand = defineCommand37({
+var campaignGroupsCommand = defineCommand39({
   meta: {
     name: "campaign-groups",
     description: `List LinkedIn campaign groups, or stage writes (create/update/pause/resume/duplicate).
@@ -7579,8 +9281,8 @@ Examples:
 });
 
 // src/commands/ads/linkedin/campaigns.ts
-import { defineCommand as defineCommand38 } from "citty";
-var campaignsCommand = defineCommand38({
+import { defineCommand as defineCommand40 } from "citty";
+var campaignsCommand2 = defineCommand40({
   meta: {
     name: "campaigns",
     description: `List LinkedIn campaigns, or stage writes (create/update/pause/resume/archive/duplicate).
@@ -7641,8 +9343,8 @@ Examples:
 });
 
 // src/commands/ads/linkedin/conversation.ts
-import { defineCommand as defineCommand39 } from "citty";
-var conversationCommand = defineCommand39({
+import { defineCommand as defineCommand41 } from "citty";
+var conversationCommand = defineCommand41({
   meta: {
     name: "conversation",
     description: `Per-button click rates inside Sponsored Messaging / Conversation Ads.
@@ -7705,7 +9407,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/conversions.ts
-import { defineCommand as defineCommand40 } from "citty";
+import { defineCommand as defineCommand42 } from "citty";
 var DAY_MS3 = 864e5;
 function healthOf(rules) {
   const enabled = rules.filter((r) => r.enabled !== false);
@@ -7731,7 +9433,7 @@ function healthOf(rules) {
     wrongLeadDedup: wrongDedup
   };
 }
-var listCmd = defineCommand40({
+var listCmd = defineCommand42({
   meta: {
     name: "list",
     description: `List conversion rules on the account.`
@@ -7759,7 +9461,7 @@ var listCmd = defineCommand40({
     }
   }
 });
-var healthCmd = defineCommand40({
+var healthCmd = defineCommand42({
   meta: {
     name: "health",
     description: `5-point Insight Tag / CAPI health check (playbook \xA707).
@@ -7789,7 +9491,7 @@ Surfaces:
     }
   }
 });
-var conversionsCommand = defineCommand40({
+var conversionsCommand2 = defineCommand42({
   meta: {
     name: "conversions",
     description: `Conversion rules \u2014 Insight Tag and Conversions API.
@@ -7808,8 +9510,8 @@ Subcommands:
 });
 
 // src/commands/ads/linkedin/creatives.ts
-import { defineCommand as defineCommand41 } from "citty";
-var creativesCommand = defineCommand41({
+import { defineCommand as defineCommand43 } from "citty";
+var creativesCommand = defineCommand43({
   meta: {
     name: "creatives",
     description: `List LinkedIn creatives (ads), or stage writes (create/update/pause/resume/duplicate).
@@ -7868,7 +9570,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/demographics.ts
-import { defineCommand as defineCommand42 } from "citty";
+import { defineCommand as defineCommand44 } from "citty";
 var DEFAULT_PIVOTS = ["job-title", "company", "industry", "seniority", "job-function", "company-size"];
 function numberOf2(v) {
   if (typeof v === "number") return Number.isFinite(v) ? v : 0;
@@ -7881,7 +9583,7 @@ function numberOf2(v) {
 function topByImpressions(rows, limit) {
   return [...rows].sort((a, b) => numberOf2(b.impressions) - numberOf2(a.impressions)).slice(0, limit);
 }
-var demographicsCommand = defineCommand42({
+var demographicsCommand = defineCommand44({
   meta: {
     name: "demographics",
     description: `Sweep all firmographic pivots in one command \u2014 LinkedIn's superpower.
@@ -7978,7 +9680,7 @@ function resolveRange(args) {
 }
 
 // src/commands/ads/linkedin/draft.ts
-import { defineCommand as defineCommand43 } from "citty";
+import { defineCommand as defineCommand45 } from "citty";
 async function listDraft() {
   try {
     const chatId = requireChatId();
@@ -7990,14 +9692,14 @@ async function listDraft() {
     handleLinkedinError(err);
   }
 }
-var listCommand3 = defineCommand43({
+var listCommand3 = defineCommand45({
   meta: {
     name: "list",
     description: "Show every LinkedIn write op staged in this chat, its mode (simulated = publish will NOT hit LinkedIn), dependencies, and post-publish results. Example: baker ads linkedin draft"
   },
   run: listDraft
 });
-var removeCommand2 = defineCommand43({
+var removeCommand2 = defineCommand45({
   meta: {
     name: "remove",
     description: "Drop one staged LinkedIn op. Removing a create cascades to everything that depends on it. Example: baker ads linkedin draft remove li_temp_abc123"
@@ -8022,7 +9724,7 @@ var removeCommand2 = defineCommand43({
     }
   }
 });
-var clearCommand2 = defineCommand43({
+var clearCommand2 = defineCommand45({
   meta: {
     name: "clear",
     description: "Discard ALL staged LinkedIn ops in this chat's draft \u2014 nothing will apply on publish. Example: baker ads linkedin draft clear"
@@ -8039,7 +9741,7 @@ var clearCommand2 = defineCommand43({
     }
   }
 });
-var linkedinDraftCommand = defineCommand43({
+var linkedinDraftCommand = defineCommand45({
   meta: {
     name: "draft",
     description: "Review and edit the LinkedIn write ops staged in this chat BEFORE publish. Subcommands: list (default), remove, clear. Ops never hit LinkedIn until the chat is published."
@@ -8053,8 +9755,8 @@ var linkedinDraftCommand = defineCommand43({
 });
 
 // src/commands/ads/linkedin/facets.ts
-import { defineCommand as defineCommand44 } from "citty";
-var listCmd2 = defineCommand44({
+import { defineCommand as defineCommand46 } from "citty";
+var listCmd2 = defineCommand46({
   meta: {
     name: "list",
     description: `List every targeting facet LinkedIn supports.
@@ -8082,7 +9784,7 @@ seniorities, titles, employers, growthRate, companyCategory, skills, etc.).`
     }
   }
 });
-var valuesCmd = defineCommand44({
+var valuesCmd = defineCommand46({
   meta: {
     name: "values",
     description: `Look up entity values for a single facet \u2014 full list or typeahead search.
@@ -8123,7 +9825,7 @@ or the full URN (urn:li:adTargetingFacet:industries).`
     }
   }
 });
-var facetsCommand = defineCommand44({
+var facetsCommand = defineCommand46({
   meta: {
     name: "facets",
     description: `LinkedIn targeting facets and entity lookup.
@@ -8140,8 +9842,8 @@ Subcommands:
 });
 
 // src/commands/ads/linkedin/forecast.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { defineCommand as defineCommand45 } from "citty";
+import { readFileSync as readFileSync8 } from "fs";
+import { defineCommand as defineCommand47 } from "citty";
 function loadTargeting3(args) {
   const inline = args.targeting;
   if (inline) {
@@ -8154,7 +9856,7 @@ function loadTargeting3(args) {
   const file = args["targeting-file"];
   if (file) {
     try {
-      return JSON.parse(readFileSync7(file, "utf-8"));
+      return JSON.parse(readFileSync8(file, "utf-8"));
     } catch (e) {
       handleLinkedinError(
         new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
@@ -8171,7 +9873,7 @@ function parseMoney(raw) {
   }
   return { amount: m[1] ?? "0", currencyCode: m[2] ?? "USD" };
 }
-var forecastCommand = defineCommand45({
+var forecastCommand = defineCommand47({
   meta: {
     name: "forecast",
     description: `Forecast reach + impressions + clicks + spend for a hypothetical campaign.
@@ -8218,9 +9920,9 @@ Examples:
 });
 
 // src/commands/ads/linkedin/leads.ts
-import { defineCommand as defineCommand46 } from "citty";
+import { defineCommand as defineCommand48 } from "citty";
 var DAY_MS4 = 864e5;
-var leadsCommand = defineCommand46({
+var leadsCommand = defineCommand48({
   meta: {
     name: "leads",
     description: `List Lead Gen Form responses (playbook \xA707).
@@ -8280,7 +9982,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/resolve.ts
-import { defineCommand as defineCommand47 } from "citty";
+import { defineCommand as defineCommand49 } from "citty";
 function toOrgUrn(raw) {
   const trimmed = raw.trim();
   if (trimmed.length === 0) {
@@ -8291,7 +9993,7 @@ function toOrgUrn(raw) {
   }
   return /^\d+$/.test(trimmed) ? `urn:li:organization:${trimmed}` : null;
 }
-var resolveCommand = defineCommand47({
+var resolveCommand = defineCommand49({
   meta: {
     name: "resolve",
     description: `Resolve organization URNs to company names.
@@ -8333,8 +10035,8 @@ couldn't be resolved \u2014 typically an org outside LinkedIn's targetable set.`
 });
 
 // src/commands/ads/linkedin/top-companies.ts
-import { defineCommand as defineCommand48 } from "citty";
-var topCompaniesCommand = defineCommand48({
+import { defineCommand as defineCommand50 } from "citty";
+var topCompaniesCommand = defineCommand50({
   meta: {
     name: "top-companies",
     description: `Top companies whose employees saw / clicked / converted on a campaign.
@@ -8405,7 +10107,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/index.ts
-var linkedinCommand = defineCommand49({
+var linkedinCommand = defineCommand51({
   meta: {
     name: "linkedin",
     description: `LinkedIn Marketing API \u2014 AI-first command surface for B2B ad insights.
@@ -8450,9 +10152,9 @@ Account ID format:
     accounts: accountsCommand2,
     account: accountCommand,
     "campaign-groups": campaignGroupsCommand,
-    campaigns: campaignsCommand,
+    campaigns: campaignsCommand2,
     creatives: creativesCommand,
-    audiences: audiencesCommand,
+    audiences: audiencesCommand2,
     "lead-forms": leadFormsCommand,
     draft: linkedinDraftCommand,
     analytics: analyticsCommand,
@@ -8464,17 +10166,17 @@ Account ID format:
     "bid-pricing": bidPricingCommand,
     forecast: forecastCommand,
     leads: leadsCommand,
-    conversions: conversionsCommand,
+    conversions: conversionsCommand2,
     conversation: conversationCommand,
     audit: auditCommand
   }
 });
 
 // src/commands/ads/meta/index.ts
-import { defineCommand as defineCommand62 } from "citty";
+import { defineCommand as defineCommand64 } from "citty";
 
 // src/commands/ads/meta/account.ts
-import { defineCommand as defineCommand50 } from "citty";
+import { defineCommand as defineCommand52 } from "citty";
 
 // src/commands/ads/meta/shared.ts
 var DAY_MS5 = 864e5;
@@ -8553,7 +10255,7 @@ function resolveEffectiveStatus(args) {
 }
 
 // src/commands/ads/meta/account.ts
-var accountCommand2 = defineCommand50({
+var accountCommand2 = defineCommand52({
   meta: {
     name: "account",
     description: `Show single Meta ad account detail (currency, timezone, balance, business).
@@ -8580,8 +10282,8 @@ Examples:
 });
 
 // src/commands/ads/meta/accounts.ts
-import { defineCommand as defineCommand51 } from "citty";
-var accountsCommand3 = defineCommand51({
+import { defineCommand as defineCommand53 } from "citty";
+var accountsCommand3 = defineCommand53({
   meta: {
     name: "accounts",
     description: `List Meta ad accounts in this company's connected scope.
@@ -8629,8 +10331,8 @@ Examples:
 });
 
 // src/commands/ads/meta/activities.ts
-import { defineCommand as defineCommand52 } from "citty";
-var activitiesCommand = defineCommand52({
+import { defineCommand as defineCommand54 } from "citty";
+var activitiesCommand = defineCommand54({
   meta: {
     name: "activities",
     description: `Audit log of recent ad-account changes (created, paused, edited). Default lookback 7 days,
@@ -8667,8 +10369,8 @@ Examples:
 });
 
 // src/commands/ads/meta/ads.ts
-import { defineCommand as defineCommand53 } from "citty";
-var adsListCommand = defineCommand53({
+import { defineCommand as defineCommand55 } from "citty";
+var adsListCommand = defineCommand55({
   meta: {
     name: "ads",
     description: `List ads in a Meta ad account. Defaults to ACTIVE only \u2014 pass --all-statuses to widen.
@@ -8716,8 +10418,8 @@ Examples:
 });
 
 // src/commands/ads/meta/adsets.ts
-import { defineCommand as defineCommand54 } from "citty";
-var adsetsCommand = defineCommand54({
+import { defineCommand as defineCommand56 } from "citty";
+var adsetsCommand = defineCommand56({
   meta: {
     name: "adsets",
     description: `List ad sets in a Meta ad account, optionally scoped to one campaign. Defaults to ACTIVE only.
@@ -8759,8 +10461,8 @@ Examples:
 });
 
 // src/commands/ads/meta/audiences.ts
-import { defineCommand as defineCommand55 } from "citty";
-var audiencesCommand2 = defineCommand55({
+import { defineCommand as defineCommand57 } from "citty";
+var audiencesCommand3 = defineCommand57({
   meta: {
     name: "audiences",
     description: `List custom audiences for a Meta ad account. Includes lookalikes, website-pixel audiences,
@@ -8795,8 +10497,8 @@ Examples:
 });
 
 // src/commands/ads/meta/businesses.ts
-import { defineCommand as defineCommand56 } from "citty";
-var businessesCommand = defineCommand56({
+import { defineCommand as defineCommand58 } from "citty";
+var businessesCommand = defineCommand58({
   meta: {
     name: "businesses",
     description: `List Meta Business Manager accounts the connected user has access to. Required for ad-studies and product-catalogs commands.
@@ -8826,8 +10528,8 @@ Examples:
 });
 
 // src/commands/ads/meta/campaigns.ts
-import { defineCommand as defineCommand57 } from "citty";
-var campaignsCommand2 = defineCommand57({
+import { defineCommand as defineCommand59 } from "citty";
+var campaignsCommand3 = defineCommand59({
   meta: {
     name: "campaigns",
     description: `List campaigns for a Meta ad account. Defaults to ACTIVE only \u2014 pass --all-statuses to widen.
@@ -8871,8 +10573,8 @@ Examples:
 });
 
 // src/commands/ads/meta/creatives.ts
-import { defineCommand as defineCommand58 } from "citty";
-var creativesCommand2 = defineCommand58({
+import { defineCommand as defineCommand60 } from "citty";
+var creativesCommand2 = defineCommand60({
   meta: {
     name: "creatives",
     description: `List ad creatives in an account, or fetch a single creative by ID.
@@ -8916,7 +10618,7 @@ Examples:
 });
 
 // src/commands/ads/meta/insights.ts
-import { defineCommand as defineCommand59 } from "citty";
+import { defineCommand as defineCommand61 } from "citty";
 
 // src/commands/ads/meta/presets.ts
 var INSIGHTS_INTENTS = {
@@ -9121,7 +10823,7 @@ function sortRowsBySpendDesc(rows) {
     return sb - sa;
   });
 }
-var insightsCommand = defineCommand59({
+var insightsCommand = defineCommand61({
   meta: {
     name: "insights",
     description: `Performance reporting \u2014 the main Meta tool for AI agents.
@@ -9222,8 +10924,8 @@ Async is automatic for heavy queries; pass --async to force it, or --no-async to
 });
 
 // src/commands/ads/meta/pixels.ts
-import { defineCommand as defineCommand60 } from "citty";
-var pixelsCommand = defineCommand60({
+import { defineCommand as defineCommand62 } from "citty";
+var pixelsCommand = defineCommand62({
   meta: {
     name: "pixels",
     description: `List Meta Pixels for an ad account, or fetch firing stats for one pixel.
@@ -9294,7 +10996,7 @@ function emit(data, args) {
 
 // src/commands/ads/meta/preview.ts
 import { writeFileSync as writeFileSync3 } from "fs";
-import { defineCommand as defineCommand61 } from "citty";
+import { defineCommand as defineCommand63 } from "citty";
 var VALID_AD_FORMATS = [
   "DESKTOP_FEED_STANDARD",
   "MOBILE_FEED_STANDARD",
@@ -9328,7 +11030,7 @@ var VALID_AD_FORMATS = [
   "MARKETPLACE_MOBILE",
   "BIZ_DISCO_FEED_MOBILE"
 ];
-var previewCommand = defineCommand61({
+var previewCommand = defineCommand63({
   meta: {
     name: "preview",
     description: `Generate a Meta-hosted preview iframe for a creative or ad. Returns iframe HTML which you
@@ -9375,7 +11077,7 @@ Examples:
 });
 
 // src/commands/ads/meta/index.ts
-var metaCommand = defineCommand62({
+var metaCommand = defineCommand64({
   meta: {
     name: "meta",
     description: `Meta Marketing API \u2014 AI-first command surface (Facebook + Instagram ads).
@@ -9414,11 +11116,11 @@ Audit & review:
     accounts: accountsCommand3,
     account: accountCommand2,
     businesses: businessesCommand,
-    campaigns: campaignsCommand2,
+    campaigns: campaignsCommand3,
     adsets: adsetsCommand,
     ads: adsListCommand,
     creatives: creativesCommand2,
-    audiences: audiencesCommand2,
+    audiences: audiencesCommand3,
     pixels: pixelsCommand,
     activities: activitiesCommand,
     insights: insightsCommand,
@@ -9427,10 +11129,10 @@ Audit & review:
 });
 
 // src/commands/ads/x/index.ts
-import { defineCommand as defineCommand79 } from "citty";
+import { defineCommand as defineCommand81 } from "citty";
 
 // src/commands/ads/x/accounts.ts
-import { defineCommand as defineCommand63 } from "citty";
+import { defineCommand as defineCommand65 } from "citty";
 registerSchema({
   command: "ads.x.accounts",
   description: "List all accessible X Ads accounts. Returns accounts with id (base36), name, approval_status, timezone, currency. Run this first to find account IDs for other commands.",
@@ -9458,7 +11160,7 @@ function handleAccountsError2(err) {
   writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
   process.exit(1);
 }
-var accountsCommand4 = defineCommand63({
+var accountsCommand4 = defineCommand65({
   meta: {
     name: "accounts",
     description: `List accessible X Ads accounts. Returns account IDs needed for all other commands.
@@ -9498,7 +11200,7 @@ Examples:
 });
 
 // src/commands/ads/x/active-entities.ts
-import { defineCommand as defineCommand64 } from "citty";
+import { defineCommand as defineCommand66 } from "citty";
 
 // src/commands/ads/x/error-parser.ts
 function mapXErrorCode(message) {
@@ -9649,7 +11351,7 @@ function parseCsv(v) {
   const parts = v.split(",").map((s) => s.trim()).filter(Boolean);
   return parts.length > 0 ? parts : void 0;
 }
-var activeEntitiesCommand = defineCommand64({
+var activeEntitiesCommand = defineCommand66({
   meta: {
     name: "active-entities",
     description: `List entities with metric activity in a time range.
@@ -9707,7 +11409,7 @@ Examples:
 });
 
 // src/commands/ads/x/audiences.ts
-import { defineCommand as defineCommand65 } from "citty";
+import { defineCommand as defineCommand67 } from "citty";
 registerSchema({
   command: "ads.x.audiences",
   description: "List custom audiences for an X Ads account. Returns id, name, audience_size, audience_type, targetable status. Audiences need 100+ active users in the past 90 days to be targetable.",
@@ -9716,7 +11418,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var audiencesCommand3 = defineCommand65({
+var audiencesCommand4 = defineCommand67({
   meta: {
     name: "audiences",
     description: `List X Ads custom audiences.
@@ -9765,7 +11467,7 @@ Examples:
 });
 
 // src/commands/ads/x/campaigns.ts
-import { defineCommand as defineCommand66 } from "citty";
+import { defineCommand as defineCommand68 } from "citty";
 
 // src/commands/ads/x/run-list.ts
 function buildCleanParams(opts) {
@@ -9828,7 +11530,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var campaignsCommand3 = defineCommand66({
+var campaignsCommand4 = defineCommand68({
   meta: {
     name: "campaigns",
     description: `List X Ads campaigns. Returns budget, schedule, funding instrument, status.
@@ -9870,7 +11572,7 @@ Examples:
 });
 
 // src/commands/ads/x/cards.ts
-import { defineCommand as defineCommand67 } from "citty";
+import { defineCommand as defineCommand69 } from "citty";
 registerSchema({
   command: "ads.x.cards",
   description: "List website cards, video cards, and carousels for an X Ads account.",
@@ -9879,7 +11581,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var cardsCommand = defineCommand67({
+var cardsCommand = defineCommand69({
   meta: {
     name: "cards",
     description: `List X Ads cards (rich creatives).
@@ -9928,7 +11630,7 @@ Examples:
 });
 
 // src/commands/ads/x/funding.ts
-import { defineCommand as defineCommand68 } from "citty";
+import { defineCommand as defineCommand70 } from "citty";
 registerSchema({
   command: "ads.x.funding",
   description: "List funding instruments for an X Ads account. Returns id, type, currency, credit_limit_local_micro, funded_amount_local_micro, status. Falls back to BAKER_X_ADS_ACCOUNT_ID env var.",
@@ -9937,7 +11639,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var fundingCommand = defineCommand68({
+var fundingCommand = defineCommand70({
   meta: {
     name: "funding",
     description: `List funding instruments for an X Ads account.
@@ -9986,7 +11688,7 @@ Examples:
 });
 
 // src/commands/ads/x/line-items.ts
-import { defineCommand as defineCommand69 } from "citty";
+import { defineCommand as defineCommand71 } from "citty";
 registerSchema({
   command: "ads.x.lineItems",
   description: "List line items (ad groups) for an X Ads account. Returns bid, product_type, objective, placements, schedule. Filter by campaign-ids or line-item-ids (CSV).",
@@ -9998,7 +11700,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var lineItemsCommand = defineCommand69({
+var lineItemsCommand = defineCommand71({
   meta: {
     name: "line-items",
     description: `List X Ads line items (ad groups).
@@ -10039,7 +11741,7 @@ Examples:
 });
 
 // src/commands/ads/x/media.ts
-import { defineCommand as defineCommand70 } from "citty";
+import { defineCommand as defineCommand72 } from "citty";
 registerSchema({
   command: "ads.x.media",
   description: "List media assets in the X Ads media library (images, GIFs, videos). Filter by media-type (IMAGE, GIF, VIDEO).",
@@ -10049,7 +11751,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var mediaCommand = defineCommand70({
+var mediaCommand = defineCommand72({
   meta: {
     name: "media",
     description: `List media assets in the X Ads media library.
@@ -10101,7 +11803,7 @@ Examples:
 });
 
 // src/commands/ads/x/promoted-tweets.ts
-import { defineCommand as defineCommand71 } from "citty";
+import { defineCommand as defineCommand73 } from "citty";
 registerSchema({
   command: "ads.x.promotedTweets",
   description: "List promoted tweets for an X Ads account. Returns id, line_item_id, tweet_id, approval_status. Filter by line-item-ids (CSV).",
@@ -10112,7 +11814,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var promotedTweetsCommand = defineCommand71({
+var promotedTweetsCommand = defineCommand73({
   meta: {
     name: "promoted-tweets",
     description: `List X Ads promoted tweets.
@@ -10166,11 +11868,11 @@ Examples:
 });
 
 // src/commands/ads/x/stats/index.ts
-import { defineCommand as defineCommand76 } from "citty";
+import { defineCommand as defineCommand78 } from "citty";
 
 // src/commands/ads/x/stats/job.ts
 import { gunzipSync } from "zlib";
-import { defineCommand as defineCommand72 } from "citty";
+import { defineCommand as defineCommand74 } from "citty";
 var POLL_INTERVAL_MS2 = 1e4;
 var DEADLINE_MS = 12 * 60 * 1e3;
 var RESULT_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
@@ -10240,7 +11942,7 @@ async function pollUntilDone(accountId, jobId) {
 function buildCacheKey(body) {
   return `stats-job:${JSON.stringify(body)}`;
 }
-var statsJobCommand = defineCommand72({
+var statsJobCommand = defineCommand74({
   meta: {
     name: "job",
     description: `Async X Ads stats job, sync from the CLI's perspective. Creates \u2192 polls \u2192 downloads \u2192 returns.
@@ -10345,7 +12047,7 @@ For fine-grained control (don't wait, poll yourself), use:
 });
 
 // src/commands/ads/x/stats/job-create.ts
-import { defineCommand as defineCommand73 } from "citty";
+import { defineCommand as defineCommand75 } from "citty";
 registerSchema({
   command: "ads.x.statsJobCreate",
   description: "Create an asynchronous X Ads stats job (range up to 90 days non-segmented, 45 days segmented). Returns a job id; poll with `stats job-status`. Times must be ISO 8601 hour-aligned.",
@@ -10368,7 +12070,7 @@ function parseCsv3(v) {
   const parts = v.split(",").map((s) => s.trim()).filter(Boolean);
   return parts.length > 0 ? parts : void 0;
 }
-var statsJobCreateCommand = defineCommand73({
+var statsJobCreateCommand = defineCommand75({
   meta: {
     name: "job-create",
     description: `Create an async X Ads stats job (up to 90 days, supports segmentation).
@@ -10431,7 +12133,7 @@ Examples:
 });
 
 // src/commands/ads/x/stats/job-status.ts
-import { defineCommand as defineCommand74 } from "citty";
+import { defineCommand as defineCommand76 } from "citty";
 registerSchema({
   command: "ads.x.statsJobStatus",
   description: "Check the status of one or more X Ads stats jobs. Returns status (PROCESSING|SUCCESS|FAILED) and a downloadable url when SUCCESS. Pass --job-id or --job-ids (CSV).",
@@ -10441,7 +12143,7 @@ registerSchema({
     "job-ids": { type: "string", description: "CSV of job IDs", required: false }
   }
 });
-var statsJobStatusCommand = defineCommand74({
+var statsJobStatusCommand = defineCommand76({
   meta: {
     name: "job-status",
     description: `Poll the status of an async X Ads stats job.
@@ -10482,7 +12184,7 @@ Examples:
 });
 
 // src/commands/ads/x/stats/sync.ts
-import { defineCommand as defineCommand75 } from "citty";
+import { defineCommand as defineCommand77 } from "citty";
 
 // src/commands/ads/x/presets.ts
 var X_STATS_PRESETS = [
@@ -10641,7 +12343,7 @@ async function runSync(args, q) {
     process.exit(1);
   }
 }
-var statsSyncCommand = defineCommand75({
+var statsSyncCommand = defineCommand77({
   meta: {
     name: "sync",
     description: `Synchronous X Ads analytics (max 7-day window).
@@ -10684,7 +12386,7 @@ Examples:
 });
 
 // src/commands/ads/x/stats/index.ts
-var statsCommand = defineCommand76({
+var statsCommand = defineCommand78({
   meta: {
     name: "stats",
     description: `X Ads analytics. Sync (\u22647 days, no segmentation) or async jobs (\u226490 days, segmentable).
@@ -10712,7 +12414,7 @@ Examples:
 });
 
 // src/commands/ads/x/targeting-constants.ts
-import { defineCommand as defineCommand77 } from "citty";
+import { defineCommand as defineCommand79 } from "citty";
 var ALLOWED_CONSTANTS = [
   "locations",
   "interests",
@@ -10740,7 +12442,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var targetingConstantsCommand = defineCommand77({
+var targetingConstantsCommand = defineCommand79({
   meta: {
     name: "targeting-constants",
     description: `Lookup X Ads targeting constants.
@@ -10790,7 +12492,7 @@ Examples:
 });
 
 // src/commands/ads/x/targeting-criteria.ts
-import { defineCommand as defineCommand78 } from "citty";
+import { defineCommand as defineCommand80 } from "citty";
 registerSchema({
   command: "ads.x.targetingCriteria",
   description: "List targeting criteria attached to line items in an X Ads account. Returns targeting_type, targeting_value, name, operator_type per criterion. Filter by line-item-ids.",
@@ -10800,7 +12502,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var targetingCriteriaCommand = defineCommand78({
+var targetingCriteriaCommand = defineCommand80({
   meta: {
     name: "targeting-criteria",
     description: `List targeting criteria attached to line items.
@@ -10851,7 +12553,7 @@ Examples:
 });
 
 // src/commands/ads/x/index.ts
-var xCommand = defineCommand79({
+var xCommand = defineCommand81({
   meta: {
     name: "x",
     description: `X (Twitter) Ads commands. Read campaigns, line items, promoted tweets, creatives, audiences, and analytics.
@@ -10875,12 +12577,12 @@ The CLI auto-detects --account-id when exactly one X Ads account is connected, o
   subCommands: {
     accounts: accountsCommand4,
     funding: fundingCommand,
-    campaigns: campaignsCommand3,
+    campaigns: campaignsCommand4,
     "line-items": lineItemsCommand,
     "promoted-tweets": promotedTweetsCommand,
     cards: cardsCommand,
     media: mediaCommand,
-    audiences: audiencesCommand3,
+    audiences: audiencesCommand4,
     "targeting-criteria": targetingCriteriaCommand,
     "targeting-constants": targetingConstantsCommand,
     "active-entities": activeEntitiesCommand,
@@ -10889,7 +12591,7 @@ The CLI auto-detects --account-id when exactly one X Ads account is connected, o
 });
 
 // src/commands/ads/index.ts
-var adsCommand = defineCommand80({
+var adsCommand2 = defineCommand82({
   meta: {
     name: "ads",
     description: `Ad platform commands. Each platform exposes its own native command surface \u2014 no forced parity.
@@ -10919,11 +12621,11 @@ Examples:
 });
 
 // src/commands/canvas/index.ts
-import { defineCommand as defineCommand88 } from "citty";
+import { defineCommand as defineCommand90 } from "citty";
 
 // src/commands/canvas/catalog.ts
-import { defineCommand as defineCommand81 } from "citty";
-var catalogCommand = defineCommand81({
+import { defineCommand as defineCommand83 } from "citty";
+var catalogCommand = defineCommand83({
   meta: {
     name: "catalog",
     description: "Print the agent-facing node catalog (JSON Schema). Includes every registered node grouped by category."
@@ -10940,9 +12642,9 @@ import { execFile } from "child_process";
 import { readdir, readFile, stat } from "fs/promises";
 import path from "path";
 import { promisify } from "util";
-import { defineCommand as defineCommand82 } from "citty";
+import { defineCommand as defineCommand84 } from "citty";
 var execFileAsync = promisify(execFile);
-var inspectCommand = defineCommand82({
+var inspectCommand = defineCommand84({
   meta: {
     name: "inspect",
     description: "Dump a one-page summary of a canvas run: per-node duration + cache status, list of output files in the run dir, and optionally three thumbnail frames per video output. Pass either a run_id (resolved against --outputs-dir) or an absolute run directory."
@@ -11051,7 +12753,7 @@ async function probeDuration(filePath) {
 // src/commands/canvas/run.ts
 import { readFile as readFile2 } from "fs/promises";
 import path4 from "path";
-import { defineCommand as defineCommand83 } from "citty";
+import { defineCommand as defineCommand85 } from "citty";
 
 // src/commands/canvas/placeholders.ts
 function unsuppliedPlaceholderAssets(canvas) {
@@ -11121,7 +12823,7 @@ async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
 }
 
 // src/commands/canvas/run.ts
-var runCommand = defineCommand83({
+var runCommand = defineCommand85({
   meta: { name: "run", description: "Validate and execute a canvas JSON file." },
   args: {
     file: { type: "positional", required: true, description: "Path to canvas JSON" },
@@ -11233,30 +12935,30 @@ var runCommand = defineCommand83({
 // src/commands/canvas/scaffold-static-ad.ts
 import { readFile as readFile3, writeFile } from "fs/promises";
 import path6 from "path";
-import { defineCommand as defineCommand84 } from "citty";
+import { defineCommand as defineCommand86 } from "citty";
 
 // src/engine/scaffold/staticAd.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 var GEN_ASPECT_RATIOS = /* @__PURE__ */ new Set(["1:1", "4:5", "9:16", "16:9", "4:3", "3:4", "2:3", "3:2", "21:9"]);
 var DEFAULT_ASPECT_RATIO = "9:16";
-var Blueprint = z8.object({
-  meta: z8.object({ estimated_aspect_ratio: z8.string().optional() }).loose().optional(),
-  text_content: z8.array(z8.object({ text: z8.string().optional() }).loose()).optional()
+var Blueprint = z10.object({
+  meta: z10.object({ estimated_aspect_ratio: z10.string().optional() }).loose().optional(),
+  text_content: z10.array(z10.object({ text: z10.string().optional() }).loose()).optional()
 }).loose();
-var ElementLocator = z8.object({
-  collection: z8.enum(["subjects", "people", "brands_logos"]),
-  index: z8.number().int().nonnegative()
+var ElementLocator = z10.object({
+  collection: z10.enum(["subjects", "people", "brands_logos"]),
+  index: z10.number().int().nonnegative()
 }).loose();
-var MainElement = z8.object({
+var MainElement = z10.object({
   // logo | product | person | animal | badge | other
-  type: z8.string(),
-  label: z8.string().optional(),
-  description: z8.string().optional(),
-  expression: z8.string().nullable().optional(),
-  reason: z8.string().optional(),
+  type: z10.string(),
+  label: z10.string().optional(),
+  description: z10.string().optional(),
+  expression: z10.string().nullable().optional(),
+  reason: z10.string().optional(),
   locator: ElementLocator.optional()
 }).loose();
-var MainElements = z8.array(MainElement);
+var MainElements = z10.array(MainElement);
 function sanitizeId(raw, fallback) {
   const id = raw.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
   return /^[a-z]/.test(id) ? id : `${fallback}_${id}`.replace(/_+$/g, "") || fallback;
@@ -11580,7 +13282,7 @@ async function runVisionPasses(canvas) {
     return fail("read_outputs", e instanceof Error ? e.message : String(e));
   }
 }
-var scaffoldStaticAdCommand = defineCommand84({
+var scaffoldStaticAdCommand = defineCommand86({
   meta: {
     name: "scaffold-static-ad",
     description: "Turn a source/inspiration image into a runnable static-ad canvas. Runs billed passes \u2014 image_describe (the blueprint, baked to prompt.json as the editable 'prompt'), an AI selection of the image's MAIN identity elements, and a structured global-layout pass (the column/row grid with per-region bounds and text sizes) \u2014 then scaffolds a canvas that wires one [TODO] ingest slot per element (logo/product/subject/badge + brand font) into image_generate. Edit prompt.json and drop the real assets, then `baker canvas run` it."
@@ -11676,7 +13378,7 @@ var scaffoldStaticAdCommand = defineCommand84({
 // src/commands/canvas/scaffold-video.ts
 import { cp, mkdir, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
 import path9 from "path";
-import { defineCommand as defineCommand85 } from "citty";
+import { defineCommand as defineCommand87 } from "citty";
 
 // src/engine/nodes/local/lib/sceneDetect.ts
 import { execFile as execFile2 } from "child_process";
@@ -11781,7 +13483,7 @@ import { toCardinal as nwKo } from "n2words/ko-KR";
 import { toCardinal as nwNl } from "n2words/nl-NL";
 import { toCardinal as nwPl } from "n2words/pl-PL";
 import { toCardinal as nwPt } from "n2words/pt-PT";
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 
 // src/engine/scaffold/lib/shoot-modes.ts
 var SHOOT_MODES = [
@@ -12081,49 +13783,49 @@ function trimArgs(durationS, offsetS = 0, dims) {
     "{{out.video}}"
   ];
 }
-var FrameAsset = z9.object({ url: z9.string().optional() }).loose().optional();
-var DialogueLine = z9.object({
-  speaker: z9.string().optional(),
-  line: z9.string().optional(),
+var FrameAsset = z11.object({ url: z11.string().optional() }).loose().optional();
+var DialogueLine = z11.object({
+  speaker: z11.string().optional(),
+  line: z11.string().optional(),
   // Absolute seconds on the source timeline (the deconstruct emits both).
-  start_s: z9.number().optional(),
-  end_s: z9.number().optional(),
-  delivery: z9.string().optional(),
-  voice_description: z9.string().optional()
+  start_s: z11.number().optional(),
+  end_s: z11.number().optional(),
+  delivery: z11.string().optional(),
+  voice_description: z11.string().optional()
 }).loose();
-var Sfx = z9.object({
-  at_s: z9.number().optional(),
-  duration_s: z9.number().optional(),
-  sound_effect_prompt: z9.string().optional(),
-  description: z9.string().optional()
+var Sfx = z11.object({
+  at_s: z11.number().optional(),
+  duration_s: z11.number().optional(),
+  sound_effect_prompt: z11.string().optional(),
+  description: z11.string().optional()
 }).loose();
-var CompositionRegion = z9.object({
+var CompositionRegion = z11.object({
   // full | top | bottom | left | right | inset
-  panel: z9.string().optional(),
+  panel: z11.string().optional(),
   // 9-grid anchor for an `inset` presenter box.
-  position: z9.string().optional(),
-  is_presenter: z9.boolean().optional(),
+  position: z11.string().optional(),
+  is_presenter: z11.boolean().optional(),
   // The cast id shown/speaking in this region (routes lip-sync + element refs).
-  cast_ref: z9.string().optional(),
-  summary: z9.string().optional(),
-  frame_prompt: z9.string().optional(),
-  motion_prompt: z9.string().optional()
+  cast_ref: z11.string().optional(),
+  summary: z11.string().optional(),
+  frame_prompt: z11.string().optional(),
+  motion_prompt: z11.string().optional()
 }).loose();
-var SceneComposition = z9.object({
+var SceneComposition = z11.object({
   // full_frame (default) | split_screen | pip | keyed_overlay
-  layout: z9.string().optional(),
+  layout: z11.string().optional(),
   // split_screen only: vertical (top/bottom) | horizontal (left/right).
-  split_axis: z9.string().optional(),
-  regions: z9.array(CompositionRegion).optional()
+  split_axis: z11.string().optional(),
+  regions: z11.array(CompositionRegion).optional()
 }).loose();
-var CameraMotion = z9.object({ movement: z9.string().optional(), detail: z9.string().optional() }).loose();
-var TranscriptWord = z9.object({ text: z9.string().optional() }).loose();
-var Scene = z9.object({
-  start_s: z9.number().optional(),
-  end_s: z9.number().optional(),
-  duration_s: z9.number().optional(),
-  summary: z9.string().optional(),
-  action_detail: z9.string().optional(),
+var CameraMotion = z11.object({ movement: z11.string().optional(), detail: z11.string().optional() }).loose();
+var TranscriptWord = z11.object({ text: z11.string().optional() }).loose();
+var Scene = z11.object({
+  start_s: z11.number().optional(),
+  end_s: z11.number().optional(),
+  duration_s: z11.number().optional(),
+  summary: z11.string().optional(),
+  action_detail: z11.string().optional(),
   // The scene's spatial layout. Absent/full_frame ⇒ one uncut shot (default path).
   // A layered layout (split_screen/pip/keyed_overlay) with regions ⇒ the scaffold
   // builds one clip per region and stacks/overlays them into the scene picture.
@@ -12131,77 +13833,77 @@ var Scene = z9.object({
   // The capture "look" for this scene — selected from the ad-native shoot-mode
   // grammar (see lib/shoot-modes.ts). When absent the scaffold auto-derives a
   // UGC/product mode; a human can override per scene by setting this.
-  shoot_mode: z9.string().optional(),
+  shoot_mode: z11.string().optional(),
   // Diegetic ambient the clip's native audio should carry (no music). When
   // absent the scene falls back to its shoot mode's default ambience.
-  ambient: z9.string().optional(),
+  ambient: z11.string().optional(),
   camera_motion: CameraMotion.optional(),
-  start_frame_prompt: z9.string().optional(),
-  end_frame_prompt: z9.string().optional(),
-  motion_prompt: z9.string().optional(),
+  start_frame_prompt: z11.string().optional(),
+  end_frame_prompt: z11.string().optional(),
+  motion_prompt: z11.string().optional(),
   // The scene's role in the ad's persuasion arc (DECON-supplied); drives the
   // script re-craft checklist. Inferred from position when absent.
-  narrative_role: z9.string().optional(),
+  narrative_role: z11.string().optional(),
   // DECON-supplied on the HOOK scene: the engineered physical/emotional state that
   // makes the first frame stop the scroll (sweaty/breathless/urgent …). Injected
   // into the hook's start-frame description so the generator renders that state,
   // not a calm influencer (CCA-11).
-  hook_mechanic: z9.object({ mechanic: z9.string().optional(), why_it_stops_scroll: z9.string().optional() }).loose().optional(),
+  hook_mechanic: z11.object({ mechanic: z11.string().optional(), why_it_stops_scroll: z11.string().optional() }).loose().optional(),
   // DECON-supplied per-scene location (so a gym hook isn't flattened to "home").
-  scene_setting: z9.string().optional(),
+  scene_setting: z11.string().optional(),
   // How this scene cuts to the next (DECON-supplied). A recognized non-cut type
   // (fade/whip/zoom/dissolve/swipe) is reproduced as an ffmpeg xfade at the
   // boundary; cut/match_cut/none/other stay hard cuts. The last scene's value is
   // ignored (nothing follows it).
-  transition_out: z9.object({ type: z9.string().optional(), description: z9.string().optional() }).loose().optional(),
-  dialogue: z9.array(DialogueLine).optional(),
-  sfx: z9.array(Sfx).optional(),
-  overlays: z9.array(z9.unknown()).optional(),
-  floating_elements: z9.array(z9.unknown()).optional(),
-  transcript_slice: z9.array(TranscriptWord).optional(),
+  transition_out: z11.object({ type: z11.string().optional(), description: z11.string().optional() }).loose().optional(),
+  dialogue: z11.array(DialogueLine).optional(),
+  sfx: z11.array(Sfx).optional(),
+  overlays: z11.array(z11.unknown()).optional(),
+  floating_elements: z11.array(z11.unknown()).optional(),
+  transcript_slice: z11.array(TranscriptWord).optional(),
   start_frame_asset: FrameAsset,
   end_frame_asset: FrameAsset,
   // DECON-supplied: true when this scene is a length-split CONTINUATION of the
   // previous one (the SAME physical shot, broken up only because it exceeded the
   // clip ceiling). The scaffold then shares the splice keyframe — this scene's
   // start frame IS the previous scene's end frame — so the join is seamless.
-  continues_previous: z9.boolean().optional()
+  continues_previous: z11.boolean().optional()
 }).loose();
-var VideoBlueprint = z9.object({
-  source: z9.object({ aspect_ratio: z9.string().optional(), duration_s: z9.number().optional() }).loose().optional(),
-  global: z9.object({
-    music: z9.object({
-      present: z9.boolean().optional(),
-      music_prompt: z9.string().optional(),
+var VideoBlueprint = z11.object({
+  source: z11.object({ aspect_ratio: z11.string().optional(), duration_s: z11.number().optional() }).loose().optional(),
+  global: z11.object({
+    music: z11.object({
+      present: z11.boolean().optional(),
+      music_prompt: z11.string().optional(),
       // Absolute second the music enters in the reference (the bed often
       // kicks in mid-ad, after the hook). We start the regenerated track here
       // instead of at 0 so the timing matches.
-      starts_at_s: z9.number().optional(),
+      starts_at_s: z11.number().optional(),
       // Populated by the deconstruct when AudD (Shazam-style) recognizes the
       // reference track. We never reuse it — only style the regenerated bed.
-      identified_track: z9.object({ title: z9.string().optional(), artist: z9.string().optional() }).loose().nullish()
+      identified_track: z11.object({ title: z11.string().optional(), artist: z11.string().optional() }).loose().nullish()
     }).loose().optional(),
-    cast: z9.array(
-      z9.object({
-        id: z9.string().optional(),
-        description: z9.string().optional(),
+    cast: z11.array(
+      z11.object({
+        id: z11.string().optional(),
+        description: z11.string().optional(),
         // The deconstruct's note on the target-market localization (e.g. "native
         // French speaker") — read to derive the spoken-track language code.
-        market_localization_note: z9.string().optional()
+        market_localization_note: z11.string().optional()
       }).loose()
     ).optional(),
-    voiceover: z9.object({
+    voiceover: z11.object({
       // on_camera | mixed → mouths are on screen (lip-sync candidates);
       // voiceover | none → narration over the picture (no lip-sync).
-      mode: z9.string().optional(),
-      voice_description: z9.string().optional(),
-      persona: z9.string().optional()
+      mode: z11.string().optional(),
+      voice_description: z11.string().optional(),
+      persona: z11.string().optional()
     }).loose().optional(),
     // Visual palette — read only to colour a clean brand-card/CTA plate (the
     // first hex is the dominant brand colour); never to drive frame generation.
-    style: z9.object({ palette: z9.array(z9.object({ hex: z9.string().optional() }).loose()).optional() }).loose().optional()
+    style: z11.object({ palette: z11.array(z11.object({ hex: z11.string().optional() }).loose()).optional() }).loose().optional()
   }).loose().optional(),
-  scenes: z9.array(Scene).min(1)
+  scenes: z11.array(Scene).min(1)
 }).loose();
 function injectHookPhysicality(blueprint) {
   for (const scene of blueprint.scenes) {
@@ -12211,26 +13913,26 @@ function injectHookPhysicality(blueprint) {
     scene.start_frame_prompt = `${prompt} The subject's physical state IS the scroll-stopper \u2014 render it explicitly, not a calm pose: ${why}.`;
   }
 }
-var AppearsItem = z9.union([z9.number(), z9.object({ scene: z9.number(), edge: z9.string().optional() }).loose()]);
-var RecurringElement = z9.object({
+var AppearsItem = z11.union([z11.number(), z11.object({ scene: z11.number(), edge: z11.string().optional() }).loose()]);
+var RecurringElement = z11.object({
   // person | animal | product | logo | badge | other
-  type: z9.string(),
-  label: z9.string().optional(),
-  description: z9.string().optional(),
-  expression: z9.string().nullable().optional(),
+  type: z11.string(),
+  label: z11.string().optional(),
+  description: z11.string().optional(),
+  expression: z11.string().nullable().optional(),
   // When the element maps to a global cast entry, its stable id (for annotation).
-  cast_id: z9.string().nullable().optional(),
+  cast_id: z11.string().nullable().optional(),
   // The label of another element that is the SAME individual as this one, shown
   // in a DIFFERENT wardrobe/persona/state (e.g. one creator playing skeptic in a
   // pink shirt and believer in a white shirt). Each look gets its own reference
   // slot, but the face/identity must stay identical across them.
-  same_as: z9.string().nullable().optional(),
+  same_as: z11.string().nullable().optional(),
   // Scenes the element appears in. Either a bare list of scene indices (both
   // edges) or per-{scene,edge} entries. Both forms are accepted and merged.
-  scenes: z9.array(z9.number()).optional(),
-  appears_in: z9.array(AppearsItem).optional()
+  scenes: z11.array(z11.number()).optional(),
+  appears_in: z11.array(AppearsItem).optional()
 }).loose();
-var RecurringElements = z9.array(RecurringElement);
+var RecurringElements = z11.array(RecurringElement);
 function sanitizeId2(raw, fallback) {
   const id = raw.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
   return /^[a-z]/.test(id) ? id : `${fallback}_${id}`.replace(/_+$/g, "") || fallback;
@@ -13756,25 +15458,25 @@ function buildSfxMusic(blueprint, nodes) {
   }
   return tracks;
 }
-var OverlayStyle = z9.object({ color_hex: z9.string().optional(), background: z9.string().optional(), size: z9.string().optional() }).loose();
-var Overlay = z9.object({
-  text: z9.string().optional(),
-  appears_at_s: z9.number().optional(),
-  duration_s: z9.number().optional(),
-  position: z9.string().optional(),
-  role: z9.string().optional(),
-  animation: z9.string().optional(),
-  animation_detail: z9.string().optional(),
+var OverlayStyle = z11.object({ color_hex: z11.string().optional(), background: z11.string().optional(), size: z11.string().optional() }).loose();
+var Overlay = z11.object({
+  text: z11.string().optional(),
+  appears_at_s: z11.number().optional(),
+  duration_s: z11.number().optional(),
+  position: z11.string().optional(),
+  role: z11.string().optional(),
+  animation: z11.string().optional(),
+  animation_detail: z11.string().optional(),
   style: OverlayStyle.optional()
 }).loose();
-var FloatingElement = z9.object({
-  kind: z9.string().optional(),
-  description: z9.string().optional(),
-  brand_name: z9.string().nullish(),
-  what_it_represents: z9.string().optional(),
-  appears_at_s: z9.number().optional(),
-  duration_s: z9.number().optional(),
-  position: z9.string().optional()
+var FloatingElement = z11.object({
+  kind: z11.string().optional(),
+  description: z11.string().optional(),
+  brand_name: z11.string().nullish(),
+  what_it_represents: z11.string().optional(),
+  appears_at_s: z11.number().optional(),
+  duration_s: z11.number().optional(),
+  position: z11.string().optional()
 }).loose();
 function escapeHtml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -13806,7 +15508,7 @@ function positionClass(position) {
 function collectCaptions(blueprint) {
   return blueprint.scenes.flatMap((scene) => {
     const sceneStart = scene.start_s ?? 0;
-    const overlays = z9.array(Overlay).safeParse(scene.overlays ?? []);
+    const overlays = z11.array(Overlay).safeParse(scene.overlays ?? []);
     return overlays.success ? overlays.data.filter((ov) => Boolean(ov.text?.trim())).map((ov) => {
       const at = ov.appears_at_s ?? sceneStart;
       return { text: ov.text.trim(), at, end: at + (ov.duration_s ?? 2.5), ov };
@@ -13935,7 +15637,7 @@ function buildOverlayHtml(input) {
   };
   for (const scene of blueprint.scenes) {
     const sceneStart = scene.start_s ?? 0;
-    const floats = z9.array(FloatingElement).safeParse(scene.floating_elements ?? []);
+    const floats = z11.array(FloatingElement).safeParse(scene.floating_elements ?? []);
     const parts = (floats.success ? floats.data.filter((fe) => keepFloat(fe, sceneStart)).map((fe) => floatingStub(fe, sceneStart)) : []).filter(Boolean);
     const pip = uiPipStub(scene);
     if (pip) parts.push(pip);
@@ -14196,8 +15898,8 @@ function buildMotionBoard(blueprint) {
     const end_s = scene.end_s ?? start_s + sceneDurationS(scene);
     cursor = end_s;
     const spoken = sceneSpokenText(scene);
-    const overlays = z9.array(Overlay).safeParse(scene.overlays ?? []);
-    const floats = z9.array(FloatingElement).safeParse(scene.floating_elements ?? []);
+    const overlays = z11.array(Overlay).safeParse(scene.overlays ?? []);
+    const floats = z11.array(FloatingElement).safeParse(scene.floating_elements ?? []);
     const graphics = [
       ...(overlays.success ? overlays.data : []).filter((ov) => ov.text?.trim()).map((ov) => ({
         kind: "text",
@@ -14659,7 +16361,7 @@ async function runAnalysisPasses(deconstructCanvas, selectModel) {
     return fail2("deconstruct", e instanceof Error ? e.message : String(e));
   }
 }
-var scaffoldVideoCommand = defineCommand85({
+var scaffoldVideoCommand = defineCommand87({
   meta: {
     name: "scaffold-video",
     description: "Turn a reference video into a runnable reproduction canvas in one command. Runs billed passes \u2014 video_deconstruct (the full scene-by-scene blueprint + transcript, baked to prompt.json as the editable 'prompt') and an AI selection of the video's RECURRING identity elements (person/animal/product/logo) \u2014 then scaffolds a pipeline where every scene boundary is a static-ad-grade frame (the blueprint as target_blueprint, a reference legend, the real frame as anchor) and each recurring element gets ONE shared [TODO] ingest slot wired into every frame it appears in. The clips feed Seedance an ultra-detailed motion brief (action, camera, dialogue, transcript). Edit prompt.json, drop the real source images, then `baker canvas run`."
@@ -14828,7 +16530,7 @@ var scaffoldVideoCommand = defineCommand85({
 // src/commands/canvas/set-prompt.ts
 import { readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
 import path10 from "path";
-import { defineCommand as defineCommand86 } from "citty";
+import { defineCommand as defineCommand88 } from "citty";
 function setNodePrompt(canvas, nodeId, text) {
   const nodes = canvas?.nodes;
   if (!Array.isArray(nodes)) throw new Error("canvas has no nodes array");
@@ -14843,7 +16545,7 @@ function setNodePrompt(canvas, nodeId, text) {
   newNodes[idx] = newNode;
   return { ...canvas, nodes: newNodes };
 }
-var setPromptCommand = defineCommand86({
+var setPromptCommand = defineCommand88({
   meta: {
     name: "set-prompt",
     description: "Safely set a node's params.prompt (a frame description, motion prompt, etc.) without hand-editing the JSON. Prefer --text-file for multi-line/accented copy \u2014 it preserves UTF-8 exactly, unlike shell-quoted jq."
@@ -14903,8 +16605,8 @@ var setPromptCommand = defineCommand86({
 // src/commands/canvas/validate.ts
 import { readFile as readFile8 } from "fs/promises";
 import path11 from "path";
-import { defineCommand as defineCommand87 } from "citty";
-var validateCommand = defineCommand87({
+import { defineCommand as defineCommand89 } from "citty";
+var validateCommand = defineCommand89({
   meta: {
     name: "validate",
     description: "Validate a canvas JSON file (no execution). Includes a per-node cost preview and runs each node's deep validators (composition meta checks for hyperframe_render/_snapshot)."
@@ -14947,7 +16649,7 @@ var validateCommand = defineCommand87({
 });
 
 // src/commands/canvas/index.ts
-var canvasCommand = defineCommand88({
+var canvasCommand = defineCommand90({
   meta: {
     name: "canvas",
     description: `Run Baker creative canvas JSON files locally. Local nodes execute in-process; remote nodes POST to the Convex backend gateway.
@@ -14974,10 +16676,10 @@ Subcommands:
 });
 
 // src/commands/creatives/index.ts
-import { defineCommand as defineCommand90 } from "citty";
+import { defineCommand as defineCommand92 } from "citty";
 
 // src/commands/creatives/publish.ts
-import { defineCommand as defineCommand89 } from "citty";
+import { defineCommand as defineCommand91 } from "citty";
 
 // src/commands/images/api.ts
 import { readFile as readFile9 } from "fs/promises";
@@ -15100,7 +16802,7 @@ async function publishCreative(args, deps = defaultImageApiDeps) {
     sourceReferenceUrl
   });
 }
-var publishCommand = defineCommand89({
+var publishCommand = defineCommand91({
   meta: {
     name: "publish",
     description: "Publish a final static creative image to Baker Creatives and print the creative reference JSON."
@@ -15146,7 +16848,7 @@ var publishCommand = defineCommand89({
 });
 
 // src/commands/creatives/index.ts
-var creativesCommand3 = defineCommand90({
+var creativesCommand3 = defineCommand92({
   meta: {
     name: "creatives",
     description: `Publish static ad creatives as first-class Baker outputs.
@@ -15162,10 +16864,10 @@ Publishing uploads the image to the Company image library, applies the official
 });
 
 // src/commands/ga4/index.ts
-import { defineCommand as defineCommand94 } from "citty";
+import { defineCommand as defineCommand96 } from "citty";
 
 // src/commands/ga4/audit.ts
-import { defineCommand as defineCommand91 } from "citty";
+import { defineCommand as defineCommand93 } from "citty";
 
 // src/commands/ga4/resolve.ts
 async function fetchProperties(useCache = true) {
@@ -15228,7 +16930,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
   }
 });
-var auditCommand2 = defineCommand91({
+var auditCommand2 = defineCommand93({
   meta: {
     name: "audit",
     description: `Run all GA4 admin health checks. Returns property config with playbook warnings.
@@ -15280,7 +16982,7 @@ Examples:
 });
 
 // src/commands/ga4/properties.ts
-import { defineCommand as defineCommand92 } from "citty";
+import { defineCommand as defineCommand94 } from "citty";
 registerSchema({
   command: "ga4.properties",
   description: "List all accessible GA4 properties. Returns property IDs needed for query and audit commands. Run this first to find property IDs.",
@@ -15288,7 +16990,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
   }
 });
-var propertiesCommand = defineCommand92({
+var propertiesCommand = defineCommand94({
   meta: {
     name: "properties",
     description: `List accessible GA4 properties.
@@ -15336,9 +17038,9 @@ Examples:
 });
 
 // src/commands/ga4/query.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve2 } from "path";
-import { defineCommand as defineCommand93 } from "citty";
+import { defineCommand as defineCommand95 } from "citty";
 
 // src/commands/ga4/presets.ts
 var GA4_PRESETS = [
@@ -15427,7 +17129,7 @@ function writeRowsToFile2(filePath, rows, append) {
       writeFileSync4(filePath, content, "utf-8");
     }
   } else if (append && existsSync5(filePath)) {
-    const existing = JSON.parse(readFileSync8(filePath, "utf-8"));
+    const existing = JSON.parse(readFileSync9(filePath, "utf-8"));
     writeFileSync4(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync4(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -15470,7 +17172,7 @@ function handleError(err) {
   });
   process.exit(1);
 }
-var queryCommand2 = defineCommand93({
+var queryCommand2 = defineCommand95({
   meta: {
     name: "query",
     description: `Run GA4 Data API reports. Preset-first with free-form escape hatch.
@@ -15541,7 +17243,7 @@ Free-form (escape hatch):
 });
 
 // src/commands/ga4/index.ts
-var ga4Command = defineCommand94({
+var ga4Command = defineCommand96({
   meta: {
     name: "ga4",
     description: `Google Analytics 4 commands. Audit property config, run playbook-aligned reports.
@@ -15564,12 +17266,12 @@ Examples:
 });
 
 // src/commands/gsc/index.ts
-import { defineCommand as defineCommand98 } from "citty";
+import { defineCommand as defineCommand100 } from "citty";
 
 // src/commands/gsc/query.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
 import { resolve as resolve3 } from "path";
-import { defineCommand as defineCommand95 } from "citty";
+import { defineCommand as defineCommand97 } from "citty";
 
 // src/commands/gsc/presets.ts
 var GSC_PRESETS = [
@@ -15712,7 +17414,7 @@ function writeRowsToFile3(filePath, rows, append) {
       writeFileSync5(filePath, content, "utf-8");
     }
   } else if (append && existsSync6(filePath)) {
-    const existing = JSON.parse(readFileSync9(filePath, "utf-8"));
+    const existing = JSON.parse(readFileSync10(filePath, "utf-8"));
     writeFileSync5(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync5(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -15757,7 +17459,7 @@ function handleError2(err) {
   });
   process.exit(1);
 }
-var queryCommand3 = defineCommand95({
+var queryCommand3 = defineCommand97({
   meta: {
     name: "query",
     description: `Run GSC Search Analytics queries. Preset-first with free-form escape hatch.
@@ -15835,7 +17537,7 @@ Free-form (escape hatch):
 });
 
 // src/commands/gsc/sitemaps.ts
-import { defineCommand as defineCommand96 } from "citty";
+import { defineCommand as defineCommand98 } from "citty";
 registerSchema({
   command: "gsc.sitemaps",
   description: "List sitemaps for a Search Console site. Check sitemap health and errors.",
@@ -15844,7 +17546,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
   }
 });
-var sitemapsCommand = defineCommand96({
+var sitemapsCommand = defineCommand98({
   meta: {
     name: "sitemaps",
     description: `List sitemaps for a site. Check health and errors.
@@ -15894,7 +17596,7 @@ Examples:
 });
 
 // src/commands/gsc/sites.ts
-import { defineCommand as defineCommand97 } from "citty";
+import { defineCommand as defineCommand99 } from "citty";
 registerSchema({
   command: "gsc.sites",
   description: "List all verified Google Search Console sites. Returns site URLs needed for query and sitemaps commands.",
@@ -15902,7 +17604,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
   }
 });
-var sitesCommand = defineCommand97({
+var sitesCommand = defineCommand99({
   meta: {
     name: "sites",
     description: `List verified Search Console sites.
@@ -15950,7 +17652,7 @@ Examples:
 });
 
 // src/commands/gsc/index.ts
-var gscCommand = defineCommand98({
+var gscCommand = defineCommand100({
   meta: {
     name: "gsc",
     description: `Google Search Console commands. PPC-SEO arbitrage, brand halo analysis, negative keyword discovery.
@@ -15973,10 +17675,10 @@ Examples:
 });
 
 // src/commands/images/index.ts
-import { defineCommand as defineCommand122 } from "citty";
+import { defineCommand as defineCommand124 } from "citty";
 
 // src/commands/images/crop.ts
-import { defineCommand as defineCommand99 } from "citty";
+import { defineCommand as defineCommand101 } from "citty";
 
 // src/lib/image/crop-sprite.ts
 import sharp from "sharp";
@@ -16101,7 +17803,7 @@ function emitError2(err) {
   }
   process.exit(1);
 }
-var cropCommand = defineCommand99({
+var cropCommand = defineCommand101({
   meta: {
     name: "crop",
     description: "Crop a rectangular region from an image.\n\nExample: baker images crop sprite.png --x 0 --y 0 --width 64 --height 64 --output icon.png"
@@ -16137,7 +17839,7 @@ var cropCommand = defineCommand99({
 });
 
 // src/commands/images/delete.ts
-import { defineCommand as defineCommand100 } from "citty";
+import { defineCommand as defineCommand102 } from "citty";
 registerSchema({
   command: "images.delete",
   description: "Delete an image by ID",
@@ -16151,7 +17853,7 @@ registerSchema({
     }
   }
 });
-var deleteCommand = defineCommand100({
+var deleteCommand = defineCommand102({
   meta: {
     name: "delete",
     description: "Delete an image by ID. Use --dry-run to preview. Example: baker images delete j571abc123 --dry-run"
@@ -16192,7 +17894,7 @@ var deleteCommand = defineCommand100({
 });
 
 // src/commands/images/dimensions.ts
-import { defineCommand as defineCommand101 } from "citty";
+import { defineCommand as defineCommand103 } from "citty";
 
 // src/lib/image/dimensions.ts
 import { imageSize } from "image-size";
@@ -16215,7 +17917,7 @@ registerSchema({
     target: { type: "string", description: "Local file path or remote http(s) URL", required: true }
   }
 });
-var dimensionsCommand = defineCommand101({
+var dimensionsCommand = defineCommand103({
   meta: {
     name: "dimensions",
     description: "Read image dimensions without decoding the full file.\n\nExample: baker images dimensions ./logo.png\nExample: baker images dimensions https://acme.com/hero.png"
@@ -16259,7 +17961,7 @@ var dimensionsCommand = defineCommand101({
 });
 
 // src/commands/images/extract.ts
-import { defineCommand as defineCommand102 } from "citty";
+import { defineCommand as defineCommand104 } from "citty";
 registerSchema({
   command: "images.extract",
   description: "Extract images from a URL via Firecrawl (formats: images).",
@@ -16275,7 +17977,7 @@ registerSchema({
     }
   }
 });
-var extractCommand = defineCommand102({
+var extractCommand = defineCommand104({
   meta: {
     name: "extract",
     description: "Pull every image from a single URL via Firecrawl. ~$0.001/scrape. Cap auto-ingest at 20.\n\nExample: baker images extract https://stripe.com --auto-ingest 5"
@@ -16313,7 +18015,7 @@ var extractCommand = defineCommand102({
 });
 
 // src/commands/images/find.ts
-import { defineCommand as defineCommand103 } from "citty";
+import { defineCommand as defineCommand105 } from "citty";
 registerSchema({
   command: "images.find",
   description: "Fanout image search: library first, then opted-in external providers.",
@@ -16345,7 +18047,7 @@ registerSchema({
     }
   }
 });
-var findCommand = defineCommand103({
+var findCommand = defineCommand105({
   meta: {
     name: "find",
     description: "Library-first fanout image search. Opt in to providers with --sources. `--fallback` short-circuits to externals only when library is thin. With --auto-ingest, ingested external hits return Baker-owned URLs.\n\nExample: baker images find 'office' --sources library,magnific --limit 20"
@@ -16394,7 +18096,7 @@ var findCommand = defineCommand103({
 
 // src/commands/images/generate.ts
 import { readFile as readFile11 } from "fs/promises";
-import { defineCommand as defineCommand104 } from "citty";
+import { defineCommand as defineCommand106 } from "citty";
 import sharp2 from "sharp";
 var GENERATE_TIMEOUT_MS = 18e4;
 var REFERENCE_MAX_EDGE = 1536;
@@ -16497,7 +18199,7 @@ async function resolveReferences(spec) {
   }
   return out;
 }
-var generateCommand = defineCommand104({
+var generateCommand = defineCommand106({
   meta: {
     name: "generate",
     description: "Generate an image with AI and store it in the library (cost-tracked per request via OpenRouter usage). Models mirror the canvas: openai/gpt-5.4-image-2 (default \u2014 photoreal, cleanest text, best for ad/landing reproduction), google/gemini-3-pro-image-preview (Nano Banana Pro), google/gemini-3.5-flash & google/gemini-3.1-flash-image-preview (fast, extreme aspect ratios), recraft/recraft-v4.1-pro-vector (vector/SVG-style with palette control). The result is auto-ingested (describe + embed), so the next `baker images library` query finds it. Pass --reference with image URLs and/or local file paths (Pinterest, stock, brand assets, sandbox files) to ground generation in reality.\n\nExamples:\n  baker images generate 'a friendly golden retriever sitting in a bright modern living room' --aspect-ratio 16:9\n  baker images generate 'hero shot of a matte black water bottle on marble' --model google/gemini-3-pro-image-preview --image-size 2K\n  baker images generate 'lifestyle photo matching this mood' --reference 'https://\u2026/ref1.jpg,https://\u2026/ref2.jpg'\n  baker images generate 'put this product on a marble countertop, soft daylight' --reference './src/brand/logos/product.png,./refs/kitchen-mood.jpg'\n  baker images generate 'flat geometric mascot, brand palette' --model recraft/recraft-v4.1-pro-vector --rgb-colors '[[10,10,10],[255,80,0]]'"
@@ -16549,7 +18251,7 @@ var generateCommand = defineCommand104({
 });
 
 // src/commands/images/get.ts
-import { defineCommand as defineCommand105 } from "citty";
+import { defineCommand as defineCommand107 } from "citty";
 registerSchema({
   command: "images.get",
   description: "Get a single image by ID",
@@ -16557,7 +18259,7 @@ registerSchema({
     id: { type: "string", description: "Image ID", required: true }
   }
 });
-var getCommand2 = defineCommand105({
+var getCommand2 = defineCommand107({
   meta: { name: "get", description: "Get a single image by ID. Example: baker images get j571abc123" },
   args: {
     id: { type: "positional", description: "Image ID", required: false },
@@ -16593,7 +18295,7 @@ var getCommand2 = defineCommand105({
 });
 
 // src/commands/images/gif.ts
-import { defineCommand as defineCommand106 } from "citty";
+import { defineCommand as defineCommand108 } from "citty";
 registerSchema({
   command: "images.gif",
   description: "Search Giphy for GIFs / reaction memes (paid social creative).",
@@ -16625,7 +18327,7 @@ registerSchema({
     }
   }
 });
-var gifCommand = defineCommand106({
+var gifCommand = defineCommand108({
   meta: {
     name: "gif",
     description: "Search Giphy for GIFs / reaction memes \u2014 built for paid-social creative (Meta, TikTok, LinkedIn, X). Free API. Each hit carries WebP + GIF + MP4 URLs in providerMeta so you can pick the right format per platform.\n\nExample: baker images gif 'this is fine' --limit 10\nExample: baker images gif 'office reaction' --rating pg --auto-ingest 2\nExample: baker images gif --trending --limit 25"
@@ -16672,7 +18374,7 @@ var gifCommand = defineCommand106({
 });
 
 // src/commands/images/google.ts
-import { defineCommand as defineCommand107 } from "citty";
+import { defineCommand as defineCommand109 } from "citty";
 registerSchema({
   command: "images.google",
   description: "Google Images search via the official Custom Search JSON API. Unverified source \u2014 inspect before placing.",
@@ -16708,7 +18410,7 @@ registerSchema({
     }
   }
 });
-var googleCommand2 = defineCommand107({
+var googleCommand2 = defineCommand109({
   meta: {
     name: "google",
     description: "Google Images via the official Custom Search JSON API ($0.005/query, free 100/day). \u26A0 Source unverified \u2014 watermarks, low-res, mislabeled results are common. Use as last resort. With --auto-ingest, ingested hits return Baker-owned URLs.\n\nExample: baker images google 'industrial workshop' --type photo --size large --limit 20"
@@ -16756,7 +18458,7 @@ var googleCommand2 = defineCommand107({
 });
 
 // src/commands/images/icon.ts
-import { defineCommand as defineCommand108 } from "citty";
+import { defineCommand as defineCommand110 } from "citty";
 registerSchema({
   command: "images.icon",
   description: "Icon lookup via Iconify (200+ icon sets, free CDN).",
@@ -16782,7 +18484,7 @@ registerSchema({
     }
   }
 });
-var iconCommand = defineCommand108({
+var iconCommand = defineCommand110({
   meta: {
     name: "icon",
     description: "Icon via Iconify (simple-icons, logos, lucide, devicon, heroicons, tabler, phosphor, material-symbols, \u2026). Free CDN, no API key.\n\nExample: baker images icon react --set devicon\nExample: baker images icon lucide:check --color '#0a0a0a'"
@@ -16822,7 +18524,7 @@ var iconCommand = defineCommand108({
 });
 
 // src/commands/images/ingest.ts
-import { defineCommand as defineCommand109 } from "citty";
+import { defineCommand as defineCommand111 } from "citty";
 registerSchema({
   command: "images.ingest",
   description: "Ingest a remote image URL into the library (full describe + embed).",
@@ -16834,7 +18536,7 @@ registerSchema({
     context: { type: "string", description: "Description context hint", required: false }
   }
 });
-var ingestCommand = defineCommand109({
+var ingestCommand = defineCommand111({
   meta: {
     name: "ingest",
     description: "Download a remote URL and store it in the library. Hash-deduped on bytes + externalId.\n\nExample: baker images ingest https://img.freepik.com/free-photo/xyz.jpg --source magnific --external-id 12345"
@@ -16876,7 +18578,7 @@ var ingestCommand = defineCommand109({
 });
 
 // src/commands/images/library.ts
-import { defineCommand as defineCommand110 } from "citty";
+import { defineCommand as defineCommand112 } from "citty";
 registerSchema({
   command: "images.library",
   description: "Search the company image library. Returns only ready images.",
@@ -16902,7 +18604,7 @@ registerSchema({
     }
   }
 });
-var libraryCommand = defineCommand110({
+var libraryCommand = defineCommand112({
   meta: {
     name: "library",
     description: "Search the company image library (hybrid BM25 + vector + Cohere rerank). Use this BEFORE any external provider.\n\nExample: baker images library 'hero banner' --aspect-ratio 16:9 --source magnific"
@@ -16959,7 +18661,7 @@ var libraryCommand = defineCommand110({
 });
 
 // src/commands/images/logo.ts
-import { defineCommand as defineCommand111 } from "citty";
+import { defineCommand as defineCommand113 } from "citty";
 registerSchema({
   command: "images.logo",
   description: "Brand logo lookup via Brandfetch CDN (fallback/404). Auto-ingests by default.",
@@ -16984,7 +18686,7 @@ registerSchema({
     }
   }
 });
-var logoCommand = defineCommand111({
+var logoCommand = defineCommand113({
   meta: {
     name: "logo",
     description: "Brand logo via Brandfetch CDN. Returns up to 5 variants (icon, light/dark logo, light/dark symbol). Auto-ingests the first variant.\n\nExample: baker images logo stripe.com --variant logo"
@@ -17022,7 +18724,7 @@ var logoCommand = defineCommand111({
 });
 
 // src/commands/images/normalize.ts
-import { defineCommand as defineCommand112 } from "citty";
+import { defineCommand as defineCommand114 } from "citty";
 
 // src/lib/image/color-changer.ts
 import quantize from "quantize";
@@ -17754,7 +19456,7 @@ function coerceRawArgs(args) {
     "dry-run": bool(args["dry-run"])
   };
 }
-var normalizeCommand = defineCommand112({
+var normalizeCommand = defineCommand114({
   meta: {
     name: "normalize",
     description: `Normalize logos / images: declarative recolor + bg removal + trim + resize. Operates on local files; writes in-place by default.
@@ -17809,7 +19511,7 @@ Examples:
 });
 
 // src/commands/images/pinterest.ts
-import { defineCommand as defineCommand113 } from "citty";
+import { defineCommand as defineCommand115 } from "citty";
 registerSchema({
   command: "images.pinterest",
   description: "Pinterest image search via ScrapeCreators. Reference-grade real-world photography, product styling, interiors, fashion, food, and aesthetic mood boards. Inspect before placing \u2014 Pinterest is unverified, trademark-bearing web content.",
@@ -17829,7 +19531,7 @@ registerSchema({
     }
   }
 });
-var pinterestCommand = defineCommand113({
+var pinterestCommand = defineCommand115({
   meta: {
     name: "pinterest",
     description: "Pinterest image search via ScrapeCreators ($0.00188/request). Best for photo-realistic reference imagery \u2014 lifestyle, interiors, fashion, food, product styling, and mood boards to brief AI generation against. \u26A0 Unverified, trademark-bearing web content \u2014 inspect and respect rights before placing on a customer page. Browse first; auto-ingest only the pins you commit to.\n\nExamples:\n  baker images pinterest 'scandinavian living room'\n  baker images pinterest 'minimalist skincare product photography' --limit 20\n  baker images pinterest 'cozy coffee shop interior' --auto-ingest 2 --context 'Mood reference for hero photography'"
@@ -17869,7 +19571,7 @@ var pinterestCommand = defineCommand113({
 });
 
 // src/commands/images/screenshot.ts
-import { defineCommand as defineCommand114 } from "citty";
+import { defineCommand as defineCommand116 } from "citty";
 registerSchema({
   command: "images.screenshot",
   description: "Capture a website screenshot via ScreenshotOne. Auto-ingests on success.",
@@ -17885,7 +19587,7 @@ registerSchema({
     }
   }
 });
-var screenshotCommand = defineCommand114({
+var screenshotCommand = defineCommand116({
   meta: {
     name: "screenshot",
     description: "Screenshot a URL via ScreenshotOne. $0.009/capture. Auto-ingests to library.\n\nExample: baker images screenshot https://stripe.com --full-page"
@@ -17935,7 +19637,7 @@ var screenshotCommand = defineCommand114({
 });
 
 // src/commands/images/search.ts
-import { defineCommand as defineCommand115 } from "citty";
+import { defineCommand as defineCommand117 } from "citty";
 registerSchema({
   command: "images.search",
   description: "Search images by text query. Only returns ready images.",
@@ -17951,7 +19653,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand = defineCommand115({
+var searchCommand = defineCommand117({
   meta: {
     name: "search",
     description: "Semantic search images by text query. Uses hybrid BM25 + vector + reranking. Example: baker images search 'hero banner' --aspect-ratio 16:9 --tags logo"
@@ -18011,7 +19713,7 @@ var searchCommand = defineCommand115({
 });
 
 // src/commands/images/sticker.ts
-import { defineCommand as defineCommand116 } from "citty";
+import { defineCommand as defineCommand118 } from "citty";
 registerSchema({
   command: "images.sticker",
   description: "Search Giphy stickers \u2014 transparent-background overlays for ad creative.",
@@ -18043,7 +19745,7 @@ registerSchema({
     }
   }
 });
-var stickerCommand = defineCommand116({
+var stickerCommand = defineCommand118({
   meta: {
     name: "sticker",
     description: "Search Giphy's sticker corpus \u2014 transparent-background WebPs / GIFs ideal for overlaying on ad creative (Meta, TikTok, Stories). Same Giphy free API as `baker images gif`; results carry WebP + GIF + MP4 URLs in providerMeta.\n\nExample: baker images sticker 'thumbs up' --limit 10\nExample: baker images sticker celebration --rating g --auto-ingest 3\nExample: baker images sticker --trending --limit 25"
@@ -18090,7 +19792,7 @@ var stickerCommand = defineCommand116({
 });
 
 // src/commands/images/stock.ts
-import { defineCommand as defineCommand117 } from "citty";
+import { defineCommand as defineCommand119 } from "citty";
 registerSchema({
   command: "images.stock",
   description: "Stock photo, vector illustration, icon-set, and PSD search via Magnific (Freepik's developer API).",
@@ -18148,7 +19850,7 @@ registerSchema({
     }
   }
 });
-var stockCommand = defineCommand117({
+var stockCommand = defineCommand119({
   meta: {
     name: "stock",
     description: "Stock search via Magnific \u2014 Freepik's developer API (~250M assets: photos, vectors, illustrations, icons, PSDs). $0.002/req. With --auto-ingest, ingested hits return Baker-owned URLs.\n\nExamples:\n  baker images stock 'minimalist office'\n  baker images stock 'flat office workers' --type vector\n  baker images stock 'hero photo of a kitchen' --type photo --orientation landscape --ai exclude\n  baker images stock 'brand pattern' --color '#0a0a0a' --license freemium --auto-ingest 2"
@@ -18204,7 +19906,7 @@ var stockCommand = defineCommand117({
 });
 
 // src/lib/tags-command.ts
-import { defineCommand as defineCommand118 } from "citty";
+import { defineCommand as defineCommand120 } from "citty";
 function makeTagsCommand(command, label, endpoint) {
   registerSchema({
     command: `${command}.tags`,
@@ -18213,7 +19915,7 @@ function makeTagsCommand(command, label, endpoint) {
       output: { type: "string", description: "Output format: md|json", required: false, default: "md" }
     }
   });
-  return defineCommand118({
+  return defineCommand120({
     meta: {
       name: "tags",
       description: `List the available ${label} tag names (defaults + company custom tags). Use before filtering with --tags. Example: baker ${command} tags`
@@ -18249,7 +19951,7 @@ function makeTagsCommand(command, label, endpoint) {
 var tagsCommand2 = makeTagsCommand("images", "image", "/api/images/tags");
 
 // src/commands/images/upload.ts
-import { defineCommand as defineCommand119 } from "citty";
+import { defineCommand as defineCommand121 } from "citty";
 registerSchema({
   command: "images.upload",
   description: "Upload an image to the library \u2014 local file path or remote http(s) URL.",
@@ -18287,7 +19989,7 @@ registerSchema({
 function isRemoteUrl2(value) {
   return /^https?:\/\//i.test(value);
 }
-var uploadCommand = defineCommand119({
+var uploadCommand = defineCommand121({
   meta: {
     name: "upload",
     description: "Upload an image to the library \u2014 accepts a local file path OR a remote http(s) URL.\n\nLocal: reads bytes, sends to /api/images/upload, content-type auto-detected from extension.\nRemote: dispatches to /api/images/ingest with hash-dedup on bytes + externalId.\n\nExamples:\n  baker images upload ./logo.png --source uploaded\n  baker images upload ./cert.png --context 'ISO 27001 badge \u2014 enterprise tier'\n  baker images upload https://acme.com/hero.png --source firecrawl --context 'Acme competitor pricing hero'"
@@ -18380,7 +20082,7 @@ async function uploadLocal(target, args) {
 }
 
 // src/commands/images/upscale.ts
-import { defineCommand as defineCommand120 } from "citty";
+import { defineCommand as defineCommand122 } from "citty";
 registerSchema({
   command: "images.upscale",
   description: "Upscale a library image via the backend (Replicate, cost-tracked). Waits for completion by default. The image must be status 'ready' and raster (not SVG/AVIF).",
@@ -18395,7 +20097,7 @@ registerSchema({
   }
 });
 var POLL_INTERVAL_MS3 = 1500;
-var upscaleCommand = defineCommand120({
+var upscaleCommand = defineCommand122({
   meta: {
     name: "upscale",
     description: "Upscale a library image via the Convex backend (Replicate, cost-tracked at $0.05/image). Waits for completion by default.\n\nExample: baker images upscale j571abc123def\nExample: baker images upscale j571abc123def --max-wait 0   # fire-and-forget"
@@ -18450,7 +20152,7 @@ var upscaleCommand = defineCommand120({
 });
 
 // src/commands/images/use.ts
-import { defineCommand as defineCommand121 } from "citty";
+import { defineCommand as defineCommand123 } from "citty";
 registerSchema({
   command: "images.use",
   description: "Ingest a URL and wait for the library record to be ready.",
@@ -18466,7 +20168,7 @@ registerSchema({
   }
 });
 var POLL_INTERVAL_MS4 = 1500;
-var useCommand = defineCommand121({
+var useCommand = defineCommand123({
   meta: {
     name: "use",
     description: "Sugar over `ingest`: download \u2192 store \u2192 wait until describe + embed complete \u2192 return ready library record.\n\nExample: baker images use https://cdn.example.com/hero.png --source uploaded"
@@ -18512,7 +20214,7 @@ var useCommand = defineCommand121({
 });
 
 // src/commands/images/index.ts
-var imagesCommand = defineCommand122({
+var imagesCommand = defineCommand124({
   meta: {
     name: "images",
     description: `Find, source, and normalize images. Subcommands route by provider so cost + license are explicit.
@@ -18582,7 +20284,7 @@ Paid transforms (run on the Convex backend, cost-tracked):
 });
 
 // src/commands/mcp/index.ts
-import { defineCommand as defineCommand123 } from "citty";
+import { defineCommand as defineCommand125 } from "citty";
 var SCOPES = ["user", "user_org", "company", "org"];
 function parseScope(raw) {
   const scope = raw === void 0 ? "company" : String(raw);
@@ -18621,7 +20323,7 @@ registerSchema({
   description: "List the custom MCP servers this company's chats see (org + company + your own user scope).",
   args: {}
 });
-var listCommand4 = defineCommand123({
+var listCommand4 = defineCommand125({
   meta: { name: "list", description: "List custom MCP servers visible to this company's chats." },
   run: async () => {
     try {
@@ -18646,7 +20348,7 @@ registerSchema({
     header: { type: "string", description: 'Auth header "Key: Value" (repeatable)', required: false }
   }
 });
-var addCommand = defineCommand123({
+var addCommand = defineCommand125({
   meta: {
     name: "add",
     description: `Register a custom MCP server. Tools appear as mcp__<name>__* on the NEXT message.
@@ -18687,7 +20389,7 @@ registerSchema({
   description: "Remove a company custom MCP server by name.",
   args: { name: { type: "string", description: "Server name to remove", required: true } }
 });
-var removeCommand3 = defineCommand123({
+var removeCommand3 = defineCommand125({
   meta: {
     name: "remove",
     description: `Remove a company custom MCP server by name.
@@ -18709,7 +20411,7 @@ Example:
     }
   }
 });
-var mcpCommand = defineCommand123({
+var mcpCommand = defineCommand125({
   meta: {
     name: "mcp",
     description: `Custom MCP servers for this company \u2014 point the agent at any HTTPS MCP endpoint.
@@ -18733,10 +20435,10 @@ Examples:
 });
 
 // src/commands/research/index.ts
-import { defineCommand as defineCommand134 } from "citty";
+import { defineCommand as defineCommand136 } from "citty";
 
 // src/commands/research/advertisers.ts
-import { defineCommand as defineCommand124 } from "citty";
+import { defineCommand as defineCommand126 } from "citty";
 
 // src/commands/research/output.ts
 var RESEARCH_DATA_NOTE = "Estimates based on third-party SERP data \u2014 not exact figures. Use for directional insights, not precise measurement.";
@@ -18849,7 +20551,7 @@ var FIELDS3 = {
   etv: "Estimated traffic value (USD)",
   visibility: "SERP visibility score (0-1)"
 };
-var advertisersCommand = defineCommand124({
+var advertisersCommand = defineCommand126({
   meta: {
     name: "advertisers",
     description: `Find domains competing for a keyword in Google SERPs.
@@ -18896,7 +20598,7 @@ Examples:
 });
 
 // src/commands/research/autocomplete.ts
-import { defineCommand as defineCommand125 } from "citty";
+import { defineCommand as defineCommand127 } from "citty";
 registerSchema({
   command: "research.autocomplete",
   description: "Get Google Autocomplete suggestions for a seed keyword. Useful for keyword expansion and discovering what people actually search for. IMPORTANT: If --location and --language are omitted, defaults to United States (us) and English (en).",
@@ -18919,7 +20621,7 @@ registerSchema({
 var FIELDS4 = {
   suggestion: "Autocomplete suggestion from Google"
 };
-var autocompleteCommand = defineCommand125({
+var autocompleteCommand = defineCommand127({
   meta: {
     name: "autocomplete",
     description: `Get Google Autocomplete suggestions for keyword expansion.
@@ -18965,7 +20667,7 @@ Examples:
 });
 
 // src/commands/research/countries.ts
-import { defineCommand as defineCommand126 } from "citty";
+import { defineCommand as defineCommand128 } from "citty";
 registerSchema({
   command: "research.countries",
   description: "List all supported country codes for --location flag in research commands.",
@@ -19022,7 +20724,7 @@ var FIELDS5 = {
   code: "Country code to pass as --location",
   name: "Country name"
 };
-var countriesCommand = defineCommand126({
+var countriesCommand = defineCommand128({
   meta: {
     name: "countries",
     description: "List all supported country codes for --location flag."
@@ -19033,7 +20735,7 @@ var countriesCommand = defineCommand126({
 });
 
 // src/commands/research/intent.ts
-import { defineCommand as defineCommand127 } from "citty";
+import { defineCommand as defineCommand129 } from "citty";
 registerSchema({
   command: "research.intent",
   description: "Classify Google Search intent for keywords. Determines if someone searching is looking to buy, research, or navigate. IMPORTANT: If --language is omitted, defaults to English (en). The response includes a query_context object showing which language was used.",
@@ -19056,7 +20758,7 @@ var FIELDS6 = {
   intent: "Primary Google Search intent: informational, navigational, commercial, transactional",
   probability: "Confidence score 0.0-1.0"
 };
-var intentCommand = defineCommand127({
+var intentCommand = defineCommand129({
   meta: {
     name: "intent",
     description: `Classify Google Search intent for keywords. Returns intent type and confidence.
@@ -19104,7 +20806,7 @@ Examples:
 });
 
 // src/commands/research/keyword-gap.ts
-import { defineCommand as defineCommand128 } from "citty";
+import { defineCommand as defineCommand130 } from "citty";
 registerSchema({
   command: "research.keyword-gap",
   description: "Find keywords a competitor ranks for (organic or paid) that you don't. Discovers expansion opportunities. IMPORTANT: If --location and --language are omitted, defaults to United States (us) and English (en). The response includes a query_context object showing which location/language were used.",
@@ -19133,7 +20835,7 @@ var FIELDS7 = {
   cpc: "Cost per click USD",
   their_position: "Competitor's ranking position"
 };
-var keywordGapCommand = defineCommand128({
+var keywordGapCommand = defineCommand130({
   meta: {
     name: "keyword-gap",
     description: `Find keywords a competitor has that you don't. Supports pagination via --offset.
@@ -19207,7 +20909,7 @@ Examples:
 });
 
 // src/commands/research/keywords-for-site.ts
-import { defineCommand as defineCommand129 } from "citty";
+import { defineCommand as defineCommand131 } from "citty";
 registerSchema({
   command: "research.keywords-for-site",
   description: "Get keywords a competitor targets in Google. Use --type paid to see only paid keywords, --type organic for organic only. IMPORTANT: If --location and --language are omitted, defaults to United States (us) and English (en). The response includes a query_context object showing which location/language were used.",
@@ -19240,7 +20942,7 @@ var FIELDS8 = {
   competition: "LOW, MEDIUM, or HIGH",
   competition_index: "Competition score 0-100"
 };
-var keywordsForSiteCommand = defineCommand129({
+var keywordsForSiteCommand = defineCommand131({
   meta: {
     name: "keywords-for-site",
     description: `Get keywords a competitor targets in Google. Use --type to filter paid/organic.
@@ -19293,7 +20995,7 @@ Examples:
 });
 
 // src/commands/research/languages.ts
-import { defineCommand as defineCommand130 } from "citty";
+import { defineCommand as defineCommand132 } from "citty";
 registerSchema({
   command: "research.languages",
   description: "List all supported language codes for --language flag in research commands.",
@@ -19323,7 +21025,7 @@ var FIELDS9 = {
   code: "Language code to pass as --language",
   name: "Language name (also accepted by --language)"
 };
-var languagesCommand2 = defineCommand130({
+var languagesCommand2 = defineCommand132({
   meta: {
     name: "languages",
     description: "List all supported language codes for --language flag."
@@ -19334,7 +21036,7 @@ var languagesCommand2 = defineCommand130({
 });
 
 // src/commands/research/lighthouse.ts
-import { defineCommand as defineCommand131 } from "citty";
+import { defineCommand as defineCommand133 } from "citty";
 registerSchema({
   command: "research.lighthouse",
   description: "Landing page performance audit. Returns metrics that affect Google Ads Quality Score and CPC.",
@@ -19353,7 +21055,7 @@ var FIELDS10 = {
   speed_index_ms: "Speed Index in ms (good: < 3400)",
   interactive_ms: "Time to Interactive in ms (good: < 3800)"
 };
-var lighthouseCommand = defineCommand131({
+var lighthouseCommand = defineCommand133({
   meta: {
     name: "lighthouse",
     description: `Landing page performance audit. Metrics affecting Google Ads Quality Score.
@@ -19391,7 +21093,7 @@ Examples:
 });
 
 // src/commands/research/relevant-pages.ts
-import { defineCommand as defineCommand132 } from "citty";
+import { defineCommand as defineCommand134 } from "citty";
 registerSchema({
   command: "research.relevant-pages",
   description: "Get the top pages of a competitor domain with organic traffic and ranking data. Shows which pages drive the most traffic. IMPORTANT: If --location and --language are omitted, defaults to United States (us) and English (en).",
@@ -19417,7 +21119,7 @@ var FIELDS11 = {
   keywords: "Total organic keywords the page ranks for",
   top_10: "Keywords in positions 1-10"
 };
-var relevantPagesCommand = defineCommand132({
+var relevantPagesCommand = defineCommand134({
   meta: {
     name: "relevant-pages",
     description: `Get the top pages of a competitor domain with traffic data.
@@ -19463,7 +21165,7 @@ Examples:
 });
 
 // src/commands/research/web.ts
-import { defineCommand as defineCommand133 } from "citty";
+import { defineCommand as defineCommand135 } from "citty";
 registerSchema({
   command: "research.web",
   description: "Search the web with AI to answer marketing questions \u2014 competitors, ICP, pricing, pain points, market trends. Three depth levels: medium (quick, default), high (thorough), xhigh (exhaustive deep research).",
@@ -19514,7 +21216,7 @@ async function runDeepResearch(question) {
   }
   throw new Error("Deep research timed out");
 }
-var webCommand = defineCommand133({
+var webCommand = defineCommand135({
   meta: {
     name: "web",
     description: `Search the web with AI to answer any open-ended marketing question. Uses live internet data via Google Search.
@@ -19574,7 +21276,7 @@ Examples:
 });
 
 // src/commands/research/index.ts
-var researchCommand = defineCommand134({
+var researchCommand = defineCommand136({
   meta: {
     name: "research",
     description: `Competitive intelligence and AI-powered research commands.
@@ -19614,10 +21316,10 @@ Examples:
 });
 
 // src/commands/scheduled-actions/index.ts
-import { defineCommand as defineCommand141 } from "citty";
+import { defineCommand as defineCommand143 } from "citty";
 
 // src/commands/scheduled-actions/create.ts
-import { defineCommand as defineCommand135 } from "citty";
+import { defineCommand as defineCommand137 } from "citty";
 
 // src/commands/scheduled-actions/shared.ts
 var TEMP_SCHEDULED_ACTION_PREFIX = "temp_sched_";
@@ -19732,7 +21434,7 @@ registerSchema({
     prompt: { type: "string", description: "Additional prompt instructions for the spawned agent", required: false }
   }
 });
-var createCommand2 = defineCommand135({
+var createCommand2 = defineCommand137({
   meta: {
     name: "create",
     description: 'Stage a scheduled action. Example: baker scheduled-actions create --name "Weekly report" --description "..." --cron "0 9 * * MON"'
@@ -19781,7 +21483,7 @@ var createCommand2 = defineCommand135({
 });
 
 // src/commands/scheduled-actions/delete.ts
-import { defineCommand as defineCommand136 } from "citty";
+import { defineCommand as defineCommand138 } from "citty";
 registerSchema({
   command: "scheduled-actions.delete",
   description: "Stage deletion of a published scheduled action or cancellation of a temp_sched_* draft creation.",
@@ -19789,7 +21491,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID or temp_sched_* draft ID", required: true }
   }
 });
-var deleteCommand2 = defineCommand136({
+var deleteCommand2 = defineCommand138({
   meta: {
     name: "delete",
     description: "Stage scheduled action deletion. Example: baker scheduled-actions delete <id-or-temp_sched_id>"
@@ -19818,7 +21520,7 @@ var deleteCommand2 = defineCommand136({
 });
 
 // src/commands/scheduled-actions/get.ts
-import { defineCommand as defineCommand137 } from "citty";
+import { defineCommand as defineCommand139 } from "citty";
 registerSchema({
   command: "scheduled-actions.get",
   description: "Get a published scheduled action or a temp_sched_* draft-created scheduled action.",
@@ -19826,7 +21528,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID or temp_sched_* draft ID", required: true }
   }
 });
-var getCommand3 = defineCommand137({
+var getCommand3 = defineCommand139({
   meta: {
     name: "get",
     description: "Get a scheduled action. Example: baker scheduled-actions get <id-or-temp_sched_id>"
@@ -19863,13 +21565,13 @@ var getCommand3 = defineCommand137({
 });
 
 // src/commands/scheduled-actions/list.ts
-import { defineCommand as defineCommand138 } from "citty";
+import { defineCommand as defineCommand140 } from "citty";
 registerSchema({
   command: "scheduled-actions.list",
   description: "List published scheduled actions. Includes draft state when BAKER_CHAT_ID is set.",
   args: {}
 });
-var listCommand5 = defineCommand138({
+var listCommand5 = defineCommand140({
   meta: {
     name: "list",
     description: "List scheduled actions. Includes staged draft ops when BAKER_CHAT_ID is set."
@@ -19890,7 +21592,7 @@ var listCommand5 = defineCommand138({
 });
 
 // src/commands/scheduled-actions/trigger.ts
-import { defineCommand as defineCommand139 } from "citty";
+import { defineCommand as defineCommand141 } from "citty";
 registerSchema({
   command: "scheduled-actions.trigger",
   description: "Immediately trigger a published scheduled action. Does not require BAKER_CHAT_ID and rejects temp_sched_* IDs.",
@@ -19898,7 +21600,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID", required: true }
   }
 });
-var triggerCommand = defineCommand139({
+var triggerCommand = defineCommand141({
   meta: {
     name: "trigger",
     description: "Immediately trigger a published scheduled action. Example: baker scheduled-actions trigger <id>"
@@ -19935,7 +21637,7 @@ var triggerCommand = defineCommand139({
 });
 
 // src/commands/scheduled-actions/update.ts
-import { defineCommand as defineCommand140 } from "citty";
+import { defineCommand as defineCommand142 } from "citty";
 registerSchema({
   command: "scheduled-actions.update",
   description: "Stage an update to a published scheduled action or temp_sched_* draft-created scheduled action.",
@@ -19960,7 +21662,7 @@ registerSchema({
     prompt: { type: "string", description: "Replacement additional spawned-agent instructions", required: false }
   }
 });
-var updateCommand2 = defineCommand140({
+var updateCommand2 = defineCommand142({
   meta: {
     name: "update",
     description: "Stage a scheduled action update. Example: baker scheduled-actions update <id> --enabled false"
@@ -20031,7 +21733,7 @@ var updateCommand2 = defineCommand140({
 });
 
 // src/commands/scheduled-actions/index.ts
-var scheduledActionsCommand = defineCommand141({
+var scheduledActionsCommand = defineCommand143({
   meta: {
     name: "scheduled-actions",
     description: `Manage Scheduled Actions. Subcommands: list, get, create, update, delete, trigger.
@@ -20057,8 +21759,8 @@ Examples:
 });
 
 // src/commands/schema.ts
-import { defineCommand as defineCommand142 } from "citty";
-var schemaCommand = defineCommand142({
+import { defineCommand as defineCommand144 } from "citty";
+var schemaCommand = defineCommand144({
   meta: {
     name: "schema",
     description: "Inspect command argument schemas (for AI agent introspection). Lists all commands if no argument given. Example: baker schema images.search"
@@ -20094,10 +21796,10 @@ var schemaCommand = defineCommand142({
 });
 
 // src/commands/testimonials/index.ts
-import { defineCommand as defineCommand146 } from "citty";
+import { defineCommand as defineCommand148 } from "citty";
 
 // src/commands/testimonials/get.ts
-import { defineCommand as defineCommand143 } from "citty";
+import { defineCommand as defineCommand145 } from "citty";
 registerSchema({
   command: "testimonials.get",
   description: "Get a single testimonial by ID",
@@ -20105,7 +21807,7 @@ registerSchema({
     id: { type: "string", description: "Testimonial ID", required: true }
   }
 });
-var getCommand4 = defineCommand143({
+var getCommand4 = defineCommand145({
   meta: { name: "get", description: "Get a single testimonial by ID. Example: baker testimonials get j571abc123" },
   args: {
     id: { type: "positional", description: "Testimonial ID", required: false },
@@ -20142,7 +21844,7 @@ var getCommand4 = defineCommand143({
 });
 
 // src/commands/testimonials/list.ts
-import { defineCommand as defineCommand144 } from "citty";
+import { defineCommand as defineCommand146 } from "citty";
 registerSchema({
   command: "testimonials.list",
   description: "List testimonials with optional filters.",
@@ -20172,7 +21874,7 @@ registerSchema({
     limit: { type: "number", description: "Max results (default 50)", required: false, default: 50 }
   }
 });
-var listCommand6 = defineCommand144({
+var listCommand6 = defineCommand146({
   meta: {
     name: "list",
     description: "List testimonials with optional filters. Example: baker testimonials list --source google --sentiment positive"
@@ -20221,7 +21923,7 @@ var listCommand6 = defineCommand144({
 });
 
 // src/commands/testimonials/search.ts
-import { defineCommand as defineCommand145 } from "citty";
+import { defineCommand as defineCommand147 } from "citty";
 registerSchema({
   command: "testimonials.search",
   description: "Search testimonials by text query. Uses hybrid BM25 + vector + reranking.",
@@ -20252,7 +21954,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand2 = defineCommand145({
+var searchCommand2 = defineCommand147({
   meta: {
     name: "search",
     description: "Semantic search testimonials by text query. Uses hybrid BM25 + vector + reranking. Example: baker testimonials search 'great service' --rating-min 4"
@@ -20326,7 +22028,7 @@ var searchCommand2 = defineCommand145({
 var tagsCommand3 = makeTagsCommand("testimonials", "testimonial", "/api/testimonials/tags");
 
 // src/commands/testimonials/index.ts
-var testimonialsCommand = defineCommand146({
+var testimonialsCommand = defineCommand148({
   meta: {
     name: "testimonials",
     description: `Find and browse testimonials in Baker. Subcommands: search, get, list, tags.
@@ -20347,10 +22049,10 @@ Examples:
 });
 
 // src/commands/videos/index.ts
-import { defineCommand as defineCommand151 } from "citty";
+import { defineCommand as defineCommand153 } from "citty";
 
 // src/commands/videos/delete.ts
-import { defineCommand as defineCommand147 } from "citty";
+import { defineCommand as defineCommand149 } from "citty";
 registerSchema({
   command: "videos.delete",
   description: "Delete a video by ID",
@@ -20364,7 +22066,7 @@ registerSchema({
     }
   }
 });
-var deleteCommand3 = defineCommand147({
+var deleteCommand3 = defineCommand149({
   meta: {
     name: "delete",
     description: "Delete a video by ID. Use --dry-run to preview. Example: baker videos delete j571abc123 --dry-run"
@@ -20405,7 +22107,7 @@ var deleteCommand3 = defineCommand147({
 });
 
 // src/commands/videos/get.ts
-import { defineCommand as defineCommand148 } from "citty";
+import { defineCommand as defineCommand150 } from "citty";
 registerSchema({
   command: "videos.get",
   description: "Get a single video by ID",
@@ -20413,7 +22115,7 @@ registerSchema({
     id: { type: "string", description: "Video ID", required: true }
   }
 });
-var getCommand5 = defineCommand148({
+var getCommand5 = defineCommand150({
   meta: { name: "get", description: "Get a single video by ID. Example: baker videos get j571abc123" },
   args: {
     id: { type: "positional", description: "Video ID", required: false },
@@ -20450,7 +22152,7 @@ var getCommand5 = defineCommand148({
 });
 
 // src/commands/videos/search.ts
-import { defineCommand as defineCommand149 } from "citty";
+import { defineCommand as defineCommand151 } from "citty";
 registerSchema({
   command: "videos.search",
   description: "Search videos by text query. Only returns ready videos.",
@@ -20460,7 +22162,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand3 = defineCommand149({
+var searchCommand3 = defineCommand151({
   meta: {
     name: "search",
     description: "Semantic search videos by text query. Uses hybrid BM25 + vector + reranking. Example: baker videos search 'product demo' --tags tutorial"
@@ -20512,7 +22214,7 @@ var tagsCommand4 = makeTagsCommand("videos", "video", "/api/videos/tags");
 // src/commands/videos/upload.ts
 import { readFile as readFile12, stat as stat3 } from "fs/promises";
 import { extname as extname3 } from "path";
-import { defineCommand as defineCommand150 } from "citty";
+import { defineCommand as defineCommand152 } from "citty";
 var MIME_MAP = {
   ".mp4": "video/mp4",
   ".mov": "video/quicktime",
@@ -20546,7 +22248,7 @@ function detectContentType(filePath) {
   }
   return mime;
 }
-var uploadCommand2 = defineCommand150({
+var uploadCommand2 = defineCommand152({
   meta: {
     name: "upload",
     description: "Upload a video file to Baker via Mux direct upload. Auto-detects content type. Example: baker videos upload ./demo.mp4"
@@ -20600,7 +22302,7 @@ var uploadCommand2 = defineCommand150({
 });
 
 // src/commands/videos/index.ts
-var videosCommand = defineCommand151({
+var videosCommand = defineCommand153({
   meta: {
     name: "videos",
     description: `Find and manage videos in Baker. Subcommands: search, get, upload, delete, tags.
@@ -20623,10 +22325,10 @@ Examples:
 });
 
 // src/commands/winning-ads/index.ts
-import { defineCommand as defineCommand154 } from "citty";
+import { defineCommand as defineCommand156 } from "citty";
 
 // src/commands/winning-ads/advertisers.ts
-import { defineCommand as defineCommand152 } from "citty";
+import { defineCommand as defineCommand154 } from "citty";
 registerSchema({
   command: "winning-ads.advertisers",
   description: "Resolve a brand name to advertiser_id(s) in the ad-dna corpus \u2014 to find your OWN advertiser (to --exclude-advertiser) or a competitor (to --advertiser-id).",
@@ -20639,7 +22341,7 @@ registerSchema({
 function identity(record) {
   return record;
 }
-var advertisersCommand2 = defineCommand152({
+var advertisersCommand2 = defineCommand154({
   meta: {
     name: "advertisers",
     description: 'Resolve a brand name to advertiser_id(s). Use it to find your own advertiser for --exclude-advertiser, or a competitor for --advertiser-id. Example: baker winning-ads advertisers "Deel" --output md'
@@ -20690,7 +22392,7 @@ var advertisersCommand2 = defineCommand152({
 });
 
 // src/commands/winning-ads/search.ts
-import { defineCommand as defineCommand153 } from "citty";
+import { defineCommand as defineCommand155 } from "citty";
 registerSchema({
   command: "winning-ads.search",
   description: "Search the ad-dna corpus of scored winning ads. Returns a lean shortlist (advertiser, summary, scores, media_url) to pick a reference to reproduce.",
@@ -20798,7 +22500,7 @@ function buildSearchBody(args) {
   }
   return body;
 }
-var searchCommand4 = defineCommand153({
+var searchCommand4 = defineCommand155({
   meta: {
     name: "search",
     description: "Search winning reference ads. Example: baker winning-ads search 'B2B SaaS before/after AI automation' --platform meta --format static --winner-category winner --exclude-advertiser adv_123 --output md"
@@ -20910,7 +22612,7 @@ var searchCommand4 = defineCommand153({
 });
 
 // src/commands/winning-ads/index.ts
-var winningAdsCommand = defineCommand154({
+var winningAdsCommand = defineCommand156({
   meta: {
     name: "winning-ads",
     description: `Search the ad-dna corpus of scored "winning" ads for reference creatives to reproduce. Proxied through the Baker backend (BAKER_API_KEY) \u2014 no separate token needed.
@@ -20934,7 +22636,7 @@ Examples:
 });
 
 // src/version.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 function packageJsonUrl() {
   return new URL("../package.json", import.meta.url);
 }
@@ -20946,11 +22648,11 @@ function parsePackageVersion(raw) {
   throw new Error("Invalid CLI package.json: missing version");
 }
 function getCliVersion() {
-  return parsePackageVersion(readFileSync10(packageJsonUrl(), "utf8"));
+  return parsePackageVersion(readFileSync11(packageJsonUrl(), "utf8"));
 }
 
 // src/cli.ts
-var main = defineCommand155({
+var main = defineCommand157({
   meta: {
     name: "baker",
     version: getCliVersion(),
@@ -20965,7 +22667,7 @@ Introspection: Run 'baker schema <command>' to inspect argument schemas.`
   subCommands: {
     actions: actionsCommand,
     "scheduled-actions": scheduledActionsCommand,
-    ads: adsCommand,
+    ads: adsCommand2,
     ga4: ga4Command,
     gsc: gscCommand,
     research: researchCommand,