@koda-sl/baker-cli 0.111.0-dev.4a58faec8 → 0.111.0-dev.94fd3a2a1

package/dist/cli.js

@@ -12,7 +12,7 @@ import {
 } from "./chunk-26K7V346.js";
 
 // src/cli.ts
-import { defineCommand as defineCommand155, runMain } from "citty";
+import { defineCommand as defineCommand156, runMain } from "citty";
 
 // src/commands/actions/index.ts
 import { defineCommand as defineCommand18 } from "citty";
@@ -31,7 +31,6 @@ function getEnv() {
         BAKER_API_KEY: z.string().startsWith("bk_", "API key must start with 'bk_'"),
         BAKER_API_URL: z.url("BAKER_API_URL must be a valid URL"),
         BAKER_CHAT_ID: z.string().optional(),
-        BAKER_ACTING_USER_ID: z.string().optional(),
         BAKER_GOOGLE_ADS_CUSTOMER_ID: z.string().regex(/^\d{10}$/).optional(),
         BAKER_GA4_PROPERTY_ID: z.string().optional(),
         BAKER_GSC_SITE_URL: z.string().optional(),
@@ -2844,10 +2843,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";
@@ -3832,11 +3831,866 @@ 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)
+});
+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 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 googleDraftListResponseSchema = z9.object({
+  status: z9.enum(["active", "publishing", "applied", "discarded", "none"]),
+  mode: googleWriteModeSchema,
+  count: z9.number(),
+  ops: z9.array(googleDraftOpViewSchema)
+});
+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/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;
+}
+function loadJsonFileArg(path11) {
+  if (typeof path11 !== "string" || path11.length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync3(path11, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failWriteValidation(`${path11} must contain a JSON object`);
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      failWriteValidation(`${path11} 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 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(path11, body) {
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost(path11, { chatId, ...body });
+    writeJsonEnvelope(response);
+  } 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: "List staged ops (with lineage, mode, and results)" },
+      run: async () => {
+        await draftAction("/api/ads/google/draft", {});
+      }
+    }),
+    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 = [
@@ -4111,7 +4965,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.
@@ -4173,7 +5027,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.",
@@ -4183,7 +5037,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."
@@ -4194,7 +5048,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.",
@@ -4204,7 +5058,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."
@@ -4215,7 +5069,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.",
@@ -4239,7 +5093,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.
@@ -4326,7 +5180,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.
@@ -4346,8 +5200,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"
@@ -4364,7 +5218,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"
@@ -4384,7 +5238,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"
@@ -4441,7 +5295,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"
@@ -4476,7 +5330,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."
@@ -4534,7 +5388,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."
@@ -4578,7 +5432,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)"
@@ -4610,7 +5464,7 @@ var searchCompetitors = defineCommand27({
     }
   }
 });
-var library = defineCommand27({
+var library = defineCommand28({
   meta: {
     name: "library",
     description: "Manage and search the Google Ads Library"
@@ -4627,9 +5481,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) {
@@ -4921,7 +5775,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");
@@ -5085,7 +5939,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.
@@ -5142,8 +5996,516 @@ 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 a keyword to an ad group" },
+    args: {
+      ...customerIdArg,
+      "ad-group-ref": { type: "string", description: "Ad group ref (g_temp_*, id, or resource name)" },
+      text: { type: "string", description: "Keyword text" },
+      "match-type": { type: "string", description: "EXACT | PHRASE | BROAD" },
+      "cpc-bid": { type: "string", description: "Keyword CPC bid in major units" },
+      "final-url": { type: "string", description: "Keyword-level final URL" }
+    },
+    run: async ({ args }) => {
+      const customerId = requireCustomerId(args);
+      await stageCreate("google.keyword.add", customerId, {
+        adGroup: requireStringFlag(args["ad-group-ref"], "--ad-group-ref"),
+        text: requireStringFlag(args.text, "--text"),
+        matchType: requireStringFlag(args["match-type"], "--match-type"),
+        cpcBidMicros: microsFlag(args["cpc-bid"], "--cpc-bid"),
+        finalUrls: args["final-url"] ? [args["final-url"]] : void 0
+      });
+    }
+  }),
+  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 a negative keyword" },
+      args: {
+        ...customerIdArg,
+        level: { type: "string", description: "adGroup | campaign" },
+        "parent-ref": { type: "string", description: "Ad group or campaign ref" },
+        text: { type: "string" },
+        "match-type": { type: "string", description: "EXACT | PHRASE | BROAD" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        await stageCreate("google.negativeKeyword.add", customerId, {
+          level: requireStringFlag(args.level, "--level"),
+          parent: requireStringFlag(args["parent-ref"], "--parent-ref"),
+          text: requireStringFlag(args.text, "--text"),
+          matchType: requireStringFlag(args["match-type"], "--match-type")
+        });
+      }
+    }),
+    remove: statusCommand2("google.negativeKeyword.remove", "negative keyword")
+  }
+});
+var keywordListsCommand = defineCommand30({
+  meta: { name: "keyword-lists", description: "Stage shared negative keyword lists (create/add/attach/detach)" },
+  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 a keyword to a shared list" },
+      args: {
+        ...customerIdArg,
+        "list-ref": { type: "string", description: "Shared set ref" },
+        text: { type: "string" },
+        "match-type": { type: "string" }
+      },
+      run: async ({ args }) => {
+        const customerId = requireCustomerId(args);
+        await stageCreate("google.sharedSetMember.add", customerId, {
+          sharedSet: requireStringFlag(args["list-ref"], "--list-ref"),
+          text: requireStringFlag(args.text, "--text"),
+          matchType: requireStringFlag(args["match-type"], "--match-type")
+        });
+      }
+    }),
+    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)" },
+      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)" },
+  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.
@@ -5158,20 +6520,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({
@@ -5832,7 +7202,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;
@@ -5935,7 +7305,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).
@@ -5969,9 +7339,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.
@@ -6019,7 +7389,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 = {
@@ -6291,7 +7661,7 @@ function numberOf(v) {
   }
   return 0;
 }
-var analyticsCommand = defineCommand32({
+var analyticsCommand = defineCommand34({
   meta: {
     name: "analytics",
     description: `Performance reporting \u2014 the workhorse for AI agents.
@@ -6418,8 +7788,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) {
@@ -6432,7 +7802,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"}`)
@@ -6441,7 +7811,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.
@@ -6486,7 +7856,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,
@@ -6545,7 +7915,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,
@@ -6611,8 +7981,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) {
@@ -6625,7 +7995,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"}`)
@@ -6634,7 +8004,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.
@@ -6684,40 +8054,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(path11) {
+function loadJsonFileArg2(path11) {
   if (typeof path11 !== "string" || path11.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync6(path11, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path11, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation(`${path11} must contain a JSON object`);
+      failWriteValidation2(`${path11} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation(`${path11} is not valid JSON: ${err.message}`);
+      failWriteValidation2(`${path11} 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) {
@@ -6734,7 +8104,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() };
 }
@@ -6748,7 +8118,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;
 }
@@ -6763,7 +8133,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 === "") {
@@ -6771,7 +8141,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() };
 }
@@ -6779,10 +8149,10 @@ function loadTargetingFileArg(path11) {
   if (typeof path11 !== "string" || path11.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg(path11);
+  const parsed = loadJsonFileArg2(path11);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
-    failWriteValidation(
+    failWriteValidation2(
       `${path11} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
@@ -6822,10 +8192,10 @@ function parseListFileArg(path11, maxRows) {
   if (typeof path11 !== "string" || path11.length === 0) {
     return void 0;
   }
-  const raw = readFileSync6(path11, "utf8");
+  const raw = readFileSync7(path11, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation(`${path11} needs a header row and at least one data row`);
+    failWriteValidation2(`${path11} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -6844,7 +8214,7 @@ function parseListFileArg(path11, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation(`${path11} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation2(`${path11} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -6880,10 +8250,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;
 }
@@ -6902,7 +8272,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}
@@ -6920,7 +8290,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"),
@@ -6929,7 +8299,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}
@@ -6949,7 +8319,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"),
@@ -6958,7 +8328,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
     });
   }
@@ -7007,7 +8377,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}
@@ -7017,14 +8387,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}
@@ -7042,18 +8412,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}
@@ -7067,7 +8437,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
       });
     }
@@ -7081,7 +8451,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}
@@ -7096,14 +8466,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 } : {}
           }
         );
@@ -7116,7 +8486,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}
@@ -7154,10 +8524,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
@@ -7168,7 +8538,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 } : {}
         }
@@ -7193,7 +8563,7 @@ var CREATIVE_FORMATS = [
   "event",
   "article"
 ];
-var creativesCreateCommand = defineCommand36({
+var creativesCreateCommand = defineCommand38({
   meta: {
     name: "create",
     description: `Stage a new creative (ad). ${STAGED_NOTE}
@@ -7229,13 +8599,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"],
@@ -7294,7 +8664,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}
@@ -7326,13 +8696,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
@@ -7342,7 +8712,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}
@@ -7359,7 +8729,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,
@@ -7372,7 +8742,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}
@@ -7387,20 +8757,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."
@@ -7410,7 +8780,7 @@ var audiencesCommand = defineCommand36({
     upload: audiencesUploadCommand
   }
 });
-var conversionsCreateCommand = defineCommand36({
+var conversionsCreateCommand = defineCommand38({
   meta: {
     name: "create",
     description: `Stage a new conversion rule. ${STAGED_NOTE}
@@ -7429,7 +8799,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,
@@ -7441,7 +8811,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}
@@ -7459,7 +8829,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,
@@ -7469,12 +8839,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}
@@ -7487,11 +8857,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}`
@@ -7504,16 +8874,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."
@@ -7525,7 +8895,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).
@@ -7576,8 +8946,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).
@@ -7638,8 +9008,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.
@@ -7702,7 +9072,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);
@@ -7728,7 +9098,7 @@ function healthOf(rules) {
     wrongLeadDedup: wrongDedup
   };
 }
-var listCmd = defineCommand40({
+var listCmd = defineCommand42({
   meta: {
     name: "list",
     description: `List conversion rules on the account.`
@@ -7756,7 +9126,7 @@ var listCmd = defineCommand40({
     }
   }
 });
-var healthCmd = defineCommand40({
+var healthCmd = defineCommand42({
   meta: {
     name: "health",
     description: `5-point Insight Tag / CAPI health check (playbook \xA707).
@@ -7786,7 +9156,7 @@ Surfaces:
     }
   }
 });
-var conversionsCommand = defineCommand40({
+var conversionsCommand2 = defineCommand42({
   meta: {
     name: "conversions",
     description: `Conversion rules \u2014 Insight Tag and Conversions API.
@@ -7805,8 +9175,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).
@@ -7865,7 +9235,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;
@@ -7878,7 +9248,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.
@@ -7975,7 +9345,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();
@@ -7987,14 +9357,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"
@@ -8019,7 +9389,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"
@@ -8036,7 +9406,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."
@@ -8050,8 +9420,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.
@@ -8079,7 +9449,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.
@@ -8120,7 +9490,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.
@@ -8137,8 +9507,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) {
@@ -8151,7 +9521,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"}`)
@@ -8168,7 +9538,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.
@@ -8215,9 +9585,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).
@@ -8277,7 +9647,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) {
@@ -8288,7 +9658,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.
@@ -8330,8 +9700,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.
@@ -8402,7 +9772,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.
@@ -8447,9 +9817,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,
@@ -8461,17 +9831,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;
@@ -8550,7 +9920,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).
@@ -8577,8 +9947,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.
@@ -8626,8 +9996,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,
@@ -8664,8 +10034,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.
@@ -8713,8 +10083,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.
@@ -8756,8 +10126,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,
@@ -8792,8 +10162,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.
@@ -8823,8 +10193,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.
@@ -8868,8 +10238,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.
@@ -8913,7 +10283,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 = {
@@ -9118,7 +10488,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.
@@ -9219,8 +10589,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.
@@ -9291,7 +10661,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",
@@ -9325,7 +10695,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
@@ -9372,7 +10742,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).
@@ -9411,11 +10781,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,
@@ -9424,10 +10794,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.",
@@ -9455,7 +10825,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.
@@ -9495,7 +10865,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) {
@@ -9646,7 +11016,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.
@@ -9704,7 +11074,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.",
@@ -9713,7 +11083,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.
@@ -9762,7 +11132,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) {
@@ -9825,7 +11195,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.
@@ -9867,7 +11237,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.",
@@ -9876,7 +11246,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).
@@ -9925,7 +11295,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.",
@@ -9934,7 +11304,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.
@@ -9983,7 +11353,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).",
@@ -9995,7 +11365,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).
@@ -10036,7 +11406,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).",
@@ -10046,7 +11416,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.
@@ -10098,7 +11468,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).",
@@ -10109,7 +11479,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.
@@ -10163,11 +11533,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;
@@ -10237,7 +11607,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.
@@ -10342,7 +11712,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.",
@@ -10365,7 +11735,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).
@@ -10428,7 +11798,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).",
@@ -10438,7 +11808,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.
@@ -10479,7 +11849,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 = [
@@ -10638,7 +12008,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).
@@ -10681,7 +12051,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).
@@ -10709,7 +12079,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",
@@ -10737,7 +12107,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.
@@ -10787,7 +12157,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.",
@@ -10797,7 +12167,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.
@@ -10848,7 +12218,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.
@@ -10872,12 +12242,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,
@@ -10886,7 +12256,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.
@@ -10916,11 +12286,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."
@@ -10937,9 +12307,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."
@@ -11048,7 +12418,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) {
@@ -11118,7 +12488,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" },
@@ -11214,30 +12584,30 @@ var runCommand = defineCommand83({
 // src/commands/canvas/scaffold-static-ad.ts
 import { readFile as readFile3, writeFile } from "fs/promises";
 import path5 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;
@@ -11279,7 +12649,7 @@ function roleForType(type) {
       return "the showcased product; keep this exact product identity. Ignore any caption text printed on this reference.";
     case "person":
     case "animal":
-      return "the emotional hero \u2014 the face/muzzle/eyes the viewer locks onto and exactly where AI artifacts (malformed mouths, teeth, foam, extra fingers) betray a fake. It MUST be grounded in this real reference, never invented from prose. Keep this identity AND the expression the blueprint specifies. Ignore any caption text printed on this reference.";
+      return "the hero subject; keep this identity AND the expression the blueprint specifies. Ignore any caption text printed on this reference.";
     default:
       return "an identity-bearing element; reproduce it faithfully from this reference. Ignore any caption text printed on it.";
   }
@@ -11287,9 +12657,7 @@ function roleForType(type) {
 function todoPath(el, label) {
   const desc = el.description ? ` \u2014 ${el.description}` : "";
   const expr = el.expression ? `, with a ${el.expression} expression` : "";
-  const t = el.type.toLowerCase();
-  const lock = t === "person" || t === "animal" ? " \u2014 REQUIRED: this is the emotional hero; ground it in a real reference (image-library / video-library / Pinterest), do not delete this slot and free-generate" : "";
-  return `[TODO: drop a real image for ${label} (${el.type})${desc}${expr}${lock}]`;
+  return `[TODO: drop a real image for ${label} (${el.type})${desc}${expr}]`;
 }
 function aspectRatio(blueprint, opts) {
   const requested = opts.aspectRatio ?? blueprint.meta?.estimated_aspect_ratio;
@@ -11404,7 +12772,7 @@ function resolveModel(kind, preferred) {
   const ids = Object.keys(MODEL_REGISTRY[kind]);
   return ids.includes(preferred) ? preferred : ids[0] ?? preferred;
 }
-var DESCRIBE_FOCUS = `the GLOBAL LAYOUT GEOMETRY above all \u2014 the column/row grid, each region's approximate bounds as a percentage of frame width and height, any panel SPLITS and their proportions (e.g. a left column split into a ~60% top photo and a ~20% bottom price box), what occupies every region, and for EVERY text block its string verbatim, relative size (x_large | large | medium | small), weight, case, color, and alignment \u2014 including small bottom-corner fine print. Also: the EXPRESSION and emotion of every person/animal (capture exaggerated or AI-edited faces), the ad_intent (what feeling it engineers and how), per-color brand_ownership (which colors are the advertiser's brand vs borrowed-functional like a red comparison column), logos by brand, and all visible text verbatim. CRITICAL \u2014 name the WINNING MECHANISM(S): the special sauce, the specific thing that makes THIS ad a candidate winner rather than a generic ad. A great ad is rarely great by accident, and the mechanism is invisible unless named, so a faithful rewrite quietly discards it. It may be VERBAL (a rhyme, pun, alliteration, rhythm/meter, repetition, antithesis, double meaning), VISUAL (an unexpected crop or scale, a visual gag or pun, a striking juxtaposition, a pattern interrupt, an exaggerated/AI-edited expression, a before/after or comparison, bold negative space, a surprising focal point), or STRUCTURAL (an unusual hook, order, or reveal). Record each as a \`winning_mechanisms\` array of { kind: verbal|visual|structural, device, why_it_works } (e.g. { kind: verbal, device: "rhyme \u2014 'today' / 'go away'", why_it_works: "memorable, playful, reframes cost as relief" }) so a rewrite can rebuild the SAUCE for our brand instead of adapting only the surface and losing what made it convert`;
+var DESCRIBE_FOCUS = "the GLOBAL LAYOUT GEOMETRY above all \u2014 the column/row grid, each region's approximate bounds as a percentage of frame width and height, any panel SPLITS and their proportions (e.g. a left column split into a ~60% top photo and a ~20% bottom price box), what occupies every region, and for EVERY text block its string verbatim, relative size (x_large | large | medium | small), weight, case, color, and alignment \u2014 including small bottom-corner fine print. Also: the EXPRESSION and emotion of every person/animal (capture exaggerated or AI-edited faces), the ad_intent (what feeling it engineers and how), per-color brand_ownership (which colors are the advertiser's brand vs borrowed-functional like a red comparison column), logos by brand, and all visible text verbatim";
 var LAYOUT_SYSTEM = "You convert an advertisement's JSON blueprint into a precise, structured LAYOUT MAP of the frame \u2014 the spatial grid a designer would rebuild it from. Be exhaustive and quantitative: every region, its bounds as a percentage of the frame, and every text block with its relative size. Output ONLY a JSON object, no prose.";
 var LAYOUT_PROMPT = `AD BLUEPRINT (from image_describe):
 {{blueprint}}
@@ -11426,20 +12794,7 @@ Return a JSON object describing the GLOBAL LAYOUT of the frame precisely enough
 
 Use the blueprint's positions, sizes, text_content, and colors. Estimate the percentages and split proportions as accurately as you can (e.g. a column split 60/20 with a 20% gap). Cover EVERY visible element \u2014 photos, text boxes, badges, background shapes, and small corner text \u2014 top-to-bottom, left-to-right. Output ONLY the JSON object.`;
 var SELECT_SYSTEM = 'You identify the MAIN, identity-critical visual elements of an advertisement from its JSON blueprint \u2014 the things a faithful reproduction must supply as REAL reference images instead of letting a model invent them. Output ONLY a JSON object of the form { "elements": [ ... ] }, no prose.';
-var SELECT_PROMPT = `AD BLUEPRINT (from image_describe):
-{{blueprint}}
-
-From this blueprint, list ONLY the elements that are prominent, important, and identity-bearing \u2014 the ones a reproduction must ground in a real asset:
-- the brand logo/wordmark (from brands_logos with function_in_image = advertiser_brand) -> type "logo"
-- trust/rating/certification/app-store/review badges (brands_logos with function_in_image = trust_badge | review_platform | certification_or_seal | app_store_badge | payment_method) -> type "badge"
-- a showcased/hero product or package (a foreground entry in subjects that the ad is selling) -> type "product"
-- a foreground person (from people) \u2014 keep it when its identity matters OR it is the emotional/hero focal point of the ad, even a generic one with no brand identity -> type "person"
-- a foreground animal/character (from subjects) \u2014 keep it when it carries a specific expression OR it is the emotional/hero focal point, even a generic one -> type "animal"
-  (For both: a free-generated face, muzzle, hands, or teeth reads as AI and grows artifacts \u2014 malformed mouths, extra fingers, foam \u2014 so the emotional hero needs the STRONGEST real grounding, not the weakest; "it's just a generic dog/person" is never a reason to drop it.)
-
-DROP background extras, decorative props, generic scenery, and anything small or incidental. Keep at most ~6. If there are none, return an empty list.
-
-For each kept element return: { "type": one of logo|product|person|animal|badge, "label": a short UPPER_SNAKE_CASE name (e.g. LOGO, PRODUCT, HERO_DOG, TRUSTPILOT), "description": a concrete reusable description to source/shoot the real asset (include the exact expression for a living subject, and its castable attributes \u2014 breed/species for an animal, apparent age band, apparent origin/ethnicity, and wardrobe/setting for a person \u2014 so it can be recast to fit OUR audience/market), "expression": the facial expression for a living subject or null, "reason": why it is identity-critical, "locator": the blueprint entry this element came from as { "collection": one of "subjects" | "people" | "brands_logos", "index": its 0-based position in that array } (people -> people; logos/badges -> brands_logos; products/animals/objects -> subjects). Output ONLY the JSON object.`;
+var SELECT_PROMPT = 'AD BLUEPRINT (from image_describe):\n{{blueprint}}\n\nFrom this blueprint, list ONLY the elements that are prominent, important, and identity-bearing \u2014 the ones a reproduction must ground in a real asset:\n- the brand logo/wordmark (from brands_logos with function_in_image = advertiser_brand) -> type "logo"\n- trust/rating/certification/app-store/review badges (brands_logos with function_in_image = trust_badge | review_platform | certification_or_seal | app_store_badge | payment_method) -> type "badge"\n- a showcased/hero product or package (a foreground entry in subjects that the ad is selling) -> type "product"\n- a foreground person whose identity matters (from people) -> type "person"\n- a foreground animal/character with a specific expression (from subjects) -> type "animal"\n\nDROP background extras, decorative props, generic scenery, and anything small or incidental. Keep at most ~6. If there are none, return an empty list.\n\nFor each kept element return: { "type": one of logo|product|person|animal|badge, "label": a short UPPER_SNAKE_CASE name (e.g. LOGO, PRODUCT, HERO_DOG, TRUSTPILOT), "description": a concrete reusable description to source/shoot the real asset (include the exact expression for a living subject), "expression": the facial expression for a living subject or null, "reason": why it is identity-critical, "locator": the blueprint entry this element came from as { "collection": one of "subjects" | "people" | "brands_logos", "index": its 0-based position in that array } (people -> people; logos/badges -> brands_logos; products/animals/objects -> subjects). Output ONLY the JSON object.';
 async function loadAssetText(ref, label) {
   const r = ref;
   if (typeof r?.path === "string") return readFile3(r.path, "utf8");
@@ -11548,7 +12903,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."
@@ -11642,7 +12997,7 @@ var scaffoldStaticAdCommand = defineCommand84({
 // src/commands/canvas/scaffold-video.ts
 import { cp, mkdir, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
 import path8 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";
@@ -11747,7 +13102,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 = [
@@ -12004,49 +13359,49 @@ function trimArgs(durationS, offsetS = 0) {
     "{{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.
@@ -12054,77 +13409,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) {
@@ -12134,26 +13489,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;
@@ -13616,25 +14971,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;");
@@ -13666,7 +15021,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 };
@@ -13775,7 +15130,7 @@ function buildOverlayHtml(input) {
   if (ovParts.length > 0) blocks.push(ovParts.join("\n"));
   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.map((fe) => floatingStub(fe, sceneStart)) : []).filter(Boolean);
     const pip = uiPipStub(scene);
     if (pip) parts.push(pip);
@@ -14032,8 +15387,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",
@@ -14474,7 +15829,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`."
@@ -14619,7 +15974,7 @@ var scaffoldVideoCommand = defineCommand85({
 // src/commands/canvas/set-prompt.ts
 import { readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
 import path9 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");
@@ -14634,7 +15989,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."
@@ -14694,8 +16049,8 @@ var setPromptCommand = defineCommand86({
 // src/commands/canvas/validate.ts
 import { readFile as readFile8 } from "fs/promises";
 import path10 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)."
@@ -14738,7 +16093,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.
@@ -14765,10 +16120,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";
@@ -14891,7 +16246,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."
@@ -14937,7 +16292,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.
@@ -14953,10 +16308,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) {
@@ -15019,7 +16374,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.
@@ -15071,7 +16426,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.",
@@ -15079,7 +16434,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.
@@ -15127,9 +16482,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 = [
@@ -15218,7 +16573,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");
@@ -15261,7 +16616,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.
@@ -15332,7 +16687,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.
@@ -15355,12 +16710,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 = [
@@ -15503,7 +16858,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");
@@ -15548,7 +16903,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.
@@ -15626,7 +16981,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.",
@@ -15635,7 +16990,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.
@@ -15685,7 +17040,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.",
@@ -15693,7 +17048,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.
@@ -15741,7 +17096,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.
@@ -15764,10 +17119,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";
@@ -15892,7 +17247,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"
@@ -15928,7 +17283,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",
@@ -15942,7 +17297,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"
@@ -15983,7 +17338,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";
@@ -16006,7 +17361,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"
@@ -16050,7 +17405,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).",
@@ -16066,7 +17421,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"
@@ -16104,7 +17459,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.",
@@ -16136,7 +17491,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"
@@ -16185,7 +17540,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;
@@ -16288,7 +17643,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]]'"
@@ -16340,7 +17695,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",
@@ -16348,7 +17703,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 },
@@ -16384,7 +17739,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).",
@@ -16416,7 +17771,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"
@@ -16463,7 +17818,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.",
@@ -16499,7 +17854,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"
@@ -16547,7 +17902,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).",
@@ -16573,7 +17928,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'"
@@ -16613,7 +17968,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).",
@@ -16625,7 +17980,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"
@@ -16667,7 +18022,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.",
@@ -16693,7 +18048,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"
@@ -16750,7 +18105,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.",
@@ -16775,7 +18130,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"
@@ -16813,7 +18168,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";
@@ -17545,7 +18900,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.
@@ -17600,7 +18955,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.",
@@ -17620,7 +18975,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'"
@@ -17660,7 +19015,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.",
@@ -17676,7 +19031,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"
@@ -17726,7 +19081,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.",
@@ -17742,7 +19097,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"
@@ -17802,7 +19157,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.",
@@ -17834,7 +19189,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"
@@ -17881,7 +19236,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).",
@@ -17939,7 +19294,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"
@@ -17995,7 +19350,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`,
@@ -18004,7 +19359,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`
@@ -18040,7 +19395,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.",
@@ -18078,7 +19433,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'"
@@ -18171,7 +19526,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).",
@@ -18186,7 +19541,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"
@@ -18241,7 +19596,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.",
@@ -18257,7 +19612,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"
@@ -18303,7 +19658,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.
@@ -18372,162 +19727,11 @@ Paid transforms (run on the Convex backend, cost-tracked):
   }
 });
 
-// src/commands/mcp/index.ts
-import { defineCommand as defineCommand123 } from "citty";
-var SCOPES = ["user", "company", "org"];
-function parseScope(raw) {
-  const scope = raw === void 0 ? "company" : String(raw);
-  if (!SCOPES.includes(scope)) {
-    throw new ApiError("VALIDATION_ERROR", `Invalid --scope "${scope}". Use user | company | org.`);
-  }
-  return scope;
-}
-function actingUserId() {
-  return getEnv().BAKER_ACTING_USER_ID;
-}
-function parseHeaders(raw) {
-  const list = raw === void 0 ? [] : Array.isArray(raw) ? raw : [raw];
-  const headers = {};
-  for (const entry of list) {
-    const text = String(entry);
-    const sep = text.indexOf(":") >= 0 && (text.indexOf(":") < text.indexOf("=") || text.indexOf("=") < 0) ? ":" : "=";
-    const at = text.indexOf(sep);
-    if (at <= 0) {
-      throw new ApiError("VALIDATION_ERROR", `Invalid header "${text}". Use "Key: Value".`);
-    }
-    headers[text.slice(0, at).trim()] = text.slice(at + 1).trim();
-  }
-  return Object.keys(headers).length > 0 ? headers : void 0;
-}
-function fail3(err) {
-  if (err instanceof ApiError) {
-    writeJson({ ok: false, error: { code: err.code, message: err.message } });
-    process.exit(1);
-  }
-  writeJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
-  process.exit(1);
-}
-registerSchema({
-  command: "mcp.list",
-  description: "List the custom MCP servers this company's chats see (org + company + your own user scope).",
-  args: {}
-});
-var listCommand4 = defineCommand123({
-  meta: { name: "list", description: "List custom MCP servers visible to this company's chats." },
-  run: async () => {
-    try {
-      const user = actingUserId();
-      const data = await apiGet(
-        "/api/mcp/custom",
-        user ? { actingUserId: user } : void 0
-      );
-      writeJson({ ok: true, data: data.servers });
-    } catch (err) {
-      fail3(err);
-    }
-  }
-});
-registerSchema({
-  command: "mcp.add",
-  description: "Register a custom MCP server. Tools appear as mcp__<name>__* on the next message. URL must be HTTPS. Scope: company (default, all chats) | org (org admin key) | user (only the current sender).",
-  args: {
-    name: { type: "string", description: "Server name \u2192 tools appear as mcp__<name>__*", required: true },
-    url: { type: "string", description: "HTTPS MCP endpoint", required: true },
-    scope: { type: "string", description: "user | company | org (default company)", required: false },
-    header: { type: "string", description: 'Auth header "Key: Value" (repeatable)', required: false }
-  }
-});
-var addCommand = defineCommand123({
-  meta: {
-    name: "add",
-    description: `Register a custom MCP server. Tools appear as mcp__<name>__* on the NEXT message.
-
-Scope: company (default \u2014 every chat in the company) | org (all companies in the org; needs an admin key) | user (only the current message sender).
-
-Examples:
-  baker mcp add --name weather --url https://mcp.example.com/mcp
-  baker mcp add --name acme --url https://acme.dev/mcp --header "Authorization: Bearer sk-\u2026"
-  baker mcp add --name mine --url https://my.dev/mcp --scope user`
-  },
-  args: {
-    name: { type: "string", description: "Server name (mcp__<name>__*)", required: true },
-    url: { type: "string", description: "HTTPS MCP endpoint", required: true },
-    scope: { type: "string", description: "user | company | org (default company)", required: false },
-    header: { type: "string", description: 'Auth header "Key: Value" (repeatable)', required: false }
-  },
-  run: async ({ args }) => {
-    try {
-      const scope = parseScope(args.scope);
-      const user = actingUserId();
-      const headers = parseHeaders(args.header);
-      const data = await apiPost("/api/mcp/custom", {
-        name: args.name,
-        url: args.url,
-        scope,
-        ...user ? { actingUserId: user } : {},
-        ...headers ? { headers } : {}
-      });
-      writeJson({ ok: true, data });
-    } catch (err) {
-      fail3(err);
-    }
-  }
-});
-registerSchema({
-  command: "mcp.remove",
-  description: "Remove a company custom MCP server by name.",
-  args: { name: { type: "string", description: "Server name to remove", required: true } }
-});
-var removeCommand3 = defineCommand123({
-  meta: {
-    name: "remove",
-    description: `Remove a company custom MCP server by name.
-
-Example:
-  baker mcp remove --name weather`
-  },
-  args: { name: { type: "string", description: "Server name to remove", required: true } },
-  run: async ({ args }) => {
-    try {
-      const user = actingUserId();
-      const data = await apiPost("/api/mcp/custom/remove", {
-        name: args.name,
-        ...user ? { actingUserId: user } : {}
-      });
-      writeJson({ ok: true, data });
-    } catch (err) {
-      fail3(err);
-    }
-  }
-});
-var mcpCommand = defineCommand123({
-  meta: {
-    name: "mcp",
-    description: `Custom MCP servers for this company \u2014 point the agent at any HTTPS MCP endpoint.
-
-Tools from a registered server appear as mcp__<name>__* on the next message.
-Managed here are **company-scoped** servers; user- and org-scoped servers are managed in the dashboard.
-
-Start here:
-  baker mcp list
-
-Examples:
-  baker mcp add --name weather --url https://mcp.example.com/mcp
-  baker mcp add --name acme --url https://acme.dev/mcp --header "Authorization: Bearer sk-\u2026"
-  baker mcp remove --name weather`
-  },
-  subCommands: {
-    list: listCommand4,
-    add: addCommand,
-    remove: removeCommand3
-  }
-});
-
 // src/commands/research/index.ts
-import { defineCommand as defineCommand134 } from "citty";
+import { defineCommand as defineCommand135 } from "citty";
 
 // src/commands/research/advertisers.ts
-import { defineCommand as defineCommand124 } from "citty";
+import { defineCommand as defineCommand125 } 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.";
@@ -18640,7 +19844,7 @@ var FIELDS3 = {
   etv: "Estimated traffic value (USD)",
   visibility: "SERP visibility score (0-1)"
 };
-var advertisersCommand = defineCommand124({
+var advertisersCommand = defineCommand125({
   meta: {
     name: "advertisers",
     description: `Find domains competing for a keyword in Google SERPs.
@@ -18687,7 +19891,7 @@ Examples:
 });
 
 // src/commands/research/autocomplete.ts
-import { defineCommand as defineCommand125 } from "citty";
+import { defineCommand as defineCommand126 } 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).",
@@ -18710,7 +19914,7 @@ registerSchema({
 var FIELDS4 = {
   suggestion: "Autocomplete suggestion from Google"
 };
-var autocompleteCommand = defineCommand125({
+var autocompleteCommand = defineCommand126({
   meta: {
     name: "autocomplete",
     description: `Get Google Autocomplete suggestions for keyword expansion.
@@ -18756,7 +19960,7 @@ Examples:
 });
 
 // src/commands/research/countries.ts
-import { defineCommand as defineCommand126 } from "citty";
+import { defineCommand as defineCommand127 } from "citty";
 registerSchema({
   command: "research.countries",
   description: "List all supported country codes for --location flag in research commands.",
@@ -18813,7 +20017,7 @@ var FIELDS5 = {
   code: "Country code to pass as --location",
   name: "Country name"
 };
-var countriesCommand = defineCommand126({
+var countriesCommand = defineCommand127({
   meta: {
     name: "countries",
     description: "List all supported country codes for --location flag."
@@ -18824,7 +20028,7 @@ var countriesCommand = defineCommand126({
 });
 
 // src/commands/research/intent.ts
-import { defineCommand as defineCommand127 } from "citty";
+import { defineCommand as defineCommand128 } 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.",
@@ -18847,7 +20051,7 @@ var FIELDS6 = {
   intent: "Primary Google Search intent: informational, navigational, commercial, transactional",
   probability: "Confidence score 0.0-1.0"
 };
-var intentCommand = defineCommand127({
+var intentCommand = defineCommand128({
   meta: {
     name: "intent",
     description: `Classify Google Search intent for keywords. Returns intent type and confidence.
@@ -18895,7 +20099,7 @@ Examples:
 });
 
 // src/commands/research/keyword-gap.ts
-import { defineCommand as defineCommand128 } from "citty";
+import { defineCommand as defineCommand129 } 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.",
@@ -18924,7 +20128,7 @@ var FIELDS7 = {
   cpc: "Cost per click USD",
   their_position: "Competitor's ranking position"
 };
-var keywordGapCommand = defineCommand128({
+var keywordGapCommand = defineCommand129({
   meta: {
     name: "keyword-gap",
     description: `Find keywords a competitor has that you don't. Supports pagination via --offset.
@@ -18998,7 +20202,7 @@ Examples:
 });
 
 // src/commands/research/keywords-for-site.ts
-import { defineCommand as defineCommand129 } from "citty";
+import { defineCommand as defineCommand130 } 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.",
@@ -19031,7 +20235,7 @@ var FIELDS8 = {
   competition: "LOW, MEDIUM, or HIGH",
   competition_index: "Competition score 0-100"
 };
-var keywordsForSiteCommand = defineCommand129({
+var keywordsForSiteCommand = defineCommand130({
   meta: {
     name: "keywords-for-site",
     description: `Get keywords a competitor targets in Google. Use --type to filter paid/organic.
@@ -19084,7 +20288,7 @@ Examples:
 });
 
 // src/commands/research/languages.ts
-import { defineCommand as defineCommand130 } from "citty";
+import { defineCommand as defineCommand131 } from "citty";
 registerSchema({
   command: "research.languages",
   description: "List all supported language codes for --language flag in research commands.",
@@ -19114,7 +20318,7 @@ var FIELDS9 = {
   code: "Language code to pass as --language",
   name: "Language name (also accepted by --language)"
 };
-var languagesCommand2 = defineCommand130({
+var languagesCommand2 = defineCommand131({
   meta: {
     name: "languages",
     description: "List all supported language codes for --language flag."
@@ -19125,7 +20329,7 @@ var languagesCommand2 = defineCommand130({
 });
 
 // src/commands/research/lighthouse.ts
-import { defineCommand as defineCommand131 } from "citty";
+import { defineCommand as defineCommand132 } from "citty";
 registerSchema({
   command: "research.lighthouse",
   description: "Landing page performance audit. Returns metrics that affect Google Ads Quality Score and CPC.",
@@ -19144,7 +20348,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 = defineCommand132({
   meta: {
     name: "lighthouse",
     description: `Landing page performance audit. Metrics affecting Google Ads Quality Score.
@@ -19182,7 +20386,7 @@ Examples:
 });
 
 // src/commands/research/relevant-pages.ts
-import { defineCommand as defineCommand132 } from "citty";
+import { defineCommand as defineCommand133 } 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).",
@@ -19208,7 +20412,7 @@ var FIELDS11 = {
   keywords: "Total organic keywords the page ranks for",
   top_10: "Keywords in positions 1-10"
 };
-var relevantPagesCommand = defineCommand132({
+var relevantPagesCommand = defineCommand133({
   meta: {
     name: "relevant-pages",
     description: `Get the top pages of a competitor domain with traffic data.
@@ -19254,7 +20458,7 @@ Examples:
 });
 
 // src/commands/research/web.ts
-import { defineCommand as defineCommand133 } from "citty";
+import { defineCommand as defineCommand134 } 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).",
@@ -19305,7 +20509,7 @@ async function runDeepResearch(question) {
   }
   throw new Error("Deep research timed out");
 }
-var webCommand = defineCommand133({
+var webCommand = defineCommand134({
   meta: {
     name: "web",
     description: `Search the web with AI to answer any open-ended marketing question. Uses live internet data via Google Search.
@@ -19365,7 +20569,7 @@ Examples:
 });
 
 // src/commands/research/index.ts
-var researchCommand = defineCommand134({
+var researchCommand = defineCommand135({
   meta: {
     name: "research",
     description: `Competitive intelligence and AI-powered research commands.
@@ -19405,10 +20609,10 @@ Examples:
 });
 
 // src/commands/scheduled-actions/index.ts
-import { defineCommand as defineCommand141 } from "citty";
+import { defineCommand as defineCommand142 } from "citty";
 
 // src/commands/scheduled-actions/create.ts
-import { defineCommand as defineCommand135 } from "citty";
+import { defineCommand as defineCommand136 } from "citty";
 
 // src/commands/scheduled-actions/shared.ts
 var TEMP_SCHEDULED_ACTION_PREFIX = "temp_sched_";
@@ -19523,7 +20727,7 @@ registerSchema({
     prompt: { type: "string", description: "Additional prompt instructions for the spawned agent", required: false }
   }
 });
-var createCommand2 = defineCommand135({
+var createCommand2 = defineCommand136({
   meta: {
     name: "create",
     description: 'Stage a scheduled action. Example: baker scheduled-actions create --name "Weekly report" --description "..." --cron "0 9 * * MON"'
@@ -19572,7 +20776,7 @@ var createCommand2 = defineCommand135({
 });
 
 // src/commands/scheduled-actions/delete.ts
-import { defineCommand as defineCommand136 } from "citty";
+import { defineCommand as defineCommand137 } from "citty";
 registerSchema({
   command: "scheduled-actions.delete",
   description: "Stage deletion of a published scheduled action or cancellation of a temp_sched_* draft creation.",
@@ -19580,7 +20784,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID or temp_sched_* draft ID", required: true }
   }
 });
-var deleteCommand2 = defineCommand136({
+var deleteCommand2 = defineCommand137({
   meta: {
     name: "delete",
     description: "Stage scheduled action deletion. Example: baker scheduled-actions delete <id-or-temp_sched_id>"
@@ -19609,7 +20813,7 @@ var deleteCommand2 = defineCommand136({
 });
 
 // src/commands/scheduled-actions/get.ts
-import { defineCommand as defineCommand137 } from "citty";
+import { defineCommand as defineCommand138 } from "citty";
 registerSchema({
   command: "scheduled-actions.get",
   description: "Get a published scheduled action or a temp_sched_* draft-created scheduled action.",
@@ -19617,7 +20821,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID or temp_sched_* draft ID", required: true }
   }
 });
-var getCommand3 = defineCommand137({
+var getCommand3 = defineCommand138({
   meta: {
     name: "get",
     description: "Get a scheduled action. Example: baker scheduled-actions get <id-or-temp_sched_id>"
@@ -19654,13 +20858,13 @@ var getCommand3 = defineCommand137({
 });
 
 // src/commands/scheduled-actions/list.ts
-import { defineCommand as defineCommand138 } from "citty";
+import { defineCommand as defineCommand139 } 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 listCommand4 = defineCommand139({
   meta: {
     name: "list",
     description: "List scheduled actions. Includes staged draft ops when BAKER_CHAT_ID is set."
@@ -19681,7 +20885,7 @@ var listCommand5 = defineCommand138({
 });
 
 // src/commands/scheduled-actions/trigger.ts
-import { defineCommand as defineCommand139 } from "citty";
+import { defineCommand as defineCommand140 } 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.",
@@ -19689,7 +20893,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID", required: true }
   }
 });
-var triggerCommand = defineCommand139({
+var triggerCommand = defineCommand140({
   meta: {
     name: "trigger",
     description: "Immediately trigger a published scheduled action. Example: baker scheduled-actions trigger <id>"
@@ -19726,7 +20930,7 @@ var triggerCommand = defineCommand139({
 });
 
 // src/commands/scheduled-actions/update.ts
-import { defineCommand as defineCommand140 } from "citty";
+import { defineCommand as defineCommand141 } from "citty";
 registerSchema({
   command: "scheduled-actions.update",
   description: "Stage an update to a published scheduled action or temp_sched_* draft-created scheduled action.",
@@ -19751,7 +20955,7 @@ registerSchema({
     prompt: { type: "string", description: "Replacement additional spawned-agent instructions", required: false }
   }
 });
-var updateCommand2 = defineCommand140({
+var updateCommand2 = defineCommand141({
   meta: {
     name: "update",
     description: "Stage a scheduled action update. Example: baker scheduled-actions update <id> --enabled false"
@@ -19822,7 +21026,7 @@ var updateCommand2 = defineCommand140({
 });
 
 // src/commands/scheduled-actions/index.ts
-var scheduledActionsCommand = defineCommand141({
+var scheduledActionsCommand = defineCommand142({
   meta: {
     name: "scheduled-actions",
     description: `Manage Scheduled Actions. Subcommands: list, get, create, update, delete, trigger.
@@ -19838,7 +21042,7 @@ Examples:
   baker scheduled-actions trigger <id>`
   },
   subCommands: {
-    list: listCommand5,
+    list: listCommand4,
     get: getCommand3,
     create: createCommand2,
     update: updateCommand2,
@@ -19848,8 +21052,8 @@ Examples:
 });
 
 // src/commands/schema.ts
-import { defineCommand as defineCommand142 } from "citty";
-var schemaCommand = defineCommand142({
+import { defineCommand as defineCommand143 } from "citty";
+var schemaCommand = defineCommand143({
   meta: {
     name: "schema",
     description: "Inspect command argument schemas (for AI agent introspection). Lists all commands if no argument given. Example: baker schema images.search"
@@ -19885,10 +21089,10 @@ var schemaCommand = defineCommand142({
 });
 
 // src/commands/testimonials/index.ts
-import { defineCommand as defineCommand146 } from "citty";
+import { defineCommand as defineCommand147 } from "citty";
 
 // src/commands/testimonials/get.ts
-import { defineCommand as defineCommand143 } from "citty";
+import { defineCommand as defineCommand144 } from "citty";
 registerSchema({
   command: "testimonials.get",
   description: "Get a single testimonial by ID",
@@ -19896,7 +21100,7 @@ registerSchema({
     id: { type: "string", description: "Testimonial ID", required: true }
   }
 });
-var getCommand4 = defineCommand143({
+var getCommand4 = defineCommand144({
   meta: { name: "get", description: "Get a single testimonial by ID. Example: baker testimonials get j571abc123" },
   args: {
     id: { type: "positional", description: "Testimonial ID", required: false },
@@ -19933,7 +21137,7 @@ var getCommand4 = defineCommand143({
 });
 
 // src/commands/testimonials/list.ts
-import { defineCommand as defineCommand144 } from "citty";
+import { defineCommand as defineCommand145 } from "citty";
 registerSchema({
   command: "testimonials.list",
   description: "List testimonials with optional filters.",
@@ -19963,7 +21167,7 @@ registerSchema({
     limit: { type: "number", description: "Max results (default 50)", required: false, default: 50 }
   }
 });
-var listCommand6 = defineCommand144({
+var listCommand5 = defineCommand145({
   meta: {
     name: "list",
     description: "List testimonials with optional filters. Example: baker testimonials list --source google --sentiment positive"
@@ -20012,7 +21216,7 @@ var listCommand6 = defineCommand144({
 });
 
 // src/commands/testimonials/search.ts
-import { defineCommand as defineCommand145 } from "citty";
+import { defineCommand as defineCommand146 } from "citty";
 registerSchema({
   command: "testimonials.search",
   description: "Search testimonials by text query. Uses hybrid BM25 + vector + reranking.",
@@ -20043,7 +21247,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand2 = defineCommand145({
+var searchCommand2 = defineCommand146({
   meta: {
     name: "search",
     description: "Semantic search testimonials by text query. Uses hybrid BM25 + vector + reranking. Example: baker testimonials search 'great service' --rating-min 4"
@@ -20117,7 +21321,7 @@ var searchCommand2 = defineCommand145({
 var tagsCommand3 = makeTagsCommand("testimonials", "testimonial", "/api/testimonials/tags");
 
 // src/commands/testimonials/index.ts
-var testimonialsCommand = defineCommand146({
+var testimonialsCommand = defineCommand147({
   meta: {
     name: "testimonials",
     description: `Find and browse testimonials in Baker. Subcommands: search, get, list, tags.
@@ -20132,16 +21336,16 @@ Examples:
   subCommands: {
     get: getCommand4,
     search: searchCommand2,
-    list: listCommand6,
+    list: listCommand5,
     tags: tagsCommand3
   }
 });
 
 // src/commands/videos/index.ts
-import { defineCommand as defineCommand151 } from "citty";
+import { defineCommand as defineCommand152 } from "citty";
 
 // src/commands/videos/delete.ts
-import { defineCommand as defineCommand147 } from "citty";
+import { defineCommand as defineCommand148 } from "citty";
 registerSchema({
   command: "videos.delete",
   description: "Delete a video by ID",
@@ -20155,7 +21359,7 @@ registerSchema({
     }
   }
 });
-var deleteCommand3 = defineCommand147({
+var deleteCommand3 = defineCommand148({
   meta: {
     name: "delete",
     description: "Delete a video by ID. Use --dry-run to preview. Example: baker videos delete j571abc123 --dry-run"
@@ -20196,7 +21400,7 @@ var deleteCommand3 = defineCommand147({
 });
 
 // src/commands/videos/get.ts
-import { defineCommand as defineCommand148 } from "citty";
+import { defineCommand as defineCommand149 } from "citty";
 registerSchema({
   command: "videos.get",
   description: "Get a single video by ID",
@@ -20204,7 +21408,7 @@ registerSchema({
     id: { type: "string", description: "Video ID", required: true }
   }
 });
-var getCommand5 = defineCommand148({
+var getCommand5 = defineCommand149({
   meta: { name: "get", description: "Get a single video by ID. Example: baker videos get j571abc123" },
   args: {
     id: { type: "positional", description: "Video ID", required: false },
@@ -20241,7 +21445,7 @@ var getCommand5 = defineCommand148({
 });
 
 // src/commands/videos/search.ts
-import { defineCommand as defineCommand149 } from "citty";
+import { defineCommand as defineCommand150 } from "citty";
 registerSchema({
   command: "videos.search",
   description: "Search videos by text query. Only returns ready videos.",
@@ -20251,7 +21455,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand3 = defineCommand149({
+var searchCommand3 = defineCommand150({
   meta: {
     name: "search",
     description: "Semantic search videos by text query. Uses hybrid BM25 + vector + reranking. Example: baker videos search 'product demo' --tags tutorial"
@@ -20303,7 +21507,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 defineCommand151 } from "citty";
 var MIME_MAP = {
   ".mp4": "video/mp4",
   ".mov": "video/quicktime",
@@ -20337,7 +21541,7 @@ function detectContentType(filePath) {
   }
   return mime;
 }
-var uploadCommand2 = defineCommand150({
+var uploadCommand2 = defineCommand151({
   meta: {
     name: "upload",
     description: "Upload a video file to Baker via Mux direct upload. Auto-detects content type. Example: baker videos upload ./demo.mp4"
@@ -20391,7 +21595,7 @@ var uploadCommand2 = defineCommand150({
 });
 
 // src/commands/videos/index.ts
-var videosCommand = defineCommand151({
+var videosCommand = defineCommand152({
   meta: {
     name: "videos",
     description: `Find and manage videos in Baker. Subcommands: search, get, upload, delete, tags.
@@ -20414,10 +21618,10 @@ Examples:
 });
 
 // src/commands/winning-ads/index.ts
-import { defineCommand as defineCommand154 } from "citty";
+import { defineCommand as defineCommand155 } from "citty";
 
 // src/commands/winning-ads/advertisers.ts
-import { defineCommand as defineCommand152 } from "citty";
+import { defineCommand as defineCommand153 } 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).",
@@ -20430,7 +21634,7 @@ registerSchema({
 function identity(record) {
   return record;
 }
-var advertisersCommand2 = defineCommand152({
+var advertisersCommand2 = defineCommand153({
   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'
@@ -20481,7 +21685,7 @@ var advertisersCommand2 = defineCommand152({
 });
 
 // src/commands/winning-ads/search.ts
-import { defineCommand as defineCommand153 } from "citty";
+import { defineCommand as defineCommand154 } 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.",
@@ -20589,7 +21793,7 @@ function buildSearchBody(args) {
   }
   return body;
 }
-var searchCommand4 = defineCommand153({
+var searchCommand4 = defineCommand154({
   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"
@@ -20701,7 +21905,7 @@ var searchCommand4 = defineCommand153({
 });
 
 // src/commands/winning-ads/index.ts
-var winningAdsCommand = defineCommand154({
+var winningAdsCommand = defineCommand155({
   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.
@@ -20725,7 +21929,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);
 }
@@ -20737,11 +21941,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 = defineCommand156({
   meta: {
     name: "baker",
     version: getCliVersion(),
@@ -20756,7 +21960,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,
@@ -20766,7 +21970,6 @@ Introspection: Run 'baker schema <command>' to inspect argument schemas.`
     testimonials: testimonialsCommand,
     canvas: canvasCommand,
     "winning-ads": winningAdsCommand,
-    mcp: mcpCommand,
     schema: schemaCommand
   }
 });