@koda-sl/baker-cli 0.104.0 → 0.106.0-dev.a605c0acb

package/dist/cli.js

@@ -9,10 +9,10 @@ import {
   defaultRegistry,
   generateCatalog,
   validateCanvasDeep
-} from "./chunk-3JVYU72O.js";
+} from "./chunk-26K7V346.js";
 
 // src/cli.ts
-import { defineCommand as defineCommand152, runMain } from "citty";
+import { defineCommand as defineCommand154, runMain } from "citty";
 
 // src/commands/actions/index.ts
 import { defineCommand as defineCommand18 } from "citty";
@@ -935,6 +935,990 @@ var actionsTagsCreateResponseSchema = okResponse(z2.object({ tagId: z2.string()
 var actionsTagsDeleteRequestSchema = z2.object({ name: z2.string() });
 var actionsTagsDeleteResponseSchema = okOnlySchema();
 
+// ../api/src/ads-linkedin/limits.ts
+var LINKEDIN_LIMITS = {
+  campaignGroup: {
+    nameMax: 100
+  },
+  campaign: {
+    nameMax: 255
+  },
+  creative: {
+    commentarySoftMax: 600,
+    // feed truncates with "…see more" beyond this
+    commentaryHardMax: 3e3,
+    headlineMax: 70,
+    descriptionMax: 300,
+    textAdHeadlineMax: 25,
+    textAdDescriptionMax: 75,
+    spotlightHeadlineMax: 70,
+    spotlightDescriptionMax: 70,
+    spotlightCtaMax: 18,
+    carouselCardHeadlineMax: 45,
+    carouselCardsMin: 2,
+    carouselCardsMax: 10,
+    conversationButtonLabelMax: 25
+  },
+  audience: {
+    nameMax: 100,
+    minRowsToServe: 300,
+    // LinkedIn refuses to serve smaller matched audiences
+    inlineRowsMax: 1e4,
+    // above this the list must come as a stored file ref
+    rowsMax: 3e5
+  },
+  conversion: {
+    nameMax: 255,
+    postClickWindows: [1, 7, 30, 90],
+    viewThroughWindows: [1, 7, 30]
+  },
+  leadForm: {
+    nameMax: 256,
+    headlineMax: 60,
+    descriptionMax: 160,
+    questionsMax: 12,
+    questionsSoftMax: 4,
+    // playbook: >4 fields tanks completion rate
+    customQuestionsMax: 3,
+    thankYouMessageMax: 300
+  }
+};
+var CAMPAIGN_TYPES = ["SPONSORED_UPDATES", "TEXT_AD", "SPONSORED_INMAILS", "DYNAMIC"];
+var COST_TYPES = ["CPC", "CPM", "CPV"];
+var OBJECTIVE_TYPES = [
+  "BRAND_AWARENESS",
+  "ENGAGEMENT",
+  "JOB_APPLICANT",
+  "LEAD_GENERATION",
+  "WEBSITE_CONVERSION",
+  "WEBSITE_VISIT",
+  "VIDEO_VIEW",
+  "TALENT_LEAD"
+];
+var OBJECTIVE_CAMPAIGN_TYPES = {
+  VIDEO_VIEW: ["SPONSORED_UPDATES"],
+  LEAD_GENERATION: ["SPONSORED_UPDATES", "SPONSORED_INMAILS"],
+  ENGAGEMENT: ["SPONSORED_UPDATES", "DYNAMIC"]
+};
+var STAGEABLE_CREATE_STATUSES = ["DRAFT", "ACTIVE", "PAUSED"];
+var CREATIVE_INTENDED_STATUSES = ["ACTIVE", "PAUSED", "DRAFT"];
+var CTA_TYPES = [
+  "APPLY",
+  "DOWNLOAD",
+  "VIEW_QUOTE",
+  "LEARN_MORE",
+  "SIGN_UP",
+  "SUBSCRIBE",
+  "REGISTER",
+  "JOIN",
+  "ATTEND",
+  "REQUEST_DEMO",
+  "SEE_MORE"
+];
+var CREATIVE_SELECTIONS = ["OPTIMIZED", "ROUND_ROBIN"];
+var AUDIENCE_TYPES = ["company-list", "user-list", "retargeting", "engagement"];
+var CONVERSION_TYPES = [
+  "ADD_TO_CART",
+  "DOWNLOAD",
+  "INSTALL",
+  "KEY_PAGE_VIEW",
+  "LEAD",
+  "PURCHASE",
+  "SIGN_UP",
+  "OTHER"
+];
+var CONVERSION_METHODS = ["INSIGHT_TAG", "CONVERSIONS_API"];
+var ATTRIBUTION_TYPES = ["LAST_TOUCH_BY_CAMPAIGN", "LAST_TOUCH_BY_CONVERSION"];
+var CURRENCY_MINIMUMS = {
+  USD: { dailyBudgetMin: 10, unitCostMin: 2 },
+  EUR: { dailyBudgetMin: 10, unitCostMin: 2 },
+  GBP: { dailyBudgetMin: 8, unitCostMin: 2 }
+};
+var DEFAULT_CURRENCY_MINIMUM = { dailyBudgetMin: 10, unitCostMin: 2 };
+var TEMP_REF_REGEX = /^li_temp_[A-Za-z0-9_-]{4,}$/;
+var NUMERIC_ID_REGEX = /^\d+$/;
+var URN_REGEX = /^urn:li:[a-zA-Z]+:.+$/;
+var IMAGE_URN_REGEX = /^urn:li:image:.+$/;
+var VIDEO_URN_REGEX = /^urn:li:video:.+$/;
+var DOCUMENT_URN_REGEX = /^urn:li:document:.+$/;
+var POST_URN_REGEX = /^urn:li:(share|ugcPost):\d+$/;
+var ORGANIZATION_URN_REGEX = /^urn:li:organization:\d+$/;
+var TARGETING_FACET_URN_REGEX = /^urn:li:adTargetingFacet:[a-zA-Z]+$/;
+
+// ../api/src/ads-linkedin/ops.ts
+import { z as z3 } from "zod";
+var tempRefSchema = z3.string().regex(TEMP_REF_REGEX, "expected a li_temp_* reference");
+var parentRefSchema = z3.union([
+  z3.string().regex(URN_REGEX, "expected a urn:li:* value"),
+  z3.string().regex(NUMERIC_ID_REGEX, "expected a numeric id"),
+  tempRefSchema
+]);
+var moneySchema = z3.object({
+  amount: z3.string().regex(/^\d+(\.\d{1,2})?$/, "expected a decimal amount like 50 or 50.00").refine((val) => Number(val) > 0, "amount must be greater than zero"),
+  currencyCode: z3.string().length(3)
+});
+var runScheduleSchema = z3.object({
+  start: z3.number().int().positive(),
+  end: z3.number().int().positive().optional()
+}).refine((s) => s.end === void 0 || s.end > s.start, {
+  message: "runSchedule.end must be after runSchedule.start",
+  path: ["end"]
+});
+var facetValuesSchema = z3.array(z3.union([z3.string().regex(URN_REGEX), tempRefSchema])).min(1);
+var targetingCriteriaSchema = z3.object({
+  include: z3.object({
+    and: z3.array(
+      z3.object({
+        or: z3.record(z3.string().regex(TARGETING_FACET_URN_REGEX, "invalid targeting facet URN"), facetValuesSchema)
+      })
+    ).min(1, "targeting needs at least one include facet group")
+  }),
+  exclude: z3.object({
+    or: z3.record(z3.string().regex(TARGETING_FACET_URN_REGEX, "invalid targeting facet URN"), facetValuesSchema)
+  }).optional()
+});
+var stageableStatusSchema = z3.enum(STAGEABLE_CREATE_STATUSES);
+var entityStatusSchema = z3.enum(["ACTIVE", "PAUSED", "ARCHIVED", "CANCELED", "DRAFT", "COMPLETED"]);
+function currencyMinimums(currencyCode) {
+  return CURRENCY_MINIMUMS[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM;
+}
+var campaignGroupCreateSchema = z3.object({
+  name: z3.string().min(1).max(LINKEDIN_LIMITS.campaignGroup.nameMax),
+  runSchedule: runScheduleSchema,
+  totalBudget: moneySchema.optional(),
+  status: stageableStatusSchema.default("DRAFT")
+});
+var campaignGroupUpdateSchema = z3.object({
+  name: z3.string().min(1).max(LINKEDIN_LIMITS.campaignGroup.nameMax).optional(),
+  runSchedule: runScheduleSchema.optional(),
+  totalBudget: moneySchema.optional(),
+  status: entityStatusSchema.optional()
+}).refine((p) => Object.values(p).some((val) => val !== void 0), "update needs at least one field");
+var campaignFields = {
+  name: z3.string().min(1).max(LINKEDIN_LIMITS.campaign.nameMax),
+  campaignGroup: parentRefSchema,
+  type: z3.enum(CAMPAIGN_TYPES),
+  objectiveType: z3.enum(OBJECTIVE_TYPES).optional(),
+  costType: z3.enum(COST_TYPES),
+  unitCost: moneySchema.optional(),
+  dailyBudget: moneySchema.optional(),
+  totalBudget: moneySchema.optional(),
+  runSchedule: runScheduleSchema.optional(),
+  locale: z3.object({ country: z3.string().length(2), language: z3.string().length(2) }),
+  targetingCriteria: targetingCriteriaSchema,
+  audienceExpansionEnabled: z3.boolean().default(false),
+  offsiteDeliveryEnabled: z3.boolean().default(false),
+  connectedTelevisionOnly: z3.boolean().default(false),
+  creativeSelection: z3.enum(CREATIVE_SELECTIONS).optional(),
+  associatedEntity: z3.string().regex(ORGANIZATION_URN_REGEX).optional(),
+  status: stageableStatusSchema.default("DRAFT")
+};
+function validateCampaignBudgets(p, ctx, { requireBudget }) {
+  if (requireBudget && !p.dailyBudget && !p.totalBudget) {
+    ctx.addIssue({ code: "custom", path: ["dailyBudget"], message: "set dailyBudget and/or totalBudget" });
+  }
+  if (p.totalBudget && !p.dailyBudget && !p.runSchedule?.end) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["runSchedule", "end"],
+      message: "totalBudget-only campaigns need runSchedule.end"
+    });
+  }
+  if (p.dailyBudget) {
+    const min = currencyMinimums(p.dailyBudget.currencyCode).dailyBudgetMin;
+    if (Number(p.dailyBudget.amount) < min) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["dailyBudget", "amount"],
+        message: `dailyBudget below the ${min} ${p.dailyBudget.currencyCode} minimum`
+      });
+    }
+  }
+  if (p.unitCost) {
+    const min = currencyMinimums(p.unitCost.currencyCode).unitCostMin;
+    if (Number(p.unitCost.amount) < min) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["unitCost", "amount"],
+        message: `unitCost below the ${min} ${p.unitCost.currencyCode} minimum bid`
+      });
+    }
+  }
+}
+var campaignCreateSchema = z3.object(campaignFields).superRefine((p, ctx) => {
+  validateCampaignBudgets(p, ctx, { requireBudget: true });
+  const allowedTypes = p.objectiveType ? OBJECTIVE_CAMPAIGN_TYPES[p.objectiveType] : void 0;
+  if (allowedTypes && !allowedTypes.includes(p.type)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["type"],
+      message: `objective ${p.objectiveType} only supports campaign types ${allowedTypes.join(", ")}`
+    });
+  }
+});
+var campaignUpdateSchema = z3.object({
+  name: campaignFields.name.optional(),
+  objectiveType: campaignFields.objectiveType,
+  unitCost: moneySchema.optional(),
+  dailyBudget: moneySchema.optional(),
+  totalBudget: moneySchema.optional(),
+  runSchedule: runScheduleSchema.optional(),
+  targetingCriteria: targetingCriteriaSchema.optional(),
+  audienceExpansionEnabled: z3.boolean().optional(),
+  offsiteDeliveryEnabled: z3.boolean().optional(),
+  connectedTelevisionOnly: z3.boolean().optional(),
+  creativeSelection: z3.enum(CREATIVE_SELECTIONS).optional(),
+  status: entityStatusSchema.optional()
+}).superRefine((p, ctx) => {
+  if (!Object.values(p).some((val) => val !== void 0)) {
+    ctx.addIssue({ code: "custom", message: "update needs at least one field" });
+  }
+  validateCampaignBudgets(p, ctx, { requireBudget: false });
+});
+var commentarySchema = z3.string().min(1).max(LINKEDIN_LIMITS.creative.commentaryHardMax);
+var headlineSchema = z3.string().min(1).max(LINKEDIN_LIMITS.creative.headlineMax);
+var httpsUrlSchema = z3.string().url().refine((u) => u.startsWith("https://"), "landing pages must be https");
+var bakerMediaIdSchema = z3.string().min(1);
+var imageCreativeSchema = z3.object({
+  format: z3.literal("image"),
+  commentary: commentarySchema,
+  imageId: bakerMediaIdSchema.optional(),
+  imageUrn: z3.string().regex(IMAGE_URN_REGEX).optional(),
+  headline: headlineSchema,
+  landingUrl: httpsUrlSchema,
+  cta: z3.enum(CTA_TYPES).optional(),
+  mediaTitle: z3.string().max(200).optional()
+}).refine((p) => p.imageId ? !p.imageUrn : Boolean(p.imageUrn), {
+  message: "provide exactly one of imageId (Baker library) or imageUrn (already on LinkedIn)",
+  path: ["imageId"]
+});
+var videoCreativeSchema = z3.object({
+  format: z3.literal("video"),
+  commentary: commentarySchema,
+  videoId: bakerMediaIdSchema.optional(),
+  videoUrn: z3.string().regex(VIDEO_URN_REGEX).optional(),
+  headline: headlineSchema,
+  landingUrl: httpsUrlSchema.optional(),
+  cta: z3.enum(CTA_TYPES).optional(),
+  mediaTitle: z3.string().max(200).optional()
+}).refine((p) => p.videoId ? !p.videoUrn : Boolean(p.videoUrn), {
+  message: "provide exactly one of videoId (Baker library) or videoUrn (already on LinkedIn)",
+  path: ["videoId"]
+});
+var textCreativeSchema = z3.object({
+  format: z3.literal("text"),
+  headline: z3.string().min(1).max(LINKEDIN_LIMITS.creative.textAdHeadlineMax),
+  description: z3.string().min(1).max(LINKEDIN_LIMITS.creative.textAdDescriptionMax),
+  landingUrl: httpsUrlSchema,
+  imageId: bakerMediaIdSchema.optional(),
+  imageUrn: z3.string().regex(IMAGE_URN_REGEX).optional()
+});
+var spotlightCreativeSchema = z3.object({
+  format: z3.literal("spotlight"),
+  headline: z3.string().min(1).max(LINKEDIN_LIMITS.creative.spotlightHeadlineMax),
+  description: z3.string().min(1).max(LINKEDIN_LIMITS.creative.spotlightDescriptionMax),
+  landingUrl: httpsUrlSchema,
+  ctaLabel: z3.string().min(1).max(LINKEDIN_LIMITS.creative.spotlightCtaMax),
+  logoImageId: bakerMediaIdSchema.optional(),
+  logoUrn: z3.string().regex(IMAGE_URN_REGEX).optional(),
+  showMemberProfilePhoto: z3.boolean().default(true)
+});
+var followerCreativeSchema = z3.object({
+  format: z3.literal("follower"),
+  headline: z3.string().max(LINKEDIN_LIMITS.creative.spotlightHeadlineMax).optional(),
+  description: z3.string().max(LINKEDIN_LIMITS.creative.spotlightDescriptionMax).optional(),
+  logoImageId: bakerMediaIdSchema.optional(),
+  logoUrn: z3.string().regex(IMAGE_URN_REGEX).optional()
+});
+var documentCreativeSchema = z3.object({
+  format: z3.literal("document"),
+  commentary: commentarySchema,
+  documentTitle: z3.string().min(1).max(200),
+  documentUrn: z3.string().regex(DOCUMENT_URN_REGEX).optional(),
+  documentId: bakerMediaIdSchema.optional()
+}).refine((p) => p.documentId ? !p.documentUrn : Boolean(p.documentUrn), {
+  message: "provide exactly one of documentId or documentUrn",
+  path: ["documentId"]
+});
+var carouselCreativeSchema = z3.object({
+  format: z3.literal("carousel"),
+  commentary: commentarySchema,
+  cards: z3.array(
+    z3.object({
+      imageId: bakerMediaIdSchema.optional(),
+      imageUrn: z3.string().regex(IMAGE_URN_REGEX).optional(),
+      headline: z3.string().min(1).max(LINKEDIN_LIMITS.creative.carouselCardHeadlineMax),
+      landingUrl: httpsUrlSchema
+    }).refine((card) => card.imageId ? !card.imageUrn : Boolean(card.imageUrn), {
+      message: "each card needs exactly one of imageId or imageUrn",
+      path: ["imageId"]
+    })
+  ).min(LINKEDIN_LIMITS.creative.carouselCardsMin).max(LINKEDIN_LIMITS.creative.carouselCardsMax)
+});
+var conversationCreativeSchema = z3.object({
+  format: z3.literal("conversation"),
+  name: z3.string().max(255).optional(),
+  raw: z3.record(z3.string(), z3.unknown())
+});
+var tlaCreativeSchema = z3.object({
+  format: z3.literal("tla"),
+  postUrn: z3.string().regex(POST_URN_REGEX, "expected urn:li:share:* or urn:li:ugcPost:*")
+});
+var jobsCreativeSchema = z3.object({
+  format: z3.literal("jobs"),
+  organizationName: z3.string().min(1).max(200),
+  logoImageId: bakerMediaIdSchema.optional(),
+  logoUrn: z3.string().regex(IMAGE_URN_REGEX).optional(),
+  headlinePreset: z3.string().min(1),
+  buttonLabelPreset: z3.string().min(1)
+});
+var creativeContentSchema = z3.discriminatedUnion("format", [
+  imageCreativeSchema,
+  videoCreativeSchema,
+  textCreativeSchema,
+  spotlightCreativeSchema,
+  followerCreativeSchema,
+  documentCreativeSchema,
+  carouselCreativeSchema,
+  conversationCreativeSchema,
+  tlaCreativeSchema,
+  jobsCreativeSchema
+]);
+var creativeCreateSchema = z3.object({
+  campaign: parentRefSchema,
+  intendedStatus: z3.enum(CREATIVE_INTENDED_STATUSES).default("DRAFT"),
+  content: creativeContentSchema
+});
+var creativeUpdateSchema = z3.object({
+  intendedStatus: z3.enum(["ACTIVE", "PAUSED", "ARCHIVED", "DRAFT"]).optional(),
+  name: z3.string().max(255).optional(),
+  headline: headlineSchema.optional(),
+  landingUrl: httpsUrlSchema.optional(),
+  cta: z3.enum(CTA_TYPES).optional()
+}).refine((p) => Object.values(p).some((val) => val !== void 0), "update needs at least one field");
+var listRowSchema = z3.record(z3.string(), z3.string());
+var audienceCreateSchema = z3.object({
+  name: z3.string().min(1).max(LINKEDIN_LIMITS.audience.nameMax),
+  audienceType: z3.enum(AUDIENCE_TYPES),
+  listColumns: z3.array(z3.string().min(1)).optional(),
+  listRows: z3.array(listRowSchema).max(LINKEDIN_LIMITS.audience.inlineRowsMax).optional(),
+  /** Baker file reference (R2) for lists too large to inline. */
+  sourceFileRef: z3.string().optional(),
+  /** Retargeting/engagement source config — structural passthrough, file-first. */
+  raw: z3.record(z3.string(), z3.unknown()).optional()
+}).superRefine((p, ctx) => {
+  const isList = p.audienceType === "company-list" || p.audienceType === "user-list";
+  if (isList && !p.listRows?.length && !p.sourceFileRef) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["listRows"],
+      message: "list audiences need listRows (or sourceFileRef for large files)"
+    });
+  }
+  if (!isList && !p.raw) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["raw"],
+      message: `${p.audienceType} audiences need a raw source config (use --file)`
+    });
+  }
+});
+var audienceUploadListSchema = z3.object({
+  segment: parentRefSchema,
+  listColumns: z3.array(z3.string().min(1)).optional(),
+  listRows: z3.array(listRowSchema).max(LINKEDIN_LIMITS.audience.inlineRowsMax).optional(),
+  sourceFileRef: z3.string().optional()
+}).refine((p) => Boolean(p.listRows?.length) || Boolean(p.sourceFileRef), {
+  message: "upload needs listRows (or sourceFileRef for large files)",
+  path: ["listRows"]
+});
+var postClickWindowSchema = z3.number().refine(
+  (val) => LINKEDIN_LIMITS.conversion.postClickWindows.includes(val),
+  `postClickAttributionWindowSize must be one of ${LINKEDIN_LIMITS.conversion.postClickWindows.join(", ")}`
+);
+var viewThroughWindowSchema = z3.number().refine(
+  (val) => LINKEDIN_LIMITS.conversion.viewThroughWindows.includes(val),
+  `viewThroughAttributionWindowSize must be one of ${LINKEDIN_LIMITS.conversion.viewThroughWindows.join(", ")}`
+);
+var conversionCreateSchema = z3.object({
+  name: z3.string().min(1).max(LINKEDIN_LIMITS.conversion.nameMax),
+  type: z3.enum(CONVERSION_TYPES),
+  conversionMethod: z3.enum(CONVERSION_METHODS),
+  postClickAttributionWindowSize: postClickWindowSchema.optional(),
+  viewThroughAttributionWindowSize: viewThroughWindowSchema.optional(),
+  attributionType: z3.enum(ATTRIBUTION_TYPES).optional(),
+  /** Insight-tag URL match rules — passthrough validated by LinkedIn. */
+  urlMatchRuleExpression: z3.array(z3.array(z3.record(z3.string(), z3.string()))).optional(),
+  associateAllCampaigns: z3.boolean().optional()
+});
+var conversionUpdateSchema = z3.object({
+  name: conversionCreateSchema.shape.name.optional(),
+  postClickAttributionWindowSize: postClickWindowSchema.optional(),
+  viewThroughAttributionWindowSize: viewThroughWindowSchema.optional(),
+  attributionType: z3.enum(ATTRIBUTION_TYPES).optional(),
+  enabled: z3.boolean().optional()
+}).refine((p) => Object.values(p).some((val) => val !== void 0), "update needs at least one field");
+var leadFormCreateSchema = z3.object({
+  name: z3.string().min(1).max(LINKEDIN_LIMITS.leadForm.nameMax),
+  headline: z3.string().min(1).max(LINKEDIN_LIMITS.leadForm.headlineMax),
+  description: z3.string().max(LINKEDIN_LIMITS.leadForm.descriptionMax).optional(),
+  privacyPolicyUrl: httpsUrlSchema,
+  questions: z3.array(z3.object({ name: z3.string().min(1), predefinedField: z3.string().optional() })).min(1).max(LINKEDIN_LIMITS.leadForm.questionsMax),
+  thankYou: z3.object({
+    message: z3.string().max(LINKEDIN_LIMITS.leadForm.thankYouMessageMax).optional(),
+    landingUrl: httpsUrlSchema.optional()
+  }).optional(),
+  legalDisclaimer: z3.string().optional(),
+  raw: z3.record(z3.string(), z3.unknown()).optional()
+});
+var leadFormUpdateSchema = z3.object({
+  name: leadFormCreateSchema.shape.name.optional(),
+  raw: z3.record(z3.string(), z3.unknown()).optional()
+}).refine((p) => Object.values(p).some((val) => val !== void 0), "update needs at least one field");
+var LINKEDIN_DRAFT_OP_KINDS = [
+  "campaignGroup.create",
+  "campaignGroup.update",
+  "campaign.create",
+  "campaign.update",
+  "creative.create",
+  "creative.update",
+  "audience.create",
+  "audience.uploadList",
+  "conversion.create",
+  "conversion.update",
+  "leadForm.create",
+  "leadForm.update"
+];
+var linkedinDraftOpKindSchema = z3.enum(LINKEDIN_DRAFT_OP_KINDS);
+var accountIdSchema = z3.string().regex(NUMERIC_ID_REGEX, "accountId must be the bare numeric ad account id");
+var updateTargetSchema = z3.union([z3.string().regex(URN_REGEX), z3.string().regex(NUMERIC_ID_REGEX)]);
+function createOp(kind, payload) {
+  return z3.object({ kind: z3.literal(kind), accountId: accountIdSchema, payload });
+}
+function updateOp(kind, payload) {
+  return z3.object({ kind: z3.literal(kind), accountId: accountIdSchema, target: updateTargetSchema, payload });
+}
+var linkedinDraftOpInputSchema = z3.discriminatedUnion("kind", [
+  createOp("campaignGroup.create", campaignGroupCreateSchema),
+  updateOp("campaignGroup.update", campaignGroupUpdateSchema),
+  createOp("campaign.create", campaignCreateSchema),
+  updateOp("campaign.update", campaignUpdateSchema),
+  createOp("creative.create", creativeCreateSchema),
+  updateOp("creative.update", creativeUpdateSchema),
+  createOp("audience.create", audienceCreateSchema),
+  createOp("audience.uploadList", audienceUploadListSchema),
+  createOp("conversion.create", conversionCreateSchema),
+  updateOp("conversion.update", conversionUpdateSchema),
+  createOp("leadForm.create", leadFormCreateSchema),
+  updateOp("leadForm.update", leadFormUpdateSchema)
+]);
+
+// ../api/src/ads-linkedin/wire.ts
+import { z as z4 } from "zod";
+var linkedinWriteModeSchema = z4.enum(["live", "simulated"]);
+var linkedinDraftOpResultSchema = z4.object({
+  status: z4.enum(["applied", "simulated", "failed", "skipped"]),
+  urn: z4.string().optional(),
+  error: z4.string().optional(),
+  skippedBecause: z4.string().optional(),
+  executedAt: z4.number().optional()
+});
+var linkedinDraftStageRequestSchema = z4.object({
+  chatId: z4.string(),
+  op: linkedinDraftOpInputSchema
+});
+var linkedinDraftStageResponseSchema = z4.object({
+  staged: z4.literal(true),
+  ref: z4.string(),
+  kind: linkedinDraftOpKindSchema,
+  mode: linkedinWriteModeSchema,
+  dependsOn: z4.array(z4.string()),
+  summary: z4.string(),
+  warnings: z4.array(z4.string())
+});
+var linkedinDraftOpViewSchema = z4.object({
+  ref: z4.string(),
+  kind: linkedinDraftOpKindSchema,
+  accountId: z4.string(),
+  target: z4.string().optional(),
+  dependsOn: z4.array(z4.string()),
+  summary: z4.string(),
+  stagedAt: z4.number(),
+  result: linkedinDraftOpResultSchema.optional()
+});
+var linkedinDraftListRequestSchema = z4.object({
+  chatId: z4.string()
+});
+var linkedinDraftListResponseSchema = z4.object({
+  status: z4.enum(["active", "publishing", "applied", "discarded", "none"]),
+  mode: linkedinWriteModeSchema,
+  count: z4.number(),
+  ops: z4.array(linkedinDraftOpViewSchema)
+});
+var linkedinDraftRemoveRequestSchema = z4.object({
+  chatId: z4.string(),
+  ref: z4.string()
+});
+var linkedinDraftRemoveResponseSchema = z4.object({
+  /** The requested ref plus any dependents removed by cascade. */
+  removed: z4.array(z4.string())
+});
+var linkedinDraftClearRequestSchema = z4.object({
+  chatId: z4.string()
+});
+var linkedinDraftClearResponseSchema = z4.object({
+  cleared: z4.number()
+});
+var linkedinFieldErrorSchema = z4.object({
+  path: z4.string(),
+  message: z4.string()
+});
+var linkedinDraftErrorResponseSchema = z4.object({
+  code: z4.string(),
+  error: z4.string(),
+  fields: z4.array(linkedinFieldErrorSchema).optional()
+});
+
+// ../api/src/images.ts
+import { z as z5 } from "zod";
+var imageSourceSchema = z5.enum([
+  "uploaded",
+  "website",
+  "google_testimonial",
+  "trustpilot_testimonial",
+  "instagram",
+  "magnific",
+  "brandfetch",
+  "google_images",
+  "firecrawl",
+  "screenshotone",
+  "iconify",
+  "giphy",
+  "pinterest",
+  "ai_generated"
+]);
+var imageStatusSchema = z5.enum(["uploading", "processing", "ready", "error"]);
+var upscaleConfigSchema = z5.object({
+  model: z5.literal("philz1337x/crystal-upscaler"),
+  input: z5.object({
+    scale_factor: z5.number(),
+    creativity: z5.number(),
+    output_format: z5.string()
+  }),
+  status: z5.enum(["pending", "completed"])
+});
+var imageDocSchema = z5.object({
+  _id: z5.string(),
+  _creationTime: z5.number(),
+  companyId: z5.string(),
+  storageKey: z5.string(),
+  upscaleConfig: upscaleConfigSchema.optional(),
+  upscaledStorageKey: z5.string().optional(),
+  name: z5.string(),
+  description: z5.string(),
+  tags: z5.array(z5.string()),
+  source: z5.string(),
+  externalId: z5.string().optional(),
+  externalUrl: z5.string().optional(),
+  contentHash: z5.string().optional(),
+  sourceId: z5.string().optional(),
+  descriptionContext: z5.string().optional(),
+  width: z5.number().optional(),
+  height: z5.number().optional(),
+  aspectRatio: z5.number().optional(),
+  dominantColor: z5.string().optional(),
+  imagePalette: z5.array(z5.string()).optional(),
+  thumbhashDataUri: z5.string().optional(),
+  isLightImage: z5.boolean().optional(),
+  descriptionEmbedding: z5.array(z5.number()).optional(),
+  imageEmbedding: z5.array(z5.number()).optional(),
+  searchText: z5.string().optional(),
+  status: imageStatusSchema,
+  errorMessage: z5.string().optional(),
+  createdAt: z5.number(),
+  updatedAt: z5.number(),
+  imageUrl: z5.string()
+});
+var imageHitSourceSchema = z5.enum([
+  "library",
+  "magnific",
+  "google_images",
+  "brandfetch",
+  "firecrawl",
+  "screenshotone",
+  "iconify",
+  "giphy",
+  "pinterest"
+]);
+var imageHitSchema = z5.object({
+  source: imageHitSourceSchema,
+  url: z5.string(),
+  thumbnailUrl: z5.string().optional(),
+  width: z5.number().optional(),
+  height: z5.number().optional(),
+  aspectRatio: z5.number().optional(),
+  dominantColor: z5.string().optional(),
+  externalId: z5.string().optional(),
+  externalUrl: z5.string().optional(),
+  providerMeta: z5.record(z5.string(), z5.unknown()).optional(),
+  descriptionContext: z5.string().optional(),
+  _id: z5.string().optional(),
+  name: z5.string().optional(),
+  description: z5.string().optional(),
+  tags: z5.array(z5.string()).optional(),
+  score: z5.number().optional(),
+  alsoInLibrary: z5.string().optional(),
+  prefetchedBytes: z5.string().optional(),
+  prefetchedContentType: z5.string().optional()
+});
+var ingestedImageHitSchema = imageHitSchema.extend({
+  imageId: z5.string().optional(),
+  imageUrl: z5.string().optional(),
+  deduped: z5.boolean().optional(),
+  sourceUrl: z5.string().optional()
+});
+var autoIngestItemSchema = z5.object({
+  imageId: z5.string(),
+  deduped: z5.boolean(),
+  imageUrl: z5.string(),
+  sourceUrl: z5.string(),
+  externalUrl: z5.string().optional()
+});
+function providerHitsResponseSchema() {
+  return z5.object({
+    hits: z5.array(ingestedImageHitSchema),
+    ingested: z5.array(autoIngestItemSchema)
+  });
+}
+var imagesGetRequestSchema = z5.object({ id: z5.string().min(1, "Missing id parameter") });
+var imagesSearchRequestSchema = z5.object({
+  query: z5.string().min(1),
+  limit: z5.coerce.number().int().positive().max(100).optional(),
+  aspectRatio: z5.string().optional(),
+  tags: z5.array(z5.string()).optional(),
+  source: z5.string().optional(),
+  externalUrlHost: z5.string().optional()
+});
+var imageSearchResultSchema = z5.object({
+  _id: z5.string(),
+  imageUrl: z5.string(),
+  name: z5.string(),
+  description: z5.string(),
+  tags: z5.array(z5.string()),
+  width: z5.number().optional(),
+  height: z5.number().optional(),
+  aspectRatio: z5.number().optional(),
+  dominantColor: z5.string().optional(),
+  imagePalette: z5.array(z5.string()).optional(),
+  source: z5.string(),
+  externalUrl: z5.string().optional(),
+  score: z5.number()
+});
+var imagesSearchResponseSchema = z5.array(imageSearchResultSchema);
+var imagesUploadRequestSchema = z5.object({
+  base64: z5.string().min(1),
+  contentType: z5.string().min(1),
+  source: z5.string().optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesUploadResponseSchema = z5.object({ imageId: z5.string() });
+var imagesDeleteRequestSchema = z5.object({ id: z5.string().min(1, "Missing image ID") });
+var imagesDeleteResponseSchema = z5.object({ ok: z5.literal(true) });
+var imagesUpscaleRequestSchema = z5.object({ imageId: z5.string().min(1, "Missing image ID") });
+var imagesUpscaleResponseSchema = z5.object({
+  imageId: z5.string(),
+  status: z5.literal("processing")
+});
+var IMAGES_FIND_SOURCES = ["library", "magnific", "google", "iconify", "giphy", "pinterest"];
+var imagesFindRequestSchema = z5.object({
+  query: z5.string().min(1),
+  sources: z5.array(z5.enum(IMAGES_FIND_SOURCES)).optional(),
+  limit: z5.coerce.number().int().positive().max(50).optional(),
+  fallback: z5.boolean().optional(),
+  threshold: z5.number().min(0).max(1).optional(),
+  autoIngest: z5.coerce.number().int().min(0).max(20).optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesFindResponseSchema = z5.object({
+  groups: z5.object({
+    library: z5.array(imageHitSchema),
+    external: z5.array(ingestedImageHitSchema)
+  }),
+  meta: z5.object({
+    counts: z5.record(z5.string(), z5.number()),
+    errors: z5.array(z5.object({ source: imageHitSourceSchema, message: z5.string() }))
+  }),
+  ingested: z5.array(autoIngestItemSchema)
+});
+var imagesStockRequestSchema = z5.object({
+  query: z5.string().min(1),
+  orientation: z5.enum(["landscape", "portrait", "square", "panoramic"]).optional(),
+  contentType: z5.enum(["photo", "vector", "psd"]).optional(),
+  license: z5.enum(["freemium", "premium"]).optional(),
+  color: z5.string().optional(),
+  aiGenerated: z5.enum(["exclude", "only"]).optional(),
+  people: z5.enum(["include", "exclude", "only"]).optional(),
+  order: z5.enum(["relevance", "recent"]).optional(),
+  limit: z5.coerce.number().int().positive().max(50).optional(),
+  page: z5.coerce.number().int().positive().optional(),
+  autoIngest: z5.coerce.number().int().min(0).max(20).optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesStockResponseSchema = providerHitsResponseSchema();
+var imagesGoogleRequestSchema = z5.object({
+  query: z5.string().min(1),
+  type: z5.string().optional(),
+  size: z5.string().optional(),
+  color: z5.string().optional(),
+  safe: z5.enum(["off", "active"]).optional(),
+  limit: z5.coerce.number().int().positive().max(50).optional(),
+  autoIngest: z5.coerce.number().int().min(0).max(20).optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesGoogleResponseSchema = providerHitsResponseSchema();
+var imagesPinterestRequestSchema = z5.object({
+  query: z5.string().min(1),
+  limit: z5.coerce.number().int().positive().max(20).optional(),
+  autoIngest: z5.coerce.number().int().min(0).max(20).optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesPinterestResponseSchema = providerHitsResponseSchema();
+var rgbTriple = z5.tuple([
+  z5.number().int().min(0).max(255),
+  z5.number().int().min(0).max(255),
+  z5.number().int().min(0).max(255)
+]);
+var imageGenerateModelSchema = z5.enum([
+  "openai/gpt-5.4-image-2",
+  "google/gemini-3.5-flash",
+  "google/gemini-3.1-flash-image-preview",
+  "google/gemini-3-pro-image-preview",
+  "recraft/recraft-v4.1-pro-vector"
+]);
+var imagesGenerateRequestSchema = z5.object({
+  prompt: z5.string().min(1),
+  model: imageGenerateModelSchema.optional(),
+  // Aspect ratio + size are validated loosely as strings; the per-model enum
+  // lives in canvas-contract and OpenRouter rejects unsupported combinations.
+  aspectRatio: z5.string().optional(),
+  imageSize: z5.string().optional(),
+  // Recraft v4.1 Pro Vector levers (ignored by other models).
+  strength: z5.coerce.number().min(0).max(1).optional(),
+  rgbColors: z5.array(rgbTriple).optional(),
+  backgroundRgbColor: rgbTriple.optional(),
+  // Public image URLs used as visual references (multi-reference, in order).
+  referenceUrls: z5.array(z5.string().url()).optional(),
+  descriptionContext: z5.string().optional()
+});
+var generatedImageSchema = z5.object({
+  imageId: z5.string(),
+  deduped: z5.boolean(),
+  imageUrl: z5.string(),
+  width: z5.number().optional(),
+  height: z5.number().optional()
+});
+var imagesGenerateResponseSchema = z5.object({
+  model: z5.string(),
+  costUsd: z5.number(),
+  images: z5.array(generatedImageSchema)
+});
+var imagesLogoRequestSchema = z5.object({
+  domain: z5.string().min(1),
+  variant: z5.enum(["icon", "logo", "symbol"]).optional(),
+  autoIngest: z5.coerce.number().int().min(0).max(5).optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesLogoResponseSchema = providerHitsResponseSchema();
+var imagesIconRequestSchema = z5.object({
+  name: z5.string().min(1),
+  set: z5.string().optional(),
+  color: z5.string().optional(),
+  width: z5.coerce.number().int().positive().optional(),
+  autoIngest: z5.coerce.number().int().min(0).max(20).optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesIconResponseSchema = providerHitsResponseSchema();
+var imagesExtractRequestSchema = z5.object({
+  url: z5.string().url(),
+  waitFor: z5.coerce.number().int().min(0).max(3e4).optional(),
+  limit: z5.coerce.number().int().positive().max(50).optional(),
+  autoIngest: z5.coerce.number().int().min(0).max(20).optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesExtractResponseSchema = providerHitsResponseSchema();
+var imagesScreenshotRequestSchema = z5.object({
+  url: z5.string().url(),
+  fullPage: z5.boolean().optional(),
+  viewportWidth: z5.coerce.number().int().positive().max(3840).optional(),
+  viewportHeight: z5.coerce.number().int().positive().max(2160).optional(),
+  format: z5.enum(["webp", "png", "jpg"]).optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesScreenshotResponseSchema = providerHitsResponseSchema();
+var imagesGiphyRequestSchema = z5.object({
+  query: z5.string().min(1).optional(),
+  trending: z5.coerce.boolean().optional(),
+  limit: z5.coerce.number().int().positive().max(50).optional(),
+  rating: z5.enum(["g", "pg", "pg-13", "r"]).optional(),
+  lang: z5.string().optional(),
+  autoIngest: z5.coerce.number().int().min(0).max(20).optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesGifResponseSchema = providerHitsResponseSchema();
+var imagesStickerResponseSchema = providerHitsResponseSchema();
+var imagesIngestRequestSchema = z5.object({
+  url: z5.string().url(),
+  // Validate source at the HTTP boundary so unknown values produce the standard
+  // `{ code: "BAD_REQUEST", message }` shape instead of a plain Error from
+  // `assertImageSource` inside the action.
+  source: imageSourceSchema,
+  externalId: z5.string().optional(),
+  externalUrl: z5.string().optional(),
+  descriptionContext: z5.string().optional()
+});
+var imagesIngestResponseSchema = z5.object({
+  imageId: z5.string(),
+  deduped: z5.boolean(),
+  contentHash: z5.string()
+});
+
+// ../api/src/testimonials.ts
+import { z as z6 } from "zod";
+var testimonialSourceTypeSchema = z6.enum(["google", "trustpilot"]);
+var testimonialStatusSchema = z6.enum(["pending", "processing", "ready", "error"]);
+var testimonialSentimentSchema = z6.enum(["positive", "neutral", "negative"]);
+var testimonialDocSchema = z6.object({
+  _id: z6.string(),
+  _creationTime: z6.number(),
+  companyId: z6.string(),
+  sourceId: z6.string(),
+  sourceType: testimonialSourceTypeSchema,
+  reviewText: z6.string(),
+  reviewTitle: z6.string().optional(),
+  searchText: z6.string().optional(),
+  reviewerName: z6.string().optional(),
+  reviewerImageUrl: z6.string().optional(),
+  reviewerImageId: z6.string().optional(),
+  reviewerLocation: z6.string().optional(),
+  rating: z6.number().optional(),
+  reviewDate: z6.number().optional(),
+  ownerAnswer: z6.string().optional(),
+  mediaUrls: z6.array(z6.string()).optional(),
+  imageIds: z6.array(z6.string()).optional(),
+  videoIds: z6.array(z6.string()).optional(),
+  sourceUrl: z6.string().optional(),
+  rawData: z6.unknown().optional(),
+  tags: z6.array(z6.string()),
+  highlight: z6.string().optional(),
+  language: z6.string().optional(),
+  summary: z6.string().optional(),
+  sentiment: testimonialSentimentSchema.optional(),
+  textEmbedding: z6.array(z6.number()).optional(),
+  externalId: z6.string().optional(),
+  contentHash: z6.string().optional(),
+  status: testimonialStatusSchema,
+  errorMessage: z6.string().optional(),
+  createdAt: z6.number(),
+  updatedAt: z6.number()
+});
+var testimonialsListRequestSchema = z6.object({
+  source: testimonialSourceTypeSchema.optional(),
+  rating_min: z6.coerce.number().int().min(1).max(5).optional(),
+  rating_max: z6.coerce.number().int().min(1).max(5).optional(),
+  tags: z6.string().transform((s) => s.split(",").filter(Boolean)).optional(),
+  status: testimonialStatusSchema.optional(),
+  sentiment: testimonialSentimentSchema.optional(),
+  language: z6.string().min(2).max(5).optional(),
+  limit: z6.coerce.number().int().positive().max(200).optional()
+});
+var testimonialsListResponseSchema = z6.array(testimonialDocSchema);
+var testimonialsGetRequestSchema = z6.object({ id: z6.string().min(1, "Missing id parameter") });
+var testimonialsSearchRequestSchema = z6.object({
+  query: z6.string().min(1),
+  limit: z6.coerce.number().int().positive().max(100).optional(),
+  source: testimonialSourceTypeSchema.optional(),
+  rating_min: z6.coerce.number().int().min(1).max(5).optional(),
+  rating_max: z6.coerce.number().int().min(1).max(5).optional(),
+  tags: z6.array(z6.string()).optional(),
+  status: testimonialStatusSchema.optional(),
+  sentiment: testimonialSentimentSchema.optional(),
+  language: z6.string().min(2).max(5).optional()
+}).refine(
+  (data) => data.rating_min === void 0 || data.rating_max === void 0 || data.rating_min <= data.rating_max,
+  { message: "rating_min must be less than or equal to rating_max" }
+);
+var testimonialsSearchResponseSchema = z6.array(testimonialDocSchema);
+var testimonialsOutscraperWebhookResponseSchema = z6.object({
+  ok: z6.literal(true),
+  note: z6.string().optional()
+});
+
+// ../api/src/videos.ts
+import { z as z7 } from "zod";
+var videoStatusSchema = z7.enum(["uploading", "uploaded", "processing", "ready", "error"]);
+var videoTranscriptSegmentSchema = z7.object({
+  text: z7.string(),
+  startSecond: z7.number(),
+  endSecond: z7.number()
+});
+var videoSceneSchema = z7.object({
+  title: z7.string(),
+  description: z7.string(),
+  startSecond: z7.number(),
+  endSecond: z7.number(),
+  thumbnailTime: z7.number()
+});
+var videoDocSchema = z7.object({
+  _id: z7.string(),
+  _creationTime: z7.number(),
+  companyId: z7.string(),
+  muxAssetId: z7.string(),
+  muxPlaybackId: z7.string(),
+  muxUploadId: z7.string(),
+  name: z7.string(),
+  description: z7.string(),
+  tags: z7.array(z7.string()),
+  source: z7.string(),
+  externalId: z7.string().optional(),
+  sourceId: z7.string().optional(),
+  width: z7.number().optional(),
+  height: z7.number().optional(),
+  aspectRatio: z7.number().optional(),
+  duration: z7.number().optional(),
+  transcript: z7.string().optional(),
+  transcriptSegments: z7.array(videoTranscriptSegmentSchema).optional(),
+  scenes: z7.array(videoSceneSchema).optional(),
+  descriptionEmbedding: z7.array(z7.number()).optional(),
+  searchText: z7.string().optional(),
+  status: videoStatusSchema,
+  errorMessage: z7.string().optional(),
+  createdAt: z7.number(),
+  updatedAt: z7.number(),
+  thumbnailUrl: z7.string()
+});
+var videosWebhookResponseSchema = z7.object({ ok: z7.literal(true) });
+var videosGetRequestSchema = z7.object({ id: z7.string().min(1, "Missing id parameter") });
+var videosSearchRequestSchema = z7.object({
+  query: z7.string().min(1),
+  limit: z7.coerce.number().int().positive().max(100).optional(),
+  tags: z7.array(z7.string()).optional()
+});
+var videoSearchResultSchema = z7.object({
+  _id: z7.string(),
+  thumbnailUrl: z7.string(),
+  name: z7.string(),
+  description: z7.string(),
+  tags: z7.array(z7.string()),
+  status: z7.string(),
+  duration: z7.number().optional(),
+  muxPlaybackId: z7.string(),
+  createdAt: z7.number()
+});
+var videosSearchResponseSchema = z7.array(videoSearchResultSchema);
+var videosUploadResponseSchema = z7.object({ uploadUrl: z7.string(), videoId: z7.string() });
+var videosDeleteRequestSchema = z7.object({ id: z7.string().min(1, "Missing video ID") });
+var videosDeleteResponseSchema = z7.object({ ok: z7.literal(true) });
+
 // src/commands/actions/complete.ts
 import { defineCommand as defineCommand2 } from "citty";
 registerSchema({
@@ -1762,7 +2746,7 @@ Examples:
 });
 
 // src/commands/ads/index.ts
-import { defineCommand as defineCommand78 } from "citty";
+import { defineCommand as defineCommand80 } from "citty";
 
 // src/commands/ads/google/index.ts
 import { defineCommand as defineCommand29 } from "citty";
@@ -4086,7 +5070,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/index.ts
-import { defineCommand as defineCommand47 } from "citty";
+import { defineCommand as defineCommand49 } from "citty";
 
 // src/commands/ads/linkedin/schemas.ts
 registerSchema({
@@ -4384,6 +5368,293 @@ registerSchema({
     "skip-cache": { type: "boolean", description: "Bypass cache", required: false }
   }
 });
+var writeAccountArgs = {
+  "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N", required: false },
+  "account-urn": { type: "string", description: "Alias for --account-id", required: false }
+};
+registerSchema({
+  command: "ads.linkedin.campaign-groups.create",
+  description: "Stage a new campaign group (staged until publish; review with `baker ads linkedin draft`). Returns a li_temp_* ref that later `campaigns create --group` calls can reference.",
+  args: {
+    ...writeAccountArgs,
+    name: { type: "string", description: "Name (\u2264100 chars)", required: true },
+    start: { type: "string", description: "Run schedule start (ISO date or epoch ms)", required: true },
+    end: { type: "string", description: "Run schedule end", required: false },
+    "total-budget": { type: "string", description: "Lifetime budget amount", required: false },
+    currency: { type: "string", description: "3-letter currency code (required with money flags)", required: false },
+    status: { type: "string", description: "DRAFT|ACTIVE|PAUSED (default DRAFT)", required: false },
+    file: { type: "string", description: "JSON payload file; flags override file keys", required: false }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.campaign-groups.update",
+  description: "Stage changes to an existing campaign group (name, schedule, budget, status). Captures a before-snapshot for the dashboard diff. Applies on chat publish.",
+  args: {
+    id: { type: "positional", description: "Campaign group id or URN", required: true },
+    ...writeAccountArgs,
+    name: { type: "string", description: "New name", required: false },
+    start: { type: "string", description: "New schedule start", required: false },
+    end: { type: "string", description: "New schedule end", required: false },
+    "total-budget": { type: "string", description: "New lifetime budget", required: false },
+    currency: { type: "string", description: "3-letter currency code", required: false },
+    status: { type: "string", description: "ACTIVE|PAUSED|ARCHIVED", required: false },
+    file: { type: "string", description: "JSON file with fields to change", required: false }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.campaigns.create",
+  description: "Stage a new campaign. --group accepts a real id/URN or a li_temp_* ref staged earlier in this chat. Targeting goes in --targeting-file as LinkedIn criteria: {include:{and:[{or:{'urn:li:adTargetingFacet:locations':['urn:li:geo:\u2026']}}]}} \u2014 find facet values with `baker ads linkedin facets values`. Playbook defaults: manual bid (--bid), audience expansion off, LAN off. Staged until publish.",
+  args: {
+    ...writeAccountArgs,
+    name: { type: "string", description: "Name (\u2264255 chars)", required: true },
+    group: { type: "string", description: "Campaign group id/URN or li_temp_* ref", required: true },
+    type: { type: "string", description: "SPONSORED_UPDATES|TEXT_AD|SPONSORED_INMAILS|DYNAMIC", required: true },
+    objective: { type: "string", description: "LEAD_GENERATION|WEBSITE_VISIT|BRAND_AWARENESS|\u2026", required: false },
+    "cost-type": { type: "string", description: "CPC|CPM|CPV", required: true },
+    bid: { type: "string", description: "Manual bid amount (unitCost)", required: false },
+    "daily-budget": { type: "string", description: "Daily budget amount", required: false },
+    "total-budget": { type: "string", description: "Lifetime budget amount", required: false },
+    currency: { type: "string", description: "3-letter currency code (required with money flags)", required: false },
+    start: { type: "string", description: "Run schedule start", required: false },
+    end: { type: "string", description: "Run schedule end", required: false },
+    locale: { type: "string", description: "Profile locale like en_US (default en_US)", required: false },
+    "targeting-file": { type: "string", description: "JSON file with targetingCriteria", required: true },
+    "audience-expansion": { type: "string", description: "on|off (playbook: off; default off)", required: false },
+    lan: {
+      type: "string",
+      description: "LinkedIn Audience Network on|off (playbook: off; default off)",
+      required: false
+    },
+    ctv: { type: "string", description: "Connected TV on|off (default off)", required: false },
+    "creative-selection": { type: "string", description: "OPTIMIZED|ROUND_ROBIN", required: false },
+    "associated-entity": { type: "string", description: "Organization URN", required: false },
+    status: { type: "string", description: "DRAFT|ACTIVE|PAUSED (default DRAFT)", required: false },
+    file: { type: "string", description: "JSON payload file; flags override file keys", required: false }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.campaigns.update",
+  description: "Stage changes to an existing campaign \u2014 budget, bid, targeting, schedule, flags, status. Only pass what changes; a before-snapshot powers the dashboard diff. Applies on chat publish.",
+  args: {
+    id: { type: "positional", description: "Campaign id or URN", required: true },
+    ...writeAccountArgs,
+    name: { type: "string", description: "New name", required: false },
+    objective: { type: "string", description: "New objective", required: false },
+    bid: { type: "string", description: "New manual bid", required: false },
+    "daily-budget": { type: "string", description: "New daily budget", required: false },
+    "total-budget": { type: "string", description: "New lifetime budget", required: false },
+    currency: { type: "string", description: "3-letter currency code", required: false },
+    start: { type: "string", description: "New schedule start", required: false },
+    end: { type: "string", description: "New schedule end", required: false },
+    "targeting-file": { type: "string", description: "JSON file with replacement targetingCriteria", required: false },
+    "audience-expansion": { type: "string", description: "on|off", required: false },
+    lan: { type: "string", description: "on|off", required: false },
+    ctv: { type: "string", description: "on|off", required: false },
+    "creative-selection": { type: "string", description: "OPTIMIZED|ROUND_ROBIN", required: false },
+    status: { type: "string", description: "ACTIVE|PAUSED|ARCHIVED", required: false },
+    file: { type: "string", description: "JSON file with fields to change", required: false }
+  }
+});
+var statusSugarArgs = {
+  id: { type: "positional", description: "Entity id or URN", required: true },
+  ...writeAccountArgs
+};
+registerSchema({
+  command: "ads.linkedin.campaigns.pause",
+  description: "Stage pausing a campaign (status \u2192 PAUSED on publish).",
+  args: statusSugarArgs
+});
+registerSchema({
+  command: "ads.linkedin.campaigns.resume",
+  description: "Stage resuming a paused campaign (status \u2192 ACTIVE on publish).",
+  args: statusSugarArgs
+});
+registerSchema({
+  command: "ads.linkedin.campaigns.archive",
+  description: "Stage archiving a campaign (status \u2192 ARCHIVED on publish).",
+  args: statusSugarArgs
+});
+registerSchema({
+  command: "ads.linkedin.campaign-groups.pause",
+  description: "Stage pausing a campaign group.",
+  args: statusSugarArgs
+});
+registerSchema({
+  command: "ads.linkedin.campaign-groups.resume",
+  description: "Stage resuming a campaign group.",
+  args: statusSugarArgs
+});
+registerSchema({
+  command: "ads.linkedin.creatives.pause",
+  description: "Stage pausing a creative (intendedStatus \u2192 PAUSED on publish). Playbook early-kill rule: >30 impressions with 0 clicks.",
+  args: statusSugarArgs
+});
+registerSchema({
+  command: "ads.linkedin.creatives.resume",
+  description: "Stage resuming a paused creative.",
+  args: statusSugarArgs
+});
+var duplicateArgs = {
+  id: { type: "positional", description: "Source id or URN", required: true },
+  ...writeAccountArgs,
+  name: { type: "string", description: "Name for the copy", required: false },
+  file: { type: "string", description: "JSON file with field overrides for the copy", required: false }
+};
+registerSchema({
+  command: "ads.linkedin.campaigns.duplicate",
+  description: "Stage a copy of an existing campaign as a new DRAFT create (playbook: duplicate, never link-to-original). Reads the source at stage time; override fields via --name/--file.",
+  args: duplicateArgs
+});
+registerSchema({
+  command: "ads.linkedin.campaign-groups.duplicate",
+  description: "Stage a copy of an existing campaign group as a new DRAFT create.",
+  args: duplicateArgs
+});
+registerSchema({
+  command: "ads.linkedin.creatives.duplicate",
+  description: "Stage a copy of an existing creative by re-sponsoring its underlying post into a new DRAFT creative (--file can override the target campaign).",
+  args: duplicateArgs
+});
+registerSchema({
+  command: "ads.linkedin.creatives.create",
+  description: "Stage a new creative (ad). Formats: image|video|text|spotlight|follower|document|carousel|conversation|tla|jobs. Media: --image-id/--video-id reference the Baker library (`baker images`/`baker videos`) and upload to LinkedIn at publish; --image-urn/--video-urn reference media already on LinkedIn. Limits: headline \u226470 (text ads \u226425), intro soft-truncates at 600 chars, landing URL must be https. Complex formats take --file with the full content object. Staged until publish.",
+  args: {
+    ...writeAccountArgs,
+    campaign: { type: "string", description: "Campaign id/URN or li_temp_* ref", required: true },
+    format: {
+      type: "string",
+      description: "image|video|text|spotlight|follower|document|carousel|conversation|tla|jobs",
+      required: true
+    },
+    "image-id": { type: "string", description: "Baker image library id", required: false },
+    "image-urn": { type: "string", description: "Existing urn:li:image:*", required: false },
+    "video-id": { type: "string", description: "Baker video library id", required: false },
+    "video-urn": { type: "string", description: "Existing urn:li:video:*", required: false },
+    "logo-image-id": { type: "string", description: "Baker image id for the logo", required: false },
+    intro: { type: "string", description: "Commentary / intro text", required: false },
+    headline: { type: "string", description: "Headline", required: false },
+    description: { type: "string", description: "Description (text/spotlight)", required: false },
+    "landing-url": { type: "string", description: "https destination URL", required: false },
+    cta: { type: "string", description: "LEARN_MORE|REQUEST_DEMO|SIGN_UP|REGISTER|DOWNLOAD|\u2026", required: false },
+    "cta-label": { type: "string", description: "Spotlight CTA label (\u226418 chars)", required: false },
+    "post-urn": { type: "string", description: "TLA: post to sponsor (urn:li:share|ugcPost:*)", required: false },
+    "intended-status": { type: "string", description: "DRAFT|ACTIVE|PAUSED (default DRAFT)", required: false },
+    title: { type: "string", description: "Media title", required: false },
+    file: { type: "string", description: "JSON file with the full content object", required: false }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.creatives.update",
+  description: "Stage changes to an existing creative (intendedStatus, name). Applies on chat publish.",
+  args: {
+    id: { type: "positional", description: "Creative id or URN", required: true },
+    ...writeAccountArgs,
+    "intended-status": { type: "string", description: "ACTIVE|PAUSED|ARCHIVED|DRAFT", required: false },
+    name: { type: "string", description: "New creative name", required: false },
+    file: { type: "string", description: "JSON file with fields to change", required: false }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.audiences.create",
+  description: "Stage a new matched audience. company-list/user-list take --list-file (CSV with header; companyName,domain for companies; email column is SHA-256 hashed locally). LinkedIn needs 300+ MATCHED members to serve \u2014 upload well above that. retargeting/engagement configs go in --file. Staged until publish.",
+  args: {
+    ...writeAccountArgs,
+    name: { type: "string", description: "Audience name (\u2264100 chars)", required: true },
+    type: { type: "string", description: "company-list|user-list|retargeting|engagement", required: true },
+    "list-file": { type: "string", description: "CSV file with the list rows", required: false },
+    file: { type: "string", description: "JSON raw source config for retargeting/engagement", required: false }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.audiences.upload",
+  description: "Stage adding rows to an existing audience segment (or a li_temp_* segment staged in this chat). Same CSV rules as audiences.create.",
+  args: {
+    id: { type: "positional", description: "Segment URN/id or li_temp_* ref", required: true },
+    ...writeAccountArgs,
+    "list-file": { type: "string", description: "CSV file with the rows to add", required: true }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.conversions.create",
+  description: "Stage a new conversion rule. Playbook defaults: --post-click-window 30 --view-window 7, counting ONE_TIME_EACH_MEMBER for leads. Staged until publish.",
+  args: {
+    ...writeAccountArgs,
+    name: { type: "string", description: "Rule name", required: true },
+    type: {
+      type: "string",
+      description: "LEAD|SIGN_UP|DOWNLOAD|PURCHASE|KEY_PAGE_VIEW|ADD_TO_CART|INSTALL|OTHER",
+      required: true
+    },
+    method: { type: "string", description: "INSIGHT_TAG|CONVERSIONS_API", required: true },
+    "post-click-window": { type: "string", description: "1|7|30|90 days", required: false },
+    "view-window": { type: "string", description: "1|7|30 days", required: false },
+    "attribution-type": {
+      type: "string",
+      description: "LAST_TOUCH_BY_CAMPAIGN|LAST_TOUCH_BY_CONVERSION",
+      required: false
+    },
+    "associate-all-campaigns": {
+      type: "boolean",
+      description: "Auto-associate with active campaigns",
+      required: false
+    },
+    file: { type: "string", description: "JSON payload file (e.g. urlMatchRuleExpression)", required: false }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.conversions.update",
+  description: "Stage changes to a conversion rule (windows, attribution, enabled, name). Applies on chat publish.",
+  args: {
+    id: { type: "positional", description: "Conversion rule id or URN", required: true },
+    ...writeAccountArgs,
+    name: { type: "string", description: "New name", required: false },
+    "post-click-window": { type: "string", description: "1|7|30|90 days", required: false },
+    "view-window": { type: "string", description: "1|7|30 days", required: false },
+    "attribution-type": { type: "string", description: "New attribution type", required: false },
+    enabled: { type: "string", description: "on|off", required: false },
+    file: { type: "string", description: "JSON file with fields to change", required: false }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.lead-forms.create",
+  description: "Stage a new Lead Gen Form from a JSON file: {name, headline \u226460, description? \u2264160, privacyPolicyUrl, questions[] \u226412 (playbook: \u22644 for completion), thankYou?, legalDisclaimer?}. Staged until publish.",
+  args: {
+    ...writeAccountArgs,
+    file: { type: "string", description: "JSON form definition file", required: true },
+    name: { type: "string", description: "Override the form name", required: false }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.lead-forms.update",
+  description: "Stage changes to a Lead Gen Form from a JSON file. Applies on chat publish.",
+  args: {
+    id: { type: "positional", description: "Lead form id or URN", required: true },
+    ...writeAccountArgs,
+    file: { type: "string", description: "JSON file with the fields to change", required: true },
+    name: { type: "string", description: "New form name", required: false }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.draft.list",
+  description: "Show every LinkedIn write op staged in this chat: ref, summary, dependencies, warnings, mode (simulated = publish will NOT hit LinkedIn), and post-publish results (applied/simulated/failed/skipped). Ops are invisible to the read commands until publish \u2014 check here before finishing.",
+  args: {}
+});
+registerSchema({
+  command: "ads.linkedin.draft.remove",
+  description: "Drop one staged LinkedIn op from this chat's draft. Removing a create cascades to every op that depends on it (a campaign removal drops its staged creatives).",
+  args: {
+    ref: {
+      type: "positional",
+      description: "Op ref (li_temp_* for creates, target id/URN for updates)",
+      required: true
+    }
+  }
+});
+registerSchema({
+  command: "ads.linkedin.draft.clear",
+  description: "Discard ALL staged LinkedIn ops in this chat's draft. Nothing applies on publish.",
+  args: {}
+});
 
 // src/commands/ads/linkedin/account.ts
 import { defineCommand as defineCommand30 } from "citty";
@@ -5238,18 +6509,742 @@ Examples:
 });
 
 // src/commands/ads/linkedin/campaign-groups.ts
+import { defineCommand as defineCommand37 } from "citty";
+
+// src/commands/ads/linkedin/write-commands.ts
 import { defineCommand as defineCommand36 } from "citty";
-var campaignGroupsCommand = defineCommand36({
+
+// src/commands/ads/linkedin/write-shared.ts
+import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync6 } from "fs";
+function bareAccountId(args) {
+  const raw = resolveAccountIdArg(args);
+  return raw.replace(/^urn:li:sponsoredAccount:/, "").replace(/^sponsoredAccount:/, "");
+}
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function loadJsonFileArg(path11) {
+  if (typeof path11 !== "string" || path11.length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync6(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 parseMoneyFlag(amount, currency, flag) {
+  if (amount === void 0 || amount === null || amount === "") {
+    return void 0;
+  }
+  if (typeof currency !== "string" || currency.length !== 3) {
+    failWriteValidation(`${flag} needs --currency (3-letter code matching the ad account, e.g. EUR)`);
+  }
+  return { amount: String(amount), currencyCode: currency.toUpperCase() };
+}
+function parseDateFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const raw = String(value);
+  if (/^\d{10,}$/.test(raw)) {
+    return Number(raw);
+  }
+  const parsed = Date.parse(raw);
+  if (Number.isNaN(parsed)) {
+    failWriteValidation(`${flag} must be an ISO date (2026-07-10) or epoch milliseconds`);
+  }
+  return parsed;
+}
+function parseOnOffFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const raw = String(value).toLowerCase();
+  if (raw === "on" || raw === "true") {
+    return true;
+  }
+  if (raw === "off" || raw === "false") {
+    return false;
+  }
+  failWriteValidation(`${flag} must be on|off`);
+}
+function parseLocaleFlag(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const match = /^([a-z]{2})[_-]([A-Za-z]{2})$/.exec(String(value));
+  if (!match) {
+    failWriteValidation("--locale must look like en_US (language_COUNTRY)");
+  }
+  return { language: match[1], country: match[2].toUpperCase() };
+}
+function loadTargetingFileArg(path11) {
+  if (typeof path11 !== "string" || path11.length === 0) {
+    return void 0;
+  }
+  const parsed = loadJsonFileArg(path11);
+  const criteria = parsed.targetingCriteria ?? parsed;
+  if (!criteria.include) {
+    failWriteValidation(
+      `${path11} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+    );
+  }
+  return criteria;
+}
+function sha256Lower(value) {
+  return createHash2("sha256").update(value.trim().toLowerCase()).digest("hex");
+}
+function parseCsvLine(line) {
+  const cells = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (char === '"') {
+        inQuotes = false;
+      } else {
+        current += char;
+      }
+    } else if (char === '"') {
+      inQuotes = true;
+    } else if (char === ",") {
+      cells.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  cells.push(current);
+  return cells.map((cell) => cell.trim());
+}
+function parseListFileArg(path11, maxRows) {
+  if (typeof path11 !== "string" || path11.length === 0) {
+    return void 0;
+  }
+  const raw = readFileSync6(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`);
+  }
+  const columns = parseCsvLine(lines[0]).map((column) => column.trim());
+  const rows = [];
+  for (const line of lines.slice(1)) {
+    const cells = parseCsvLine(line);
+    const row = {};
+    columns.forEach((column, index) => {
+      const value = cells[index] ?? "";
+      if (!value) {
+        return;
+      }
+      row[column] = column.toLowerCase() === "email" ? sha256Lower(value) : value;
+    });
+    if (Object.keys(row).length > 0) {
+      rows.push(row);
+    }
+  }
+  if (rows.length > maxRows) {
+    failWriteValidation(`${path11} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+  }
+  return { columns, rows };
+}
+async function stageOp(raw) {
+  const preflight = linkedinDraftOpInputSchema.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((field) => field.path ? `${field.path}: ${field.message}` : field.message).join("; "),
+        fields
+      }
+    });
+    process.exit(1);
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/linkedin/draft/stage", {
+      chatId,
+      op: preflight.data
+    });
+    writeJsonEnvelope(response);
+  } catch (err) {
+    handleLinkedinError(err);
+  }
+}
+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) {
+  const target = args.id ?? args.target;
+  if (typeof target !== "string" || target.length === 0) {
+    failWriteValidation(`pass the ${entity} id or URN as the positional argument`);
+  }
+  return target;
+}
+
+// src/commands/ads/linkedin/write-commands.ts
+var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads linkedin draft`.";
+var accountArgs = {
+  "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+  "account-urn": { type: "string", description: "Alias for --account-id" }
+};
+function runScheduleFromFlags(args) {
+  const start = parseDateFlag(args.start, "--start");
+  const end = parseDateFlag(args.end, "--end");
+  if (start === void 0 && end === void 0) {
+    return void 0;
+  }
+  return { ...start !== void 0 ? { start } : {}, ...end !== void 0 ? { end } : {} };
+}
+var campaignGroupsCreateCommand = defineCommand36({
+  meta: {
+    name: "create",
+    description: `Stage a new campaign group. ${STAGED_NOTE}
+Example: baker ads linkedin campaign-groups create --name "Q3 ABM" --start 2026-07-10 --total-budget 5000 --currency EUR`
+  },
+  args: {
+    ...accountArgs,
+    name: { type: "string", description: "Campaign group name (\u2264100 chars)" },
+    start: { type: "string", description: "Run schedule start (ISO date or epoch ms)" },
+    end: { type: "string", description: "Run schedule end" },
+    "total-budget": { type: "string", description: "Lifetime budget amount" },
+    currency: { type: "string", description: "3-letter currency code (required with money flags)" },
+    status: { type: "string", description: "DRAFT|ACTIVE|PAUSED (default DRAFT)" },
+    file: { type: "string", description: "JSON file with the full payload; flags override file keys" }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const payload = mergePayload(loadJsonFileArg(args.file), {
+      name: args.name,
+      runSchedule: runScheduleFromFlags(args),
+      totalBudget: parseMoneyFlag(args["total-budget"], args.currency, "--total-budget"),
+      status: args.status ? String(args.status).toUpperCase() : void 0
+    });
+    await stageOp({ kind: "campaignGroup.create", accountId, payload });
+  }
+});
+var campaignGroupsUpdateCommand = defineCommand36({
+  meta: {
+    name: "update",
+    description: `Stage changes to an existing campaign group. ${STAGED_NOTE}
+Example: baker ads linkedin campaign-groups update 635137195 --total-budget 8000 --currency EUR`
+  },
+  args: {
+    id: { type: "positional", description: "Campaign group id or URN", required: true },
+    ...accountArgs,
+    name: { type: "string", description: "New name" },
+    start: { type: "string", description: "New run schedule start" },
+    end: { type: "string", description: "New run schedule end" },
+    "total-budget": { type: "string", description: "New lifetime budget" },
+    currency: { type: "string", description: "3-letter currency code" },
+    status: { type: "string", description: "ACTIVE|PAUSED|ARCHIVED|\u2026" },
+    file: { type: "string", description: "JSON file with fields to change" }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const payload = mergePayload(loadJsonFileArg(args.file), {
+      name: args.name,
+      runSchedule: runScheduleFromFlags(args),
+      totalBudget: parseMoneyFlag(args["total-budget"], args.currency, "--total-budget"),
+      status: args.status ? String(args.status).toUpperCase() : void 0
+    });
+    await stageOp({
+      kind: "campaignGroup.update",
+      accountId,
+      target: requireTarget(args, "campaign group"),
+      payload
+    });
+  }
+});
+function campaignPayloadFromFlags(args) {
+  return {
+    name: args.name,
+    campaignGroup: args.group,
+    type: args.type ? String(args.type).toUpperCase() : void 0,
+    objectiveType: args.objective ? String(args.objective).toUpperCase() : void 0,
+    costType: args["cost-type"] ? String(args["cost-type"]).toUpperCase() : void 0,
+    unitCost: parseMoneyFlag(args.bid, args.currency, "--bid"),
+    dailyBudget: parseMoneyFlag(args["daily-budget"], args.currency, "--daily-budget"),
+    totalBudget: parseMoneyFlag(args["total-budget"], args.currency, "--total-budget"),
+    runSchedule: runScheduleFromFlags(args),
+    locale: parseLocaleFlag(args.locale),
+    targetingCriteria: loadTargetingFileArg(args["targeting-file"]),
+    audienceExpansionEnabled: parseOnOffFlag(args["audience-expansion"], "--audience-expansion"),
+    offsiteDeliveryEnabled: parseOnOffFlag(args.lan, "--lan"),
+    connectedTelevisionOnly: parseOnOffFlag(args.ctv, "--ctv"),
+    creativeSelection: args["creative-selection"] ? String(args["creative-selection"]).toUpperCase() : void 0,
+    associatedEntity: args["associated-entity"],
+    status: args.status ? String(args.status).toUpperCase() : void 0
+  };
+}
+var campaignFlagArgs = {
+  ...accountArgs,
+  name: { type: "string", description: "Campaign name (\u2264255 chars)" },
+  group: { type: "string", description: "Campaign group id/URN, or li_temp_* ref staged in this chat" },
+  type: { type: "string", description: "SPONSORED_UPDATES|TEXT_AD|SPONSORED_INMAILS|DYNAMIC" },
+  objective: { type: "string", description: "e.g. LEAD_GENERATION, WEBSITE_VISIT, BRAND_AWARENESS" },
+  "cost-type": { type: "string", description: "CPC|CPM|CPV" },
+  bid: { type: "string", description: "Manual bid (unitCost) \u2014 playbook mandates manual bidding" },
+  "daily-budget": { type: "string", description: "Daily budget amount" },
+  "total-budget": { type: "string", description: "Lifetime budget amount" },
+  currency: { type: "string", description: "3-letter currency code (required with money flags)" },
+  start: { type: "string", description: "Run schedule start (ISO date or epoch ms)" },
+  end: { type: "string", description: "Run schedule end" },
+  locale: { type: "string", description: "Profile locale like en_US" },
+  "targeting-file": { type: "string", description: "JSON file with targetingCriteria (include.and[].or facets)" },
+  "audience-expansion": { type: "string", description: "on|off (playbook: off)" },
+  lan: { type: "string", description: "LinkedIn Audience Network on|off (playbook: off)" },
+  ctv: { type: "string", description: "Connected TV on|off" },
+  "creative-selection": { type: "string", description: "OPTIMIZED|ROUND_ROBIN" },
+  "associated-entity": { type: "string", description: "Organization URN" },
+  status: { type: "string", description: "DRAFT|ACTIVE|PAUSED" },
+  file: { type: "string", description: "JSON file with the full payload; flags override file keys" }
+};
+var campaignsCreateCommand = defineCommand36({
+  meta: {
+    name: "create",
+    description: `Stage a new campaign. ${STAGED_NOTE}
+Targeting goes in --targeting-file (facet URNs). --group accepts a li_temp_* ref from a campaign group staged in this chat.
+Example: baker ads linkedin campaigns create --name "ABM Tier-1" --group li_temp_x1 --objective WEBSITE_VISIT --type SPONSORED_UPDATES --cost-type CPC --bid 8.50 --daily-budget 75 --currency EUR --locale en_US --targeting-file targeting.json`
+  },
+  args: campaignFlagArgs,
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const payload = mergePayload(loadJsonFileArg(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({
+  meta: {
+    name: "update",
+    description: `Stage changes to an existing campaign (budget, bid, targeting, flags, schedule, status). ${STAGED_NOTE}
+Example: baker ads linkedin campaigns update 123456 --daily-budget 100 --currency EUR --audience-expansion off`
+  },
+  args: {
+    id: { type: "positional", description: "Campaign id or URN", required: true },
+    ...campaignFlagArgs
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const flags = campaignPayloadFromFlags(args);
+    flags.campaignGroup = void 0;
+    flags.type = void 0;
+    flags.locale = void 0;
+    flags.associatedEntity = void 0;
+    const payload = mergePayload(loadJsonFileArg(args.file), flags);
+    await stageOp({
+      kind: "campaign.update",
+      accountId,
+      target: requireTarget(args, "campaign"),
+      payload
+    });
+  }
+});
+function statusSugarCommand(entity, kind, name) {
+  const status = name === "pause" ? "PAUSED" : name === "resume" ? "ACTIVE" : "ARCHIVED";
+  return defineCommand36({
+    meta: {
+      name,
+      description: `Stage a status change to ${status}. ${STAGED_NOTE}
+Example: baker ads linkedin ${entity} ${name} 123456`
+    },
+    args: {
+      id: { type: "positional", description: "Entity id or URN", required: true },
+      ...accountArgs
+    },
+    run: async ({ args }) => {
+      await stageStatusChange({
+        kind,
+        accountId: bareAccountId(args),
+        target: requireTarget(args, entity.replace(/-/g, " ").replace(/s$/, "")),
+        status
+      });
+    }
+  });
+}
+var campaignsPauseCommand = statusSugarCommand("campaigns", "campaign.update", "pause");
+var campaignsResumeCommand = statusSugarCommand("campaigns", "campaign.update", "resume");
+var campaignsArchiveCommand = statusSugarCommand("campaigns", "campaign.update", "archive");
+var campaignGroupsPauseCommand = statusSugarCommand("campaign-groups", "campaignGroup.update", "pause");
+var campaignGroupsResumeCommand = statusSugarCommand("campaign-groups", "campaignGroup.update", "resume");
+var creativesPauseCommand = statusSugarCommand("creatives", "creative.update", "pause");
+var creativesResumeCommand = statusSugarCommand("creatives", "creative.update", "resume");
+function duplicateCommand(entity, cliGroup) {
+  return defineCommand36({
+    meta: {
+      name: "duplicate",
+      description: `Stage a copy of an existing ${entity} as a new DRAFT create (playbook: duplicate, never link-to-original). ${STAGED_NOTE}
+Example: baker ads linkedin ${cliGroup} duplicate 123456 --name "New variant"`
+    },
+    args: {
+      id: { type: "positional", description: "Source id or URN", required: true },
+      ...accountArgs,
+      name: { type: "string", description: "Name for the copy" },
+      file: { type: "string", description: "JSON file with field overrides for the copy" }
+    },
+    run: async ({ args }) => {
+      try {
+        const chatId = requireChatId();
+        const overrides = mergePayload(loadJsonFileArg(args.file), { name: args.name });
+        const response = await apiPost(
+          "/api/ads/linkedin/draft/duplicate",
+          {
+            chatId,
+            accountId: bareAccountId(args),
+            entity,
+            sourceId: requireTarget(args, entity),
+            ...Object.keys(overrides).length > 0 ? { overrides } : {}
+          }
+        );
+        writeJsonEnvelope(response);
+      } catch (err) {
+        handleLinkedinError(err);
+      }
+    }
+  });
+}
+var campaignsDuplicateCommand = duplicateCommand("campaign", "campaigns");
+var campaignGroupsDuplicateCommand = duplicateCommand("campaignGroup", "campaign-groups");
+var creativesDuplicateCommand = duplicateCommand("creative", "creatives");
+var CREATIVE_FORMATS = [
+  "image",
+  "video",
+  "text",
+  "spotlight",
+  "follower",
+  "document",
+  "carousel",
+  "conversation",
+  "tla",
+  "jobs"
+];
+var creativesCreateCommand = defineCommand36({
+  meta: {
+    name: "create",
+    description: `Stage a new creative (ad). ${STAGED_NOTE}
+Formats: ${CREATIVE_FORMATS.join("|")}. Media comes from the Baker library (--image-id / --video-id from \`baker images\`/\`baker videos\`) or as LinkedIn URNs. Complex formats (carousel, conversation, jobs) take --file with the full content object.
+Examples:
+  baker ads linkedin creatives create --campaign li_temp_x2 --format image --image-id <bakerImageId> --intro "Meet the platform\u2026" --headline "Book a demo" --landing-url https://example.com/demo --cta REQUEST_DEMO
+  baker ads linkedin creatives create --campaign 123456 --format tla --post-urn urn:li:ugcPost:789`
+  },
+  args: {
+    ...accountArgs,
+    campaign: { type: "string", description: "Campaign id/URN, or li_temp_* ref staged in this chat" },
+    format: { type: "string", description: CREATIVE_FORMATS.join("|") },
+    "image-id": { type: "string", description: "Baker image library id (uploaded to LinkedIn at publish)" },
+    "image-urn": { type: "string", description: "Existing urn:li:image:*" },
+    "video-id": { type: "string", description: "Baker video library id" },
+    "video-urn": { type: "string", description: "Existing urn:li:video:*" },
+    "logo-image-id": { type: "string", description: "Baker image id for logo (text/spotlight/follower/jobs)" },
+    intro: { type: "string", description: "Commentary / intro text (\u2264600 chars before feed truncation)" },
+    headline: { type: "string", description: "Headline (\u226470; text ads \u226425)" },
+    description: { type: "string", description: "Description (text ads \u226475, spotlight \u226470)" },
+    "landing-url": { type: "string", description: "https destination URL" },
+    cta: { type: "string", description: "LEARN_MORE|REQUEST_DEMO|SIGN_UP|REGISTER|DOWNLOAD|\u2026" },
+    "cta-label": { type: "string", description: "Spotlight custom CTA label (\u226418 chars)" },
+    "post-urn": { type: "string", description: "TLA: existing post to sponsor (urn:li:share|ugcPost:*)" },
+    "intended-status": { type: "string", description: "DRAFT|ACTIVE|PAUSED (default DRAFT)" },
+    title: { type: "string", description: "Media title" },
+    file: { type: "string", description: "JSON file with the full content object; flags override" }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    if (!args.campaign) {
+      failWriteValidation("--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("|")}`);
+    }
+    const content = mergePayload(loadJsonFileArg(args.file), {
+      format,
+      commentary: args.intro,
+      imageId: args["image-id"],
+      imageUrn: args["image-urn"],
+      videoId: args["video-id"],
+      videoUrn: args["video-urn"],
+      logoImageId: args["logo-image-id"],
+      headline: args.headline,
+      description: args.description,
+      landingUrl: args["landing-url"],
+      cta: args.cta ? String(args.cta).toUpperCase() : void 0,
+      ctaLabel: args["cta-label"],
+      postUrn: args["post-urn"],
+      mediaTitle: args.title
+    });
+    await stageOp({
+      kind: "creative.create",
+      accountId,
+      payload: {
+        campaign: args.campaign,
+        intendedStatus: args["intended-status"] ? String(args["intended-status"]).toUpperCase() : void 0,
+        content
+      }
+    });
+  }
+});
+var creativesUpdateCommand = defineCommand36({
+  meta: {
+    name: "update",
+    description: `Stage changes to an existing creative. ${STAGED_NOTE}
+Example: baker ads linkedin creatives update urn:li:sponsoredCreative:789 --intended-status PAUSED`
+  },
+  args: {
+    id: { type: "positional", description: "Creative id or URN", required: true },
+    ...accountArgs,
+    "intended-status": { type: "string", description: "ACTIVE|PAUSED|ARCHIVED|DRAFT" },
+    name: { type: "string", description: "New creative name" },
+    file: { type: "string", description: "JSON file with fields to change" }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const payload = mergePayload(loadJsonFileArg(args.file), {
+      intendedStatus: args["intended-status"] ? String(args["intended-status"]).toUpperCase() : void 0,
+      name: args.name
+    });
+    await stageOp({
+      kind: "creative.update",
+      accountId,
+      target: requireTarget(args, "creative"),
+      payload
+    });
+  }
+});
+var AUDIENCE_TYPES2 = ["company-list", "user-list", "retargeting", "engagement"];
+var INLINE_ROWS_MAX = 1e4;
+var audiencesCreateCommand = defineCommand36({
+  meta: {
+    name: "create",
+    description: `Stage a new matched audience. ${STAGED_NOTE}
+List audiences take --list-file (CSV: companyName,domain for companies; email,\u2026 for contacts \u2014 emails are SHA-256 hashed locally). LinkedIn needs 300+ MATCHED members to serve.
+Example: baker ads linkedin audiences create --name "ABM Tier-1" --type company-list --list-file accounts.csv`
+  },
+  args: {
+    ...accountArgs,
+    name: { type: "string", description: "Audience name (\u2264100 chars)" },
+    type: { type: "string", description: AUDIENCE_TYPES2.join("|") },
+    "list-file": { type: "string", description: "CSV file with the list rows (header row required)" },
+    file: { type: "string", description: "JSON file with a raw source config (retargeting/engagement)" }
+  },
+  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;
+    await stageOp({
+      kind: "audience.create",
+      accountId,
+      payload: {
+        name: args.name,
+        audienceType: args.type,
+        ...list ? { listColumns: list.columns, listRows: list.rows } : {},
+        ...raw ? { raw } : {}
+      }
+    });
+  }
+});
+var audiencesUploadCommand = defineCommand36({
+  meta: {
+    name: "upload",
+    description: `Stage a list upload into an existing audience segment. ${STAGED_NOTE}
+Example: baker ads linkedin audiences upload urn:li:dmpSegment:42 --list-file more-accounts.csv`
+  },
+  args: {
+    id: { type: "positional", description: "Segment URN/id, or li_temp_* ref staged in this chat", required: true },
+    ...accountArgs,
+    "list-file": { type: "string", description: "CSV file with the rows to add", required: true }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const list = parseListFileArg(args["list-file"], INLINE_ROWS_MAX);
+    if (!list) {
+      failWriteValidation("--list-file is required");
+    }
+    await stageOp({
+      kind: "audience.uploadList",
+      accountId,
+      payload: {
+        segment: requireTarget(args, "audience segment"),
+        listColumns: list.columns,
+        listRows: list.rows
+      }
+    });
+  }
+});
+var audiencesCommand = defineCommand36({
+  meta: {
+    name: "audiences",
+    description: "Stage LinkedIn matched-audience changes (create lists, upload rows). Staged until publish \u2014 never hits the API directly."
+  },
+  subCommands: {
+    create: audiencesCreateCommand,
+    upload: audiencesUploadCommand
+  }
+});
+var conversionsCreateCommand = defineCommand36({
+  meta: {
+    name: "create",
+    description: `Stage a new conversion rule. ${STAGED_NOTE}
+Example: baker ads linkedin conversions create --name "Demo booked" --type LEAD --method INSIGHT_TAG --post-click-window 30 --view-window 7`
+  },
+  args: {
+    ...accountArgs,
+    name: { type: "string", description: "Conversion rule name" },
+    type: { type: "string", description: "LEAD|SIGN_UP|DOWNLOAD|PURCHASE|KEY_PAGE_VIEW|ADD_TO_CART|INSTALL|OTHER" },
+    method: { type: "string", description: "INSIGHT_TAG|CONVERSIONS_API" },
+    "post-click-window": { type: "string", description: "1|7|30|90 days (playbook default 30)" },
+    "view-window": { type: "string", description: "1|7|30 days (playbook default 7)" },
+    "attribution-type": { type: "string", description: "LAST_TOUCH_BY_CAMPAIGN|LAST_TOUCH_BY_CONVERSION" },
+    "associate-all-campaigns": { type: "boolean", description: "Auto-associate with active campaigns" },
+    file: { type: "string", description: "JSON file with the full payload (e.g. urlMatchRuleExpression)" }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const payload = mergePayload(loadJsonFileArg(args.file), {
+      name: args.name,
+      type: args.type ? String(args.type).toUpperCase() : void 0,
+      conversionMethod: args.method ? String(args.method).toUpperCase() : void 0,
+      postClickAttributionWindowSize: args["post-click-window"] ? Number(args["post-click-window"]) : void 0,
+      viewThroughAttributionWindowSize: args["view-window"] ? Number(args["view-window"]) : void 0,
+      attributionType: args["attribution-type"] ? String(args["attribution-type"]).toUpperCase() : void 0,
+      associateAllCampaigns: args["associate-all-campaigns"] === true ? true : void 0
+    });
+    await stageOp({ kind: "conversion.create", accountId, payload });
+  }
+});
+var conversionsUpdateCommand = defineCommand36({
+  meta: {
+    name: "update",
+    description: `Stage changes to a conversion rule (windows, name, enabled). ${STAGED_NOTE}
+Example: baker ads linkedin conversions update 104988516 --post-click-window 30 --view-window 7`
+  },
+  args: {
+    id: { type: "positional", description: "Conversion rule id or URN", required: true },
+    ...accountArgs,
+    name: { type: "string", description: "New name" },
+    "post-click-window": { type: "string", description: "1|7|30|90 days" },
+    "view-window": { type: "string", description: "1|7|30 days" },
+    "attribution-type": { type: "string", description: "LAST_TOUCH_BY_CAMPAIGN|LAST_TOUCH_BY_CONVERSION" },
+    enabled: { type: "string", description: "on|off" },
+    file: { type: "string", description: "JSON file with fields to change" }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const payload = mergePayload(loadJsonFileArg(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,
+      attributionType: args["attribution-type"] ? String(args["attribution-type"]).toUpperCase() : void 0,
+      enabled: parseOnOffFlag(args.enabled, "--enabled")
+    });
+    await stageOp({
+      kind: "conversion.update",
+      accountId,
+      target: requireTarget(args, "conversion rule"),
+      payload
+    });
+  }
+});
+var leadFormsCreateCommand = defineCommand36({
+  meta: {
+    name: "create",
+    description: `Stage a new Lead Gen Form from a JSON file. ${STAGED_NOTE}
+The file needs: name, headline (\u226460), privacyPolicyUrl, questions[] (\u226412; playbook: \u22644 for completion). Example: baker ads linkedin lead-forms create --file form.json`
+  },
+  args: {
+    ...accountArgs,
+    file: { type: "string", description: "JSON file with the form definition", required: true },
+    name: { type: "string", description: "Override the form name" }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const payload = mergePayload(loadJsonFileArg(args.file), { name: args.name });
+    await stageOp({ kind: "leadForm.create", accountId, payload });
+  }
+});
+var leadFormsUpdateCommand = defineCommand36({
+  meta: {
+    name: "update",
+    description: `Stage changes to a Lead Gen Form from a JSON file. ${STAGED_NOTE}`
+  },
+  args: {
+    id: { type: "positional", description: "Lead form id or URN", required: true },
+    ...accountArgs,
+    file: { type: "string", description: "JSON file with the fields to change", required: true },
+    name: { type: "string", description: "New form name" }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const payload = mergePayload({ raw: loadJsonFileArg(args.file) }, { name: args.name });
+    await stageOp({
+      kind: "leadForm.update",
+      accountId,
+      target: requireTarget(args, "lead form"),
+      payload
+    });
+  }
+});
+var leadFormsCommand = defineCommand36({
+  meta: {
+    name: "lead-forms",
+    description: "Stage LinkedIn Lead Gen Form changes (file-first). Staged until publish \u2014 never hits the API directly."
+  },
+  subCommands: {
+    create: leadFormsCreateCommand,
+    update: leadFormsUpdateCommand
+  }
+});
+
+// src/commands/ads/linkedin/campaign-groups.ts
+var campaignGroupsCommand = defineCommand37({
   meta: {
     name: "campaign-groups",
-    description: `List LinkedIn campaign groups.
+    description: `List LinkedIn campaign groups, or stage writes (create/update/pause/resume/duplicate).
 
 Default: ACTIVE only. Pass --all-statuses to widen, or --statuses ACTIVE,PAUSED to override.
+Write subcommands stage ops on this chat's draft and apply only when the chat is published.
 
 Examples:
   baker ads linkedin campaign-groups --account-id 503001492
   baker ads linkedin campaign-groups --account-id 503001492 --all-statuses
-  baker ads linkedin campaign-groups --account-id 503001492 --statuses ACTIVE,PAUSED --output csv`
+  baker ads linkedin campaign-groups create --name "Q3 ABM" --start 2026-07-10 --total-budget 5000 --currency EUR`
+  },
+  subCommands: {
+    create: campaignGroupsCreateCommand,
+    update: campaignGroupsUpdateCommand,
+    pause: campaignGroupsPauseCommand,
+    resume: campaignGroupsResumeCommand,
+    duplicate: campaignGroupsDuplicateCommand
   },
   args: {
     "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
@@ -5282,11 +7277,11 @@ Examples:
 });
 
 // src/commands/ads/linkedin/campaigns.ts
-import { defineCommand as defineCommand37 } from "citty";
-var campaignsCommand = defineCommand37({
+import { defineCommand as defineCommand38 } from "citty";
+var campaignsCommand = defineCommand38({
   meta: {
     name: "campaigns",
-    description: `List LinkedIn campaigns.
+    description: `List LinkedIn campaigns, or stage writes (create/update/pause/resume/archive/duplicate).
 
 Default: ACTIVE only. The schema includes the audit-relevant settings:
   audienceExpansionEnabled \u2014 playbook \xA702 silent budget drain (should be false)
@@ -5294,10 +7289,22 @@ Default: ACTIVE only. The schema includes the audit-relevant settings:
   optimizationTargetType   \u2014 driver of the bidding strategy
   costType                 \u2014 CPC | CPM | CPV | CPS
 
+Write subcommands stage ops on this chat's draft \u2014 they never hit the LinkedIn
+API directly and apply only when the chat is published.
+
 Examples:
   baker ads linkedin campaigns --account-id 503001492
-  baker ads linkedin campaigns --account-id 503001492 --campaign-group-id 12345
-  baker ads linkedin campaigns --account-id 503001492 --all-statuses --output csv`
+  baker ads linkedin campaigns --account-id 503001492 --all-statuses --output csv
+  baker ads linkedin campaigns update 123456 --daily-budget 100 --currency EUR
+  baker ads linkedin campaigns pause 123456`
+  },
+  subCommands: {
+    create: campaignsCreateCommand,
+    update: campaignsUpdateCommand,
+    pause: campaignsPauseCommand,
+    resume: campaignsResumeCommand,
+    archive: campaignsArchiveCommand,
+    duplicate: campaignsDuplicateCommand
   },
   args: {
     "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
@@ -5332,8 +7339,8 @@ Examples:
 });
 
 // src/commands/ads/linkedin/conversation.ts
-import { defineCommand as defineCommand38 } from "citty";
-var conversationCommand = defineCommand38({
+import { defineCommand as defineCommand39 } from "citty";
+var conversationCommand = defineCommand39({
   meta: {
     name: "conversation",
     description: `Per-button click rates inside Sponsored Messaging / Conversation Ads.
@@ -5396,7 +7403,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/conversions.ts
-import { defineCommand as defineCommand39 } from "citty";
+import { defineCommand as defineCommand40 } from "citty";
 var DAY_MS3 = 864e5;
 function healthOf(rules) {
   const enabled = rules.filter((r) => r.enabled !== false);
@@ -5422,7 +7429,7 @@ function healthOf(rules) {
     wrongLeadDedup: wrongDedup
   };
 }
-var listCmd = defineCommand39({
+var listCmd = defineCommand40({
   meta: {
     name: "list",
     description: `List conversion rules on the account.`
@@ -5450,7 +7457,7 @@ var listCmd = defineCommand39({
     }
   }
 });
-var healthCmd = defineCommand39({
+var healthCmd = defineCommand40({
   meta: {
     name: "health",
     description: `5-point Insight Tag / CAPI health check (playbook \xA707).
@@ -5480,27 +7487,30 @@ Surfaces:
     }
   }
 });
-var conversionsCommand = defineCommand39({
+var conversionsCommand = defineCommand40({
   meta: {
     name: "conversions",
     description: `Conversion rules \u2014 Insight Tag and Conversions API.
 
 Subcommands:
   list                \u2014 every rule on the account
-  health              \u2014 playbook \xA707 5-point health check`
+  health              \u2014 playbook \xA707 5-point health check
+  create / update     \u2014 stage a conversion-rule write (applies on chat publish)`
   },
   subCommands: {
     list: listCmd,
-    health: healthCmd
+    health: healthCmd,
+    create: conversionsCreateCommand,
+    update: conversionsUpdateCommand
   }
 });
 
 // src/commands/ads/linkedin/creatives.ts
-import { defineCommand as defineCommand40 } from "citty";
-var creativesCommand = defineCommand40({
+import { defineCommand as defineCommand41 } from "citty";
+var creativesCommand = defineCommand41({
   meta: {
     name: "creatives",
-    description: `List LinkedIn creatives (ads).
+    description: `List LinkedIn creatives (ads), or stage writes (create/update/pause/resume/duplicate).
 
 Defaults to ACTIVE intended-status. Pass --all-statuses or --statuses ACTIVE,PAUSED to widen.
 
@@ -5508,10 +7518,20 @@ The 'content' block is opaque (varies by creative type \u2014 image, video, docu
 spotlight, conversation, dynamic). Use 'reviewStatus' to spot rejected/pending
 creatives during an audit.
 
+Write subcommands stage ops on this chat's draft \u2014 media comes from the Baker
+library and is uploaded to LinkedIn only at publish.
+
 Examples:
   baker ads linkedin creatives --account-id 503001492
-  baker ads linkedin creatives --account-id 503001492 --campaign-id 1234
-  baker ads linkedin creatives --account-id 503001492 --all-statuses --output csv`
+  baker ads linkedin creatives create --campaign 1234 --format image --image-id <bakerImageId> --intro "\u2026" --headline "Book a demo" --landing-url https://example.com --cta REQUEST_DEMO
+  baker ads linkedin creatives pause urn:li:sponsoredCreative:789`
+  },
+  subCommands: {
+    create: creativesCreateCommand,
+    update: creativesUpdateCommand,
+    pause: creativesPauseCommand,
+    resume: creativesResumeCommand,
+    duplicate: creativesDuplicateCommand
   },
   args: {
     "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
@@ -5546,7 +7566,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/demographics.ts
-import { defineCommand as defineCommand41 } from "citty";
+import { defineCommand as defineCommand42 } 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;
@@ -5559,7 +7579,7 @@ function numberOf2(v) {
 function topByImpressions(rows, limit) {
   return [...rows].sort((a, b) => numberOf2(b.impressions) - numberOf2(a.impressions)).slice(0, limit);
 }
-var demographicsCommand = defineCommand41({
+var demographicsCommand = defineCommand42({
   meta: {
     name: "demographics",
     description: `Sweep all firmographic pivots in one command \u2014 LinkedIn's superpower.
@@ -5642,22 +7662,97 @@ Examples:
     }
   }
 });
-function resolveRange(args) {
-  const start = args.start;
-  const end = args.end;
-  if (start) {
-    return { start, end };
-  }
-  const days = args["last-days"] ? Number(args["last-days"]) : 30;
-  if (!Number.isFinite(days) || days < 1) {
-    handleLinkedinError(new Error("Invalid --last-days; must be a positive integer."));
-  }
-  return { start: daysAgoIso(days), end: todayIso() };
-}
+function resolveRange(args) {
+  const start = args.start;
+  const end = args.end;
+  if (start) {
+    return { start, end };
+  }
+  const days = args["last-days"] ? Number(args["last-days"]) : 30;
+  if (!Number.isFinite(days) || days < 1) {
+    handleLinkedinError(new Error("Invalid --last-days; must be a positive integer."));
+  }
+  return { start: daysAgoIso(days), end: todayIso() };
+}
+
+// src/commands/ads/linkedin/draft.ts
+import { defineCommand as defineCommand43 } from "citty";
+async function listDraft() {
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/linkedin/draft", {
+      chatId
+    });
+    writeJsonEnvelope(response);
+  } catch (err) {
+    handleLinkedinError(err);
+  }
+}
+var listCommand3 = defineCommand43({
+  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({
+  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"
+  },
+  args: {
+    ref: {
+      type: "positional",
+      description: "Op ref (li_temp_* for creates, target id/URN for updates)",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost(
+        "/api/ads/linkedin/draft/remove",
+        { chatId, ref: args.ref }
+      );
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var clearCommand2 = defineCommand43({
+  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"
+  },
+  run: async () => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/ads/linkedin/draft/clear", {
+        chatId
+      });
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var linkedinDraftCommand = defineCommand43({
+  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."
+  },
+  subCommands: {
+    list: listCommand3,
+    remove: removeCommand2,
+    clear: clearCommand2
+  },
+  run: listDraft
+});
 
 // src/commands/ads/linkedin/facets.ts
-import { defineCommand as defineCommand42 } from "citty";
-var listCmd2 = defineCommand42({
+import { defineCommand as defineCommand44 } from "citty";
+var listCmd2 = defineCommand44({
   meta: {
     name: "list",
     description: `List every targeting facet LinkedIn supports.
@@ -5685,7 +7780,7 @@ seniorities, titles, employers, growthRate, companyCategory, skills, etc.).`
     }
   }
 });
-var valuesCmd = defineCommand42({
+var valuesCmd = defineCommand44({
   meta: {
     name: "values",
     description: `Look up entity values for a single facet \u2014 full list or typeahead search.
@@ -5726,7 +7821,7 @@ or the full URN (urn:li:adTargetingFacet:industries).`
     }
   }
 });
-var facetsCommand = defineCommand42({
+var facetsCommand = defineCommand44({
   meta: {
     name: "facets",
     description: `LinkedIn targeting facets and entity lookup.
@@ -5743,8 +7838,8 @@ Subcommands:
 });
 
 // src/commands/ads/linkedin/forecast.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { defineCommand as defineCommand43 } from "citty";
+import { readFileSync as readFileSync7 } from "fs";
+import { defineCommand as defineCommand45 } from "citty";
 function loadTargeting3(args) {
   const inline = args.targeting;
   if (inline) {
@@ -5757,7 +7852,7 @@ function loadTargeting3(args) {
   const file = args["targeting-file"];
   if (file) {
     try {
-      return JSON.parse(readFileSync6(file, "utf-8"));
+      return JSON.parse(readFileSync7(file, "utf-8"));
     } catch (e) {
       handleLinkedinError(
         new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
@@ -5774,7 +7869,7 @@ function parseMoney(raw) {
   }
   return { amount: m[1] ?? "0", currencyCode: m[2] ?? "USD" };
 }
-var forecastCommand = defineCommand43({
+var forecastCommand = defineCommand45({
   meta: {
     name: "forecast",
     description: `Forecast reach + impressions + clicks + spend for a hypothetical campaign.
@@ -5821,9 +7916,9 @@ Examples:
 });
 
 // src/commands/ads/linkedin/leads.ts
-import { defineCommand as defineCommand44 } from "citty";
+import { defineCommand as defineCommand46 } from "citty";
 var DAY_MS4 = 864e5;
-var leadsCommand = defineCommand44({
+var leadsCommand = defineCommand46({
   meta: {
     name: "leads",
     description: `List Lead Gen Form responses (playbook \xA707).
@@ -5883,7 +7978,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/resolve.ts
-import { defineCommand as defineCommand45 } from "citty";
+import { defineCommand as defineCommand47 } from "citty";
 function toOrgUrn(raw) {
   const trimmed = raw.trim();
   if (trimmed.length === 0) {
@@ -5894,7 +7989,7 @@ function toOrgUrn(raw) {
   }
   return /^\d+$/.test(trimmed) ? `urn:li:organization:${trimmed}` : null;
 }
-var resolveCommand = defineCommand45({
+var resolveCommand = defineCommand47({
   meta: {
     name: "resolve",
     description: `Resolve organization URNs to company names.
@@ -5936,8 +8031,8 @@ couldn't be resolved \u2014 typically an org outside LinkedIn's targetable set.`
 });
 
 // src/commands/ads/linkedin/top-companies.ts
-import { defineCommand as defineCommand46 } from "citty";
-var topCompaniesCommand = defineCommand46({
+import { defineCommand as defineCommand48 } from "citty";
+var topCompaniesCommand = defineCommand48({
   meta: {
     name: "top-companies",
     description: `Top companies whose employees saw / clicked / converted on a campaign.
@@ -6008,7 +8103,7 @@ Examples:
 });
 
 // src/commands/ads/linkedin/index.ts
-var linkedinCommand = defineCommand47({
+var linkedinCommand = defineCommand49({
   meta: {
     name: "linkedin",
     description: `LinkedIn Marketing API \u2014 AI-first command surface for B2B ad insights.
@@ -6034,6 +8129,17 @@ Performance \u2014 the workhorse (3 axes):
   baker ads linkedin analytics --list-intents
   baker ads linkedin analytics --list-pivots
 
+Staged writes (NEVER hit LinkedIn directly \u2014 ops stage on this chat's draft,
+show in the dashboard as pending LinkedIn changes, and apply when the chat is
+published; if the company's LinkedIn-write flag is off the publish is simulated):
+  baker ads linkedin campaign-groups create|update|pause|resume|duplicate
+  baker ads linkedin campaigns create|update|pause|resume|archive|duplicate
+  baker ads linkedin creatives create|update|pause|resume|duplicate
+  baker ads linkedin audiences create|upload
+  baker ads linkedin conversions create|update
+  baker ads linkedin lead-forms create|update
+  baker ads linkedin draft [list|remove <ref>|clear]                \u2014 review/undo staged ops
+
 Account ID format:
   --account-id accepts numeric (503001492) or URN (urn:li:sponsoredAccount:503001492).
   Set BAKER_LINKEDIN_AD_ACCOUNT_ID env to skip --account-id on every call.`
@@ -6044,6 +8150,9 @@ Account ID format:
     "campaign-groups": campaignGroupsCommand,
     campaigns: campaignsCommand,
     creatives: creativesCommand,
+    audiences: audiencesCommand,
+    "lead-forms": leadFormsCommand,
+    draft: linkedinDraftCommand,
     analytics: analyticsCommand,
     demographics: demographicsCommand,
     "top-companies": topCompaniesCommand,
@@ -6060,10 +8169,10 @@ Account ID format:
 });
 
 // src/commands/ads/meta/index.ts
-import { defineCommand as defineCommand60 } from "citty";
+import { defineCommand as defineCommand62 } from "citty";
 
 // src/commands/ads/meta/account.ts
-import { defineCommand as defineCommand48 } from "citty";
+import { defineCommand as defineCommand50 } from "citty";
 
 // src/commands/ads/meta/shared.ts
 var DAY_MS5 = 864e5;
@@ -6142,7 +8251,7 @@ function resolveEffectiveStatus(args) {
 }
 
 // src/commands/ads/meta/account.ts
-var accountCommand2 = defineCommand48({
+var accountCommand2 = defineCommand50({
   meta: {
     name: "account",
     description: `Show single Meta ad account detail (currency, timezone, balance, business).
@@ -6169,8 +8278,8 @@ Examples:
 });
 
 // src/commands/ads/meta/accounts.ts
-import { defineCommand as defineCommand49 } from "citty";
-var accountsCommand3 = defineCommand49({
+import { defineCommand as defineCommand51 } from "citty";
+var accountsCommand3 = defineCommand51({
   meta: {
     name: "accounts",
     description: `List Meta ad accounts in this company's connected scope.
@@ -6218,8 +8327,8 @@ Examples:
 });
 
 // src/commands/ads/meta/activities.ts
-import { defineCommand as defineCommand50 } from "citty";
-var activitiesCommand = defineCommand50({
+import { defineCommand as defineCommand52 } from "citty";
+var activitiesCommand = defineCommand52({
   meta: {
     name: "activities",
     description: `Audit log of recent ad-account changes (created, paused, edited). Default lookback 7 days,
@@ -6256,8 +8365,8 @@ Examples:
 });
 
 // src/commands/ads/meta/ads.ts
-import { defineCommand as defineCommand51 } from "citty";
-var adsListCommand = defineCommand51({
+import { defineCommand as defineCommand53 } from "citty";
+var adsListCommand = defineCommand53({
   meta: {
     name: "ads",
     description: `List ads in a Meta ad account. Defaults to ACTIVE only \u2014 pass --all-statuses to widen.
@@ -6305,8 +8414,8 @@ Examples:
 });
 
 // src/commands/ads/meta/adsets.ts
-import { defineCommand as defineCommand52 } from "citty";
-var adsetsCommand = defineCommand52({
+import { defineCommand as defineCommand54 } from "citty";
+var adsetsCommand = defineCommand54({
   meta: {
     name: "adsets",
     description: `List ad sets in a Meta ad account, optionally scoped to one campaign. Defaults to ACTIVE only.
@@ -6348,8 +8457,8 @@ Examples:
 });
 
 // src/commands/ads/meta/audiences.ts
-import { defineCommand as defineCommand53 } from "citty";
-var audiencesCommand = defineCommand53({
+import { defineCommand as defineCommand55 } from "citty";
+var audiencesCommand2 = defineCommand55({
   meta: {
     name: "audiences",
     description: `List custom audiences for a Meta ad account. Includes lookalikes, website-pixel audiences,
@@ -6384,8 +8493,8 @@ Examples:
 });
 
 // src/commands/ads/meta/businesses.ts
-import { defineCommand as defineCommand54 } from "citty";
-var businessesCommand = defineCommand54({
+import { defineCommand as defineCommand56 } from "citty";
+var businessesCommand = defineCommand56({
   meta: {
     name: "businesses",
     description: `List Meta Business Manager accounts the connected user has access to. Required for ad-studies and product-catalogs commands.
@@ -6415,8 +8524,8 @@ Examples:
 });
 
 // src/commands/ads/meta/campaigns.ts
-import { defineCommand as defineCommand55 } from "citty";
-var campaignsCommand2 = defineCommand55({
+import { defineCommand as defineCommand57 } from "citty";
+var campaignsCommand2 = defineCommand57({
   meta: {
     name: "campaigns",
     description: `List campaigns for a Meta ad account. Defaults to ACTIVE only \u2014 pass --all-statuses to widen.
@@ -6460,8 +8569,8 @@ Examples:
 });
 
 // src/commands/ads/meta/creatives.ts
-import { defineCommand as defineCommand56 } from "citty";
-var creativesCommand2 = defineCommand56({
+import { defineCommand as defineCommand58 } from "citty";
+var creativesCommand2 = defineCommand58({
   meta: {
     name: "creatives",
     description: `List ad creatives in an account, or fetch a single creative by ID.
@@ -6505,7 +8614,7 @@ Examples:
 });
 
 // src/commands/ads/meta/insights.ts
-import { defineCommand as defineCommand57 } from "citty";
+import { defineCommand as defineCommand59 } from "citty";
 
 // src/commands/ads/meta/presets.ts
 var INSIGHTS_INTENTS = {
@@ -6710,7 +8819,7 @@ function sortRowsBySpendDesc(rows) {
     return sb - sa;
   });
 }
-var insightsCommand = defineCommand57({
+var insightsCommand = defineCommand59({
   meta: {
     name: "insights",
     description: `Performance reporting \u2014 the main Meta tool for AI agents.
@@ -6811,8 +8920,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 defineCommand58 } from "citty";
-var pixelsCommand = defineCommand58({
+import { defineCommand as defineCommand60 } from "citty";
+var pixelsCommand = defineCommand60({
   meta: {
     name: "pixels",
     description: `List Meta Pixels for an ad account, or fetch firing stats for one pixel.
@@ -6883,7 +8992,7 @@ function emit(data, args) {
 
 // src/commands/ads/meta/preview.ts
 import { writeFileSync as writeFileSync3 } from "fs";
-import { defineCommand as defineCommand59 } from "citty";
+import { defineCommand as defineCommand61 } from "citty";
 var VALID_AD_FORMATS = [
   "DESKTOP_FEED_STANDARD",
   "MOBILE_FEED_STANDARD",
@@ -6917,7 +9026,7 @@ var VALID_AD_FORMATS = [
   "MARKETPLACE_MOBILE",
   "BIZ_DISCO_FEED_MOBILE"
 ];
-var previewCommand = defineCommand59({
+var previewCommand = defineCommand61({
   meta: {
     name: "preview",
     description: `Generate a Meta-hosted preview iframe for a creative or ad. Returns iframe HTML which you
@@ -6964,7 +9073,7 @@ Examples:
 });
 
 // src/commands/ads/meta/index.ts
-var metaCommand = defineCommand60({
+var metaCommand = defineCommand62({
   meta: {
     name: "meta",
     description: `Meta Marketing API \u2014 AI-first command surface (Facebook + Instagram ads).
@@ -7007,7 +9116,7 @@ Audit & review:
     adsets: adsetsCommand,
     ads: adsListCommand,
     creatives: creativesCommand2,
-    audiences: audiencesCommand,
+    audiences: audiencesCommand2,
     pixels: pixelsCommand,
     activities: activitiesCommand,
     insights: insightsCommand,
@@ -7016,10 +9125,10 @@ Audit & review:
 });
 
 // src/commands/ads/x/index.ts
-import { defineCommand as defineCommand77 } from "citty";
+import { defineCommand as defineCommand79 } from "citty";
 
 // src/commands/ads/x/accounts.ts
-import { defineCommand as defineCommand61 } from "citty";
+import { defineCommand as defineCommand63 } 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.",
@@ -7047,7 +9156,7 @@ function handleAccountsError2(err) {
   writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
   process.exit(1);
 }
-var accountsCommand4 = defineCommand61({
+var accountsCommand4 = defineCommand63({
   meta: {
     name: "accounts",
     description: `List accessible X Ads accounts. Returns account IDs needed for all other commands.
@@ -7087,7 +9196,7 @@ Examples:
 });
 
 // src/commands/ads/x/active-entities.ts
-import { defineCommand as defineCommand62 } from "citty";
+import { defineCommand as defineCommand64 } from "citty";
 
 // src/commands/ads/x/error-parser.ts
 function mapXErrorCode(message) {
@@ -7238,7 +9347,7 @@ function parseCsv(v) {
   const parts = v.split(",").map((s) => s.trim()).filter(Boolean);
   return parts.length > 0 ? parts : void 0;
 }
-var activeEntitiesCommand = defineCommand62({
+var activeEntitiesCommand = defineCommand64({
   meta: {
     name: "active-entities",
     description: `List entities with metric activity in a time range.
@@ -7296,7 +9405,7 @@ Examples:
 });
 
 // src/commands/ads/x/audiences.ts
-import { defineCommand as defineCommand63 } from "citty";
+import { defineCommand as defineCommand65 } 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.",
@@ -7305,7 +9414,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var audiencesCommand2 = defineCommand63({
+var audiencesCommand3 = defineCommand65({
   meta: {
     name: "audiences",
     description: `List X Ads custom audiences.
@@ -7354,7 +9463,7 @@ Examples:
 });
 
 // src/commands/ads/x/campaigns.ts
-import { defineCommand as defineCommand64 } from "citty";
+import { defineCommand as defineCommand66 } from "citty";
 
 // src/commands/ads/x/run-list.ts
 function buildCleanParams(opts) {
@@ -7417,7 +9526,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var campaignsCommand3 = defineCommand64({
+var campaignsCommand3 = defineCommand66({
   meta: {
     name: "campaigns",
     description: `List X Ads campaigns. Returns budget, schedule, funding instrument, status.
@@ -7459,7 +9568,7 @@ Examples:
 });
 
 // src/commands/ads/x/cards.ts
-import { defineCommand as defineCommand65 } from "citty";
+import { defineCommand as defineCommand67 } from "citty";
 registerSchema({
   command: "ads.x.cards",
   description: "List website cards, video cards, and carousels for an X Ads account.",
@@ -7468,7 +9577,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var cardsCommand = defineCommand65({
+var cardsCommand = defineCommand67({
   meta: {
     name: "cards",
     description: `List X Ads cards (rich creatives).
@@ -7517,7 +9626,7 @@ Examples:
 });
 
 // src/commands/ads/x/funding.ts
-import { defineCommand as defineCommand66 } from "citty";
+import { defineCommand as defineCommand68 } 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.",
@@ -7526,7 +9635,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var fundingCommand = defineCommand66({
+var fundingCommand = defineCommand68({
   meta: {
     name: "funding",
     description: `List funding instruments for an X Ads account.
@@ -7575,7 +9684,7 @@ Examples:
 });
 
 // src/commands/ads/x/line-items.ts
-import { defineCommand as defineCommand67 } from "citty";
+import { defineCommand as defineCommand69 } 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).",
@@ -7587,7 +9696,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var lineItemsCommand = defineCommand67({
+var lineItemsCommand = defineCommand69({
   meta: {
     name: "line-items",
     description: `List X Ads line items (ad groups).
@@ -7628,7 +9737,7 @@ Examples:
 });
 
 // src/commands/ads/x/media.ts
-import { defineCommand as defineCommand68 } from "citty";
+import { defineCommand as defineCommand70 } 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).",
@@ -7638,7 +9747,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var mediaCommand = defineCommand68({
+var mediaCommand = defineCommand70({
   meta: {
     name: "media",
     description: `List media assets in the X Ads media library.
@@ -7690,7 +9799,7 @@ Examples:
 });
 
 // src/commands/ads/x/promoted-tweets.ts
-import { defineCommand as defineCommand69 } from "citty";
+import { defineCommand as defineCommand71 } 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).",
@@ -7701,7 +9810,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var promotedTweetsCommand = defineCommand69({
+var promotedTweetsCommand = defineCommand71({
   meta: {
     name: "promoted-tweets",
     description: `List X Ads promoted tweets.
@@ -7755,11 +9864,11 @@ Examples:
 });
 
 // src/commands/ads/x/stats/index.ts
-import { defineCommand as defineCommand74 } from "citty";
+import { defineCommand as defineCommand76 } from "citty";
 
 // src/commands/ads/x/stats/job.ts
 import { gunzipSync } from "zlib";
-import { defineCommand as defineCommand70 } from "citty";
+import { defineCommand as defineCommand72 } from "citty";
 var POLL_INTERVAL_MS2 = 1e4;
 var DEADLINE_MS = 12 * 60 * 1e3;
 var RESULT_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
@@ -7829,7 +9938,7 @@ async function pollUntilDone(accountId, jobId) {
 function buildCacheKey(body) {
   return `stats-job:${JSON.stringify(body)}`;
 }
-var statsJobCommand = defineCommand70({
+var statsJobCommand = defineCommand72({
   meta: {
     name: "job",
     description: `Async X Ads stats job, sync from the CLI's perspective. Creates \u2192 polls \u2192 downloads \u2192 returns.
@@ -7934,7 +10043,7 @@ For fine-grained control (don't wait, poll yourself), use:
 });
 
 // src/commands/ads/x/stats/job-create.ts
-import { defineCommand as defineCommand71 } from "citty";
+import { defineCommand as defineCommand73 } 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.",
@@ -7957,7 +10066,7 @@ function parseCsv3(v) {
   const parts = v.split(",").map((s) => s.trim()).filter(Boolean);
   return parts.length > 0 ? parts : void 0;
 }
-var statsJobCreateCommand = defineCommand71({
+var statsJobCreateCommand = defineCommand73({
   meta: {
     name: "job-create",
     description: `Create an async X Ads stats job (up to 90 days, supports segmentation).
@@ -8020,7 +10129,7 @@ Examples:
 });
 
 // src/commands/ads/x/stats/job-status.ts
-import { defineCommand as defineCommand72 } from "citty";
+import { defineCommand as defineCommand74 } 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).",
@@ -8030,7 +10139,7 @@ registerSchema({
     "job-ids": { type: "string", description: "CSV of job IDs", required: false }
   }
 });
-var statsJobStatusCommand = defineCommand72({
+var statsJobStatusCommand = defineCommand74({
   meta: {
     name: "job-status",
     description: `Poll the status of an async X Ads stats job.
@@ -8071,7 +10180,7 @@ Examples:
 });
 
 // src/commands/ads/x/stats/sync.ts
-import { defineCommand as defineCommand73 } from "citty";
+import { defineCommand as defineCommand75 } from "citty";
 
 // src/commands/ads/x/presets.ts
 var X_STATS_PRESETS = [
@@ -8230,7 +10339,7 @@ async function runSync(args, q) {
     process.exit(1);
   }
 }
-var statsSyncCommand = defineCommand73({
+var statsSyncCommand = defineCommand75({
   meta: {
     name: "sync",
     description: `Synchronous X Ads analytics (max 7-day window).
@@ -8273,7 +10382,7 @@ Examples:
 });
 
 // src/commands/ads/x/stats/index.ts
-var statsCommand = defineCommand74({
+var statsCommand = defineCommand76({
   meta: {
     name: "stats",
     description: `X Ads analytics. Sync (\u22647 days, no segmentation) or async jobs (\u226490 days, segmentable).
@@ -8301,7 +10410,7 @@ Examples:
 });
 
 // src/commands/ads/x/targeting-constants.ts
-import { defineCommand as defineCommand75 } from "citty";
+import { defineCommand as defineCommand77 } from "citty";
 var ALLOWED_CONSTANTS = [
   "locations",
   "interests",
@@ -8329,7 +10438,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var targetingConstantsCommand = defineCommand75({
+var targetingConstantsCommand = defineCommand77({
   meta: {
     name: "targeting-constants",
     description: `Lookup X Ads targeting constants.
@@ -8379,7 +10488,7 @@ Examples:
 });
 
 // src/commands/ads/x/targeting-criteria.ts
-import { defineCommand as defineCommand76 } from "citty";
+import { defineCommand as defineCommand78 } 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.",
@@ -8389,7 +10498,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache", required: false }
   }
 });
-var targetingCriteriaCommand = defineCommand76({
+var targetingCriteriaCommand = defineCommand78({
   meta: {
     name: "targeting-criteria",
     description: `List targeting criteria attached to line items.
@@ -8440,7 +10549,7 @@ Examples:
 });
 
 // src/commands/ads/x/index.ts
-var xCommand = defineCommand77({
+var xCommand = defineCommand79({
   meta: {
     name: "x",
     description: `X (Twitter) Ads commands. Read campaigns, line items, promoted tweets, creatives, audiences, and analytics.
@@ -8469,7 +10578,7 @@ The CLI auto-detects --account-id when exactly one X Ads account is connected, o
     "promoted-tweets": promotedTweetsCommand,
     cards: cardsCommand,
     media: mediaCommand,
-    audiences: audiencesCommand2,
+    audiences: audiencesCommand3,
     "targeting-criteria": targetingCriteriaCommand,
     "targeting-constants": targetingConstantsCommand,
     "active-entities": activeEntitiesCommand,
@@ -8478,7 +10587,7 @@ The CLI auto-detects --account-id when exactly one X Ads account is connected, o
 });
 
 // src/commands/ads/index.ts
-var adsCommand = defineCommand78({
+var adsCommand = defineCommand80({
   meta: {
     name: "ads",
     description: `Ad platform commands. Each platform exposes its own native command surface \u2014 no forced parity.
@@ -8508,11 +10617,11 @@ Examples:
 });
 
 // src/commands/canvas/index.ts
-import { defineCommand as defineCommand86 } from "citty";
+import { defineCommand as defineCommand88 } from "citty";
 
 // src/commands/canvas/catalog.ts
-import { defineCommand as defineCommand79 } from "citty";
-var catalogCommand = defineCommand79({
+import { defineCommand as defineCommand81 } from "citty";
+var catalogCommand = defineCommand81({
   meta: {
     name: "catalog",
     description: "Print the agent-facing node catalog (JSON Schema). Includes every registered node grouped by category."
@@ -8529,9 +10638,9 @@ import { execFile } from "child_process";
 import { readdir, readFile, stat } from "fs/promises";
 import path from "path";
 import { promisify } from "util";
-import { defineCommand as defineCommand80 } from "citty";
+import { defineCommand as defineCommand82 } from "citty";
 var execFileAsync = promisify(execFile);
-var inspectCommand = defineCommand80({
+var inspectCommand = defineCommand82({
   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."
@@ -8640,7 +10749,7 @@ async function probeDuration(filePath) {
 // src/commands/canvas/run.ts
 import { readFile as readFile2 } from "fs/promises";
 import path4 from "path";
-import { defineCommand as defineCommand81 } from "citty";
+import { defineCommand as defineCommand83 } from "citty";
 
 // src/commands/canvas/placeholders.ts
 function unsuppliedPlaceholderAssets(canvas) {
@@ -8710,7 +10819,7 @@ async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
 }
 
 // src/commands/canvas/run.ts
-var runCommand = defineCommand81({
+var runCommand = defineCommand83({
   meta: { name: "run", description: "Validate and execute a canvas JSON file." },
   args: {
     file: { type: "positional", required: true, description: "Path to canvas JSON" },
@@ -8806,30 +10915,30 @@ var runCommand = defineCommand81({
 // src/commands/canvas/scaffold-static-ad.ts
 import { readFile as readFile3, writeFile } from "fs/promises";
 import path5 from "path";
-import { defineCommand as defineCommand82 } from "citty";
+import { defineCommand as defineCommand84 } from "citty";
 
 // src/engine/scaffold/staticAd.ts
-import { z as z3 } from "zod";
+import { z as z8 } 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 = z3.object({
-  meta: z3.object({ estimated_aspect_ratio: z3.string().optional() }).loose().optional(),
-  text_content: z3.array(z3.object({ text: z3.string().optional() }).loose()).optional()
+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()
 }).loose();
-var ElementLocator = z3.object({
-  collection: z3.enum(["subjects", "people", "brands_logos"]),
-  index: z3.number().int().nonnegative()
+var ElementLocator = z8.object({
+  collection: z8.enum(["subjects", "people", "brands_logos"]),
+  index: z8.number().int().nonnegative()
 }).loose();
-var MainElement = z3.object({
+var MainElement = z8.object({
   // logo | product | person | animal | badge | other
-  type: z3.string(),
-  label: z3.string().optional(),
-  description: z3.string().optional(),
-  expression: z3.string().nullable().optional(),
-  reason: z3.string().optional(),
+  type: z8.string(),
+  label: z8.string().optional(),
+  description: z8.string().optional(),
+  expression: z8.string().nullable().optional(),
+  reason: z8.string().optional(),
   locator: ElementLocator.optional()
 }).loose();
-var MainElements = z3.array(MainElement);
+var MainElements = z8.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;
@@ -9125,7 +11234,7 @@ async function runVisionPasses(canvas) {
     return fail("read_outputs", e instanceof Error ? e.message : String(e));
   }
 }
-var scaffoldStaticAdCommand = defineCommand82({
+var scaffoldStaticAdCommand = defineCommand84({
   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."
@@ -9219,7 +11328,7 @@ var scaffoldStaticAdCommand = defineCommand82({
 // 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 defineCommand83 } from "citty";
+import { defineCommand as defineCommand85 } from "citty";
 
 // src/engine/nodes/local/lib/sceneDetect.ts
 import { execFile as execFile2 } from "child_process";
@@ -9324,7 +11433,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 z4 } from "zod";
+import { z as z9 } from "zod";
 
 // src/engine/scaffold/lib/shoot-modes.ts
 var SHOOT_MODES = [
@@ -9581,49 +11690,49 @@ function trimArgs(durationS, offsetS = 0) {
     "{{out.video}}"
   ];
 }
-var FrameAsset = z4.object({ url: z4.string().optional() }).loose().optional();
-var DialogueLine = z4.object({
-  speaker: z4.string().optional(),
-  line: z4.string().optional(),
+var FrameAsset = z9.object({ url: z9.string().optional() }).loose().optional();
+var DialogueLine = z9.object({
+  speaker: z9.string().optional(),
+  line: z9.string().optional(),
   // Absolute seconds on the source timeline (the deconstruct emits both).
-  start_s: z4.number().optional(),
-  end_s: z4.number().optional(),
-  delivery: z4.string().optional(),
-  voice_description: z4.string().optional()
+  start_s: z9.number().optional(),
+  end_s: z9.number().optional(),
+  delivery: z9.string().optional(),
+  voice_description: z9.string().optional()
 }).loose();
-var Sfx = z4.object({
-  at_s: z4.number().optional(),
-  duration_s: z4.number().optional(),
-  sound_effect_prompt: z4.string().optional(),
-  description: z4.string().optional()
+var Sfx = z9.object({
+  at_s: z9.number().optional(),
+  duration_s: z9.number().optional(),
+  sound_effect_prompt: z9.string().optional(),
+  description: z9.string().optional()
 }).loose();
-var CompositionRegion = z4.object({
+var CompositionRegion = z9.object({
   // full | top | bottom | left | right | inset
-  panel: z4.string().optional(),
+  panel: z9.string().optional(),
   // 9-grid anchor for an `inset` presenter box.
-  position: z4.string().optional(),
-  is_presenter: z4.boolean().optional(),
+  position: z9.string().optional(),
+  is_presenter: z9.boolean().optional(),
   // The cast id shown/speaking in this region (routes lip-sync + element refs).
-  cast_ref: z4.string().optional(),
-  summary: z4.string().optional(),
-  frame_prompt: z4.string().optional(),
-  motion_prompt: z4.string().optional()
+  cast_ref: z9.string().optional(),
+  summary: z9.string().optional(),
+  frame_prompt: z9.string().optional(),
+  motion_prompt: z9.string().optional()
 }).loose();
-var SceneComposition = z4.object({
+var SceneComposition = z9.object({
   // full_frame (default) | split_screen | pip | keyed_overlay
-  layout: z4.string().optional(),
+  layout: z9.string().optional(),
   // split_screen only: vertical (top/bottom) | horizontal (left/right).
-  split_axis: z4.string().optional(),
-  regions: z4.array(CompositionRegion).optional()
+  split_axis: z9.string().optional(),
+  regions: z9.array(CompositionRegion).optional()
 }).loose();
-var CameraMotion = z4.object({ movement: z4.string().optional(), detail: z4.string().optional() }).loose();
-var TranscriptWord = z4.object({ text: z4.string().optional() }).loose();
-var Scene = z4.object({
-  start_s: z4.number().optional(),
-  end_s: z4.number().optional(),
-  duration_s: z4.number().optional(),
-  summary: z4.string().optional(),
-  action_detail: z4.string().optional(),
+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(),
   // 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.
@@ -9631,77 +11740,77 @@ var Scene = z4.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: z4.string().optional(),
+  shoot_mode: z9.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: z4.string().optional(),
+  ambient: z9.string().optional(),
   camera_motion: CameraMotion.optional(),
-  start_frame_prompt: z4.string().optional(),
-  end_frame_prompt: z4.string().optional(),
-  motion_prompt: z4.string().optional(),
+  start_frame_prompt: z9.string().optional(),
+  end_frame_prompt: z9.string().optional(),
+  motion_prompt: z9.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: z4.string().optional(),
+  narrative_role: z9.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: z4.object({ mechanic: z4.string().optional(), why_it_stops_scroll: z4.string().optional() }).loose().optional(),
+  hook_mechanic: z9.object({ mechanic: z9.string().optional(), why_it_stops_scroll: z9.string().optional() }).loose().optional(),
   // DECON-supplied per-scene location (so a gym hook isn't flattened to "home").
-  scene_setting: z4.string().optional(),
+  scene_setting: z9.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: z4.object({ type: z4.string().optional(), description: z4.string().optional() }).loose().optional(),
-  dialogue: z4.array(DialogueLine).optional(),
-  sfx: z4.array(Sfx).optional(),
-  overlays: z4.array(z4.unknown()).optional(),
-  floating_elements: z4.array(z4.unknown()).optional(),
-  transcript_slice: z4.array(TranscriptWord).optional(),
+  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(),
   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: z4.boolean().optional()
+  continues_previous: z9.boolean().optional()
 }).loose();
-var VideoBlueprint = z4.object({
-  source: z4.object({ aspect_ratio: z4.string().optional(), duration_s: z4.number().optional() }).loose().optional(),
-  global: z4.object({
-    music: z4.object({
-      present: z4.boolean().optional(),
-      music_prompt: z4.string().optional(),
+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(),
       // 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: z4.number().optional(),
+      starts_at_s: z9.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: z4.object({ title: z4.string().optional(), artist: z4.string().optional() }).loose().nullish()
+      identified_track: z9.object({ title: z9.string().optional(), artist: z9.string().optional() }).loose().nullish()
     }).loose().optional(),
-    cast: z4.array(
-      z4.object({
-        id: z4.string().optional(),
-        description: z4.string().optional(),
+    cast: z9.array(
+      z9.object({
+        id: z9.string().optional(),
+        description: z9.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: z4.string().optional()
+        market_localization_note: z9.string().optional()
       }).loose()
     ).optional(),
-    voiceover: z4.object({
+    voiceover: z9.object({
       // on_camera | mixed → mouths are on screen (lip-sync candidates);
       // voiceover | none → narration over the picture (no lip-sync).
-      mode: z4.string().optional(),
-      voice_description: z4.string().optional(),
-      persona: z4.string().optional()
+      mode: z9.string().optional(),
+      voice_description: z9.string().optional(),
+      persona: z9.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: z4.object({ palette: z4.array(z4.object({ hex: z4.string().optional() }).loose()).optional() }).loose().optional()
+    style: z9.object({ palette: z9.array(z9.object({ hex: z9.string().optional() }).loose()).optional() }).loose().optional()
   }).loose().optional(),
-  scenes: z4.array(Scene).min(1)
+  scenes: z9.array(Scene).min(1)
 }).loose();
 function injectHookPhysicality(blueprint) {
   for (const scene of blueprint.scenes) {
@@ -9711,26 +11820,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 = z4.union([z4.number(), z4.object({ scene: z4.number(), edge: z4.string().optional() }).loose()]);
-var RecurringElement = z4.object({
+var AppearsItem = z9.union([z9.number(), z9.object({ scene: z9.number(), edge: z9.string().optional() }).loose()]);
+var RecurringElement = z9.object({
   // person | animal | product | logo | badge | other
-  type: z4.string(),
-  label: z4.string().optional(),
-  description: z4.string().optional(),
-  expression: z4.string().nullable().optional(),
+  type: z9.string(),
+  label: z9.string().optional(),
+  description: z9.string().optional(),
+  expression: z9.string().nullable().optional(),
   // When the element maps to a global cast entry, its stable id (for annotation).
-  cast_id: z4.string().nullable().optional(),
+  cast_id: z9.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: z4.string().nullable().optional(),
+  same_as: z9.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: z4.array(z4.number()).optional(),
-  appears_in: z4.array(AppearsItem).optional()
+  scenes: z9.array(z9.number()).optional(),
+  appears_in: z9.array(AppearsItem).optional()
 }).loose();
-var RecurringElements = z4.array(RecurringElement);
+var RecurringElements = z9.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;
@@ -11193,25 +13302,25 @@ function buildSfxMusic(blueprint, nodes) {
   }
   return tracks;
 }
-var OverlayStyle = z4.object({ color_hex: z4.string().optional(), background: z4.string().optional(), size: z4.string().optional() }).loose();
-var Overlay = z4.object({
-  text: z4.string().optional(),
-  appears_at_s: z4.number().optional(),
-  duration_s: z4.number().optional(),
-  position: z4.string().optional(),
-  role: z4.string().optional(),
-  animation: z4.string().optional(),
-  animation_detail: z4.string().optional(),
+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(),
   style: OverlayStyle.optional()
 }).loose();
-var FloatingElement = z4.object({
-  kind: z4.string().optional(),
-  description: z4.string().optional(),
-  brand_name: z4.string().nullish(),
-  what_it_represents: z4.string().optional(),
-  appears_at_s: z4.number().optional(),
-  duration_s: z4.number().optional(),
-  position: z4.string().optional()
+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()
 }).loose();
 function escapeHtml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -11243,7 +13352,7 @@ function positionClass(position) {
 function collectCaptions(blueprint) {
   return blueprint.scenes.flatMap((scene) => {
     const sceneStart = scene.start_s ?? 0;
-    const overlays = z4.array(Overlay).safeParse(scene.overlays ?? []);
+    const overlays = z9.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 };
@@ -11352,7 +13461,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 = z4.array(FloatingElement).safeParse(scene.floating_elements ?? []);
+    const floats = z9.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);
@@ -11609,8 +13718,8 @@ function buildMotionBoard(blueprint) {
     const end_s = scene.end_s ?? start_s + sceneDurationS(scene);
     cursor = end_s;
     const spoken = sceneSpokenText(scene);
-    const overlays = z4.array(Overlay).safeParse(scene.overlays ?? []);
-    const floats = z4.array(FloatingElement).safeParse(scene.floating_elements ?? []);
+    const overlays = z9.array(Overlay).safeParse(scene.overlays ?? []);
+    const floats = z9.array(FloatingElement).safeParse(scene.floating_elements ?? []);
     const graphics = [
       ...(overlays.success ? overlays.data : []).filter((ov) => ov.text?.trim()).map((ov) => ({
         kind: "text",
@@ -12051,7 +14160,7 @@ async function runAnalysisPasses(deconstructCanvas, selectModel) {
     return fail2("deconstruct", e instanceof Error ? e.message : String(e));
   }
 }
-var scaffoldVideoCommand = defineCommand83({
+var scaffoldVideoCommand = defineCommand85({
   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`."
@@ -12196,7 +14305,7 @@ var scaffoldVideoCommand = defineCommand83({
 // src/commands/canvas/set-prompt.ts
 import { readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
 import path9 from "path";
-import { defineCommand as defineCommand84 } from "citty";
+import { defineCommand as defineCommand86 } from "citty";
 function setNodePrompt(canvas, nodeId, text) {
   const nodes = canvas?.nodes;
   if (!Array.isArray(nodes)) throw new Error("canvas has no nodes array");
@@ -12211,7 +14320,7 @@ function setNodePrompt(canvas, nodeId, text) {
   newNodes[idx] = newNode;
   return { ...canvas, nodes: newNodes };
 }
-var setPromptCommand = defineCommand84({
+var setPromptCommand = defineCommand86({
   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."
@@ -12271,8 +14380,8 @@ var setPromptCommand = defineCommand84({
 // src/commands/canvas/validate.ts
 import { readFile as readFile8 } from "fs/promises";
 import path10 from "path";
-import { defineCommand as defineCommand85 } from "citty";
-var validateCommand = defineCommand85({
+import { defineCommand as defineCommand87 } from "citty";
+var validateCommand = defineCommand87({
   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)."
@@ -12315,7 +14424,7 @@ var validateCommand = defineCommand85({
 });
 
 // src/commands/canvas/index.ts
-var canvasCommand = defineCommand86({
+var canvasCommand = defineCommand88({
   meta: {
     name: "canvas",
     description: `Run Baker creative canvas JSON files locally. Local nodes execute in-process; remote nodes POST to the Convex backend gateway.
@@ -12342,10 +14451,10 @@ Subcommands:
 });
 
 // src/commands/creatives/index.ts
-import { defineCommand as defineCommand88 } from "citty";
+import { defineCommand as defineCommand90 } from "citty";
 
 // src/commands/creatives/publish.ts
-import { defineCommand as defineCommand87 } from "citty";
+import { defineCommand as defineCommand89 } from "citty";
 
 // src/commands/images/api.ts
 import { readFile as readFile9 } from "fs/promises";
@@ -12401,7 +14510,7 @@ async function waitForReadyImage(deps, imageId, opts = {}) {
   let lastStatus = "unknown";
   while (Date.now() <= deadline) {
     const image = await getImage(deps, imageId);
-    lastStatus = image.status ?? "unknown";
+    lastStatus = image.status;
     if (image.status === "ready") {
       return image;
     }
@@ -12468,7 +14577,7 @@ async function publishCreative(args, deps = defaultImageApiDeps) {
     sourceReferenceUrl
   });
 }
-var publishCommand = defineCommand87({
+var publishCommand = defineCommand89({
   meta: {
     name: "publish",
     description: "Publish a final static creative image to Baker Creatives and print the creative reference JSON."
@@ -12514,7 +14623,7 @@ var publishCommand = defineCommand87({
 });
 
 // src/commands/creatives/index.ts
-var creativesCommand3 = defineCommand88({
+var creativesCommand3 = defineCommand90({
   meta: {
     name: "creatives",
     description: `Publish static ad creatives as first-class Baker outputs.
@@ -12530,10 +14639,10 @@ Publishing uploads the image to the Company image library, applies the official
 });
 
 // src/commands/ga4/index.ts
-import { defineCommand as defineCommand92 } from "citty";
+import { defineCommand as defineCommand94 } from "citty";
 
 // src/commands/ga4/audit.ts
-import { defineCommand as defineCommand89 } from "citty";
+import { defineCommand as defineCommand91 } from "citty";
 
 // src/commands/ga4/resolve.ts
 async function fetchProperties(useCache = true) {
@@ -12596,7 +14705,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
   }
 });
-var auditCommand2 = defineCommand89({
+var auditCommand2 = defineCommand91({
   meta: {
     name: "audit",
     description: `Run all GA4 admin health checks. Returns property config with playbook warnings.
@@ -12648,7 +14757,7 @@ Examples:
 });
 
 // src/commands/ga4/properties.ts
-import { defineCommand as defineCommand90 } from "citty";
+import { defineCommand as defineCommand92 } 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.",
@@ -12656,7 +14765,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
   }
 });
-var propertiesCommand = defineCommand90({
+var propertiesCommand = defineCommand92({
   meta: {
     name: "properties",
     description: `List accessible GA4 properties.
@@ -12704,9 +14813,9 @@ Examples:
 });
 
 // src/commands/ga4/query.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve2 } from "path";
-import { defineCommand as defineCommand91 } from "citty";
+import { defineCommand as defineCommand93 } from "citty";
 
 // src/commands/ga4/presets.ts
 var GA4_PRESETS = [
@@ -12795,7 +14904,7 @@ function writeRowsToFile2(filePath, rows, append) {
       writeFileSync4(filePath, content, "utf-8");
     }
   } else if (append && existsSync5(filePath)) {
-    const existing = JSON.parse(readFileSync7(filePath, "utf-8"));
+    const existing = JSON.parse(readFileSync8(filePath, "utf-8"));
     writeFileSync4(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync4(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -12838,7 +14947,7 @@ function handleError(err) {
   });
   process.exit(1);
 }
-var queryCommand2 = defineCommand91({
+var queryCommand2 = defineCommand93({
   meta: {
     name: "query",
     description: `Run GA4 Data API reports. Preset-first with free-form escape hatch.
@@ -12909,7 +15018,7 @@ Free-form (escape hatch):
 });
 
 // src/commands/ga4/index.ts
-var ga4Command = defineCommand92({
+var ga4Command = defineCommand94({
   meta: {
     name: "ga4",
     description: `Google Analytics 4 commands. Audit property config, run playbook-aligned reports.
@@ -12932,12 +15041,12 @@ Examples:
 });
 
 // src/commands/gsc/index.ts
-import { defineCommand as defineCommand96 } from "citty";
+import { defineCommand as defineCommand98 } from "citty";
 
 // src/commands/gsc/query.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
 import { resolve as resolve3 } from "path";
-import { defineCommand as defineCommand93 } from "citty";
+import { defineCommand as defineCommand95 } from "citty";
 
 // src/commands/gsc/presets.ts
 var GSC_PRESETS = [
@@ -13080,7 +15189,7 @@ function writeRowsToFile3(filePath, rows, append) {
       writeFileSync5(filePath, content, "utf-8");
     }
   } else if (append && existsSync6(filePath)) {
-    const existing = JSON.parse(readFileSync8(filePath, "utf-8"));
+    const existing = JSON.parse(readFileSync9(filePath, "utf-8"));
     writeFileSync5(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
     writeFileSync5(filePath, JSON.stringify(rows, null, 2), "utf-8");
@@ -13125,7 +15234,7 @@ function handleError2(err) {
   });
   process.exit(1);
 }
-var queryCommand3 = defineCommand93({
+var queryCommand3 = defineCommand95({
   meta: {
     name: "query",
     description: `Run GSC Search Analytics queries. Preset-first with free-form escape hatch.
@@ -13203,7 +15312,7 @@ Free-form (escape hatch):
 });
 
 // src/commands/gsc/sitemaps.ts
-import { defineCommand as defineCommand94 } from "citty";
+import { defineCommand as defineCommand96 } from "citty";
 registerSchema({
   command: "gsc.sitemaps",
   description: "List sitemaps for a Search Console site. Check sitemap health and errors.",
@@ -13212,7 +15321,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
   }
 });
-var sitemapsCommand = defineCommand94({
+var sitemapsCommand = defineCommand96({
   meta: {
     name: "sitemaps",
     description: `List sitemaps for a site. Check health and errors.
@@ -13262,7 +15371,7 @@ Examples:
 });
 
 // src/commands/gsc/sites.ts
-import { defineCommand as defineCommand95 } from "citty";
+import { defineCommand as defineCommand97 } from "citty";
 registerSchema({
   command: "gsc.sites",
   description: "List all verified Google Search Console sites. Returns site URLs needed for query and sitemaps commands.",
@@ -13270,7 +15379,7 @@ registerSchema({
     "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
   }
 });
-var sitesCommand = defineCommand95({
+var sitesCommand = defineCommand97({
   meta: {
     name: "sites",
     description: `List verified Search Console sites.
@@ -13318,7 +15427,7 @@ Examples:
 });
 
 // src/commands/gsc/index.ts
-var gscCommand = defineCommand96({
+var gscCommand = defineCommand98({
   meta: {
     name: "gsc",
     description: `Google Search Console commands. PPC-SEO arbitrage, brand halo analysis, negative keyword discovery.
@@ -13341,10 +15450,10 @@ Examples:
 });
 
 // src/commands/images/index.ts
-import { defineCommand as defineCommand120 } from "citty";
+import { defineCommand as defineCommand122 } from "citty";
 
 // src/commands/images/crop.ts
-import { defineCommand as defineCommand97 } from "citty";
+import { defineCommand as defineCommand99 } from "citty";
 
 // src/lib/image/crop-sprite.ts
 import sharp from "sharp";
@@ -13469,7 +15578,7 @@ function emitError2(err) {
   }
   process.exit(1);
 }
-var cropCommand = defineCommand97({
+var cropCommand = defineCommand99({
   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"
@@ -13505,7 +15614,7 @@ var cropCommand = defineCommand97({
 });
 
 // src/commands/images/delete.ts
-import { defineCommand as defineCommand98 } from "citty";
+import { defineCommand as defineCommand100 } from "citty";
 registerSchema({
   command: "images.delete",
   description: "Delete an image by ID",
@@ -13519,7 +15628,7 @@ registerSchema({
     }
   }
 });
-var deleteCommand = defineCommand98({
+var deleteCommand = defineCommand100({
   meta: {
     name: "delete",
     description: "Delete an image by ID. Use --dry-run to preview. Example: baker images delete j571abc123 --dry-run"
@@ -13560,7 +15669,7 @@ var deleteCommand = defineCommand98({
 });
 
 // src/commands/images/dimensions.ts
-import { defineCommand as defineCommand99 } from "citty";
+import { defineCommand as defineCommand101 } from "citty";
 
 // src/lib/image/dimensions.ts
 import { imageSize } from "image-size";
@@ -13583,7 +15692,7 @@ registerSchema({
     target: { type: "string", description: "Local file path or remote http(s) URL", required: true }
   }
 });
-var dimensionsCommand = defineCommand99({
+var dimensionsCommand = defineCommand101({
   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"
@@ -13627,7 +15736,7 @@ var dimensionsCommand = defineCommand99({
 });
 
 // src/commands/images/extract.ts
-import { defineCommand as defineCommand100 } from "citty";
+import { defineCommand as defineCommand102 } from "citty";
 registerSchema({
   command: "images.extract",
   description: "Extract images from a URL via Firecrawl (formats: images).",
@@ -13643,7 +15752,7 @@ registerSchema({
     }
   }
 });
-var extractCommand = defineCommand100({
+var extractCommand = defineCommand102({
   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"
@@ -13681,7 +15790,7 @@ var extractCommand = defineCommand100({
 });
 
 // src/commands/images/find.ts
-import { defineCommand as defineCommand101 } from "citty";
+import { defineCommand as defineCommand103 } from "citty";
 registerSchema({
   command: "images.find",
   description: "Fanout image search: library first, then opted-in external providers.",
@@ -13713,7 +15822,7 @@ registerSchema({
     }
   }
 });
-var findCommand = defineCommand101({
+var findCommand = defineCommand103({
   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"
@@ -13739,7 +15848,9 @@ var findCommand = defineCommand101({
         process.exit(1);
       }
       const body = { query };
-      if (args.sources) body.sources = args.sources.split(",").filter(Boolean);
+      if (args.sources) {
+        body.sources = args.sources.split(",").filter(Boolean);
+      }
       if (args.limit) body.limit = Number(args.limit);
       if (args.fallback) body.fallback = true;
       if (args.threshold) body.threshold = Number(args.threshold);
@@ -13760,7 +15871,7 @@ var findCommand = defineCommand101({
 
 // src/commands/images/generate.ts
 import { readFile as readFile11 } from "fs/promises";
-import { defineCommand as defineCommand102 } from "citty";
+import { defineCommand as defineCommand104 } from "citty";
 import sharp2 from "sharp";
 var GENERATE_TIMEOUT_MS = 18e4;
 var REFERENCE_MAX_EDGE = 1536;
@@ -13826,8 +15937,15 @@ function buildGenerateBody(args, prompt) {
   if (args["aspect-ratio"]) body.aspectRatio = args["aspect-ratio"];
   if (args["image-size"]) body.imageSize = args["image-size"];
   if (args.strength !== void 0) body.strength = Number(args.strength);
-  if (args["rgb-colors"]) body.rgbColors = parseJsonArg(args["rgb-colors"], "rgb-colors");
-  if (args["bg-rgb"]) body.backgroundRgbColor = parseJsonArg(args["bg-rgb"], "bg-rgb");
+  if (args["rgb-colors"]) {
+    body.rgbColors = parseJsonArg(args["rgb-colors"], "rgb-colors");
+  }
+  if (args["bg-rgb"]) {
+    body.backgroundRgbColor = parseJsonArg(
+      args["bg-rgb"],
+      "bg-rgb"
+    );
+  }
   if (args.context) body.descriptionContext = args.context;
   return body;
 }
@@ -13856,7 +15974,7 @@ async function resolveReferences(spec) {
   }
   return out;
 }
-var generateCommand = defineCommand102({
+var generateCommand = defineCommand104({
   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]]'"
@@ -13908,7 +16026,7 @@ var generateCommand = defineCommand102({
 });
 
 // src/commands/images/get.ts
-import { defineCommand as defineCommand103 } from "citty";
+import { defineCommand as defineCommand105 } from "citty";
 registerSchema({
   command: "images.get",
   description: "Get a single image by ID",
@@ -13916,7 +16034,7 @@ registerSchema({
     id: { type: "string", description: "Image ID", required: true }
   }
 });
-var getCommand2 = defineCommand103({
+var getCommand2 = defineCommand105({
   meta: { name: "get", description: "Get a single image by ID. Example: baker images get j571abc123" },
   args: {
     id: { type: "positional", description: "Image ID", required: false },
@@ -13952,7 +16070,7 @@ var getCommand2 = defineCommand103({
 });
 
 // src/commands/images/gif.ts
-import { defineCommand as defineCommand104 } from "citty";
+import { defineCommand as defineCommand106 } from "citty";
 registerSchema({
   command: "images.gif",
   description: "Search Giphy for GIFs / reaction memes (paid social creative).",
@@ -13984,7 +16102,7 @@ registerSchema({
     }
   }
 });
-var gifCommand = defineCommand104({
+var gifCommand = defineCommand106({
   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"
@@ -14031,7 +16149,7 @@ var gifCommand = defineCommand104({
 });
 
 // src/commands/images/google.ts
-import { defineCommand as defineCommand105 } from "citty";
+import { defineCommand as defineCommand107 } from "citty";
 registerSchema({
   command: "images.google",
   description: "Google Images search via the official Custom Search JSON API. Unverified source \u2014 inspect before placing.",
@@ -14067,7 +16185,7 @@ registerSchema({
     }
   }
 });
-var googleCommand2 = defineCommand105({
+var googleCommand2 = defineCommand107({
   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"
@@ -14115,7 +16233,7 @@ var googleCommand2 = defineCommand105({
 });
 
 // src/commands/images/icon.ts
-import { defineCommand as defineCommand106 } from "citty";
+import { defineCommand as defineCommand108 } from "citty";
 registerSchema({
   command: "images.icon",
   description: "Icon lookup via Iconify (200+ icon sets, free CDN).",
@@ -14141,7 +16259,7 @@ registerSchema({
     }
   }
 });
-var iconCommand = defineCommand106({
+var iconCommand = defineCommand108({
   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'"
@@ -14181,7 +16299,7 @@ var iconCommand = defineCommand106({
 });
 
 // src/commands/images/ingest.ts
-import { defineCommand as defineCommand107 } from "citty";
+import { defineCommand as defineCommand109 } from "citty";
 registerSchema({
   command: "images.ingest",
   description: "Ingest a remote image URL into the library (full describe + embed).",
@@ -14193,7 +16311,7 @@ registerSchema({
     context: { type: "string", description: "Description context hint", required: false }
   }
 });
-var ingestCommand = defineCommand107({
+var ingestCommand = defineCommand109({
   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"
@@ -14235,7 +16353,7 @@ var ingestCommand = defineCommand107({
 });
 
 // src/commands/images/library.ts
-import { defineCommand as defineCommand108 } from "citty";
+import { defineCommand as defineCommand110 } from "citty";
 registerSchema({
   command: "images.library",
   description: "Search the company image library. Returns only ready images.",
@@ -14261,7 +16379,7 @@ registerSchema({
     }
   }
 });
-var libraryCommand = defineCommand108({
+var libraryCommand = defineCommand110({
   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"
@@ -14318,7 +16436,7 @@ var libraryCommand = defineCommand108({
 });
 
 // src/commands/images/logo.ts
-import { defineCommand as defineCommand109 } from "citty";
+import { defineCommand as defineCommand111 } from "citty";
 registerSchema({
   command: "images.logo",
   description: "Brand logo lookup via Brandfetch CDN (fallback/404). Auto-ingests by default.",
@@ -14343,7 +16461,7 @@ registerSchema({
     }
   }
 });
-var logoCommand = defineCommand109({
+var logoCommand = defineCommand111({
   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"
@@ -14381,7 +16499,7 @@ var logoCommand = defineCommand109({
 });
 
 // src/commands/images/normalize.ts
-import { defineCommand as defineCommand110 } from "citty";
+import { defineCommand as defineCommand112 } from "citty";
 
 // src/lib/image/color-changer.ts
 import quantize from "quantize";
@@ -15113,7 +17231,7 @@ function coerceRawArgs(args) {
     "dry-run": bool(args["dry-run"])
   };
 }
-var normalizeCommand = defineCommand110({
+var normalizeCommand = defineCommand112({
   meta: {
     name: "normalize",
     description: `Normalize logos / images: declarative recolor + bg removal + trim + resize. Operates on local files; writes in-place by default.
@@ -15168,7 +17286,7 @@ Examples:
 });
 
 // src/commands/images/pinterest.ts
-import { defineCommand as defineCommand111 } from "citty";
+import { defineCommand as defineCommand113 } 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.",
@@ -15188,7 +17306,7 @@ registerSchema({
     }
   }
 });
-var pinterestCommand = defineCommand111({
+var pinterestCommand = defineCommand113({
   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'"
@@ -15228,7 +17346,7 @@ var pinterestCommand = defineCommand111({
 });
 
 // src/commands/images/screenshot.ts
-import { defineCommand as defineCommand112 } from "citty";
+import { defineCommand as defineCommand114 } from "citty";
 registerSchema({
   command: "images.screenshot",
   description: "Capture a website screenshot via ScreenshotOne. Auto-ingests on success.",
@@ -15244,7 +17362,7 @@ registerSchema({
     }
   }
 });
-var screenshotCommand = defineCommand112({
+var screenshotCommand = defineCommand114({
   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"
@@ -15294,7 +17412,7 @@ var screenshotCommand = defineCommand112({
 });
 
 // src/commands/images/search.ts
-import { defineCommand as defineCommand113 } from "citty";
+import { defineCommand as defineCommand115 } from "citty";
 registerSchema({
   command: "images.search",
   description: "Search images by text query. Only returns ready images.",
@@ -15310,7 +17428,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand = defineCommand113({
+var searchCommand = defineCommand115({
   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"
@@ -15370,7 +17488,7 @@ var searchCommand = defineCommand113({
 });
 
 // src/commands/images/sticker.ts
-import { defineCommand as defineCommand114 } from "citty";
+import { defineCommand as defineCommand116 } from "citty";
 registerSchema({
   command: "images.sticker",
   description: "Search Giphy stickers \u2014 transparent-background overlays for ad creative.",
@@ -15402,7 +17520,7 @@ registerSchema({
     }
   }
 });
-var stickerCommand = defineCommand114({
+var stickerCommand = defineCommand116({
   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"
@@ -15449,7 +17567,7 @@ var stickerCommand = defineCommand114({
 });
 
 // src/commands/images/stock.ts
-import { defineCommand as defineCommand115 } from "citty";
+import { defineCommand as defineCommand117 } from "citty";
 registerSchema({
   command: "images.stock",
   description: "Stock photo, vector illustration, icon-set, and PSD search via Magnific (Freepik's developer API).",
@@ -15507,7 +17625,7 @@ registerSchema({
     }
   }
 });
-var stockCommand = defineCommand115({
+var stockCommand = defineCommand117({
   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"
@@ -15563,7 +17681,7 @@ var stockCommand = defineCommand115({
 });
 
 // src/lib/tags-command.ts
-import { defineCommand as defineCommand116 } from "citty";
+import { defineCommand as defineCommand118 } from "citty";
 function makeTagsCommand(command, label, endpoint) {
   registerSchema({
     command: `${command}.tags`,
@@ -15572,7 +17690,7 @@ function makeTagsCommand(command, label, endpoint) {
       output: { type: "string", description: "Output format: md|json", required: false, default: "md" }
     }
   });
-  return defineCommand116({
+  return defineCommand118({
     meta: {
       name: "tags",
       description: `List the available ${label} tag names (defaults + company custom tags). Use before filtering with --tags. Example: baker ${command} tags`
@@ -15608,7 +17726,7 @@ function makeTagsCommand(command, label, endpoint) {
 var tagsCommand2 = makeTagsCommand("images", "image", "/api/images/tags");
 
 // src/commands/images/upload.ts
-import { defineCommand as defineCommand117 } from "citty";
+import { defineCommand as defineCommand119 } from "citty";
 registerSchema({
   command: "images.upload",
   description: "Upload an image to the library \u2014 local file path or remote http(s) URL.",
@@ -15646,7 +17764,7 @@ registerSchema({
 function isRemoteUrl2(value) {
   return /^https?:\/\//i.test(value);
 }
-var uploadCommand = defineCommand117({
+var uploadCommand = defineCommand119({
   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'"
@@ -15739,7 +17857,7 @@ async function uploadLocal(target, args) {
 }
 
 // src/commands/images/upscale.ts
-import { defineCommand as defineCommand118 } from "citty";
+import { defineCommand as defineCommand120 } 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).",
@@ -15754,7 +17872,7 @@ registerSchema({
   }
 });
 var POLL_INTERVAL_MS3 = 1500;
-var upscaleCommand = defineCommand118({
+var upscaleCommand = defineCommand120({
   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"
@@ -15783,10 +17901,10 @@ var upscaleCommand = defineCommand118({
           writeJson({ ok: true, data: { imageId, status: "completed", image: doc } });
           return;
         }
-        if (doc.upscaleConfig?.status === "error") {
+        if (!doc.upscaleConfig) {
           writeJson({
             ok: false,
-            error: { code: "IMAGE_PROCESSING_ERROR", message: doc.upscaleConfig.error ?? "Upscale failed" }
+            error: { code: "IMAGE_PROCESSING_ERROR", message: "Upscale failed" }
           });
           process.exit(1);
         }
@@ -15809,7 +17927,7 @@ var upscaleCommand = defineCommand118({
 });
 
 // src/commands/images/use.ts
-import { defineCommand as defineCommand119 } from "citty";
+import { defineCommand as defineCommand121 } from "citty";
 registerSchema({
   command: "images.use",
   description: "Ingest a URL and wait for the library record to be ready.",
@@ -15825,7 +17943,7 @@ registerSchema({
   }
 });
 var POLL_INTERVAL_MS4 = 1500;
-var useCommand = defineCommand119({
+var useCommand = defineCommand121({
   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"
@@ -15871,7 +17989,7 @@ var useCommand = defineCommand119({
 });
 
 // src/commands/images/index.ts
-var imagesCommand = defineCommand120({
+var imagesCommand = defineCommand122({
   meta: {
     name: "images",
     description: `Find, source, and normalize images. Subcommands route by provider so cost + license are explicit.
@@ -15941,10 +18059,10 @@ Paid transforms (run on the Convex backend, cost-tracked):
 });
 
 // src/commands/research/index.ts
-import { defineCommand as defineCommand131 } from "citty";
+import { defineCommand as defineCommand133 } from "citty";
 
 // src/commands/research/advertisers.ts
-import { defineCommand as defineCommand121 } from "citty";
+import { defineCommand as defineCommand123 } 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.";
@@ -16057,7 +18175,7 @@ var FIELDS3 = {
   etv: "Estimated traffic value (USD)",
   visibility: "SERP visibility score (0-1)"
 };
-var advertisersCommand = defineCommand121({
+var advertisersCommand = defineCommand123({
   meta: {
     name: "advertisers",
     description: `Find domains competing for a keyword in Google SERPs.
@@ -16104,7 +18222,7 @@ Examples:
 });
 
 // src/commands/research/autocomplete.ts
-import { defineCommand as defineCommand122 } from "citty";
+import { defineCommand as defineCommand124 } 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).",
@@ -16127,7 +18245,7 @@ registerSchema({
 var FIELDS4 = {
   suggestion: "Autocomplete suggestion from Google"
 };
-var autocompleteCommand = defineCommand122({
+var autocompleteCommand = defineCommand124({
   meta: {
     name: "autocomplete",
     description: `Get Google Autocomplete suggestions for keyword expansion.
@@ -16173,7 +18291,7 @@ Examples:
 });
 
 // src/commands/research/countries.ts
-import { defineCommand as defineCommand123 } from "citty";
+import { defineCommand as defineCommand125 } from "citty";
 registerSchema({
   command: "research.countries",
   description: "List all supported country codes for --location flag in research commands.",
@@ -16230,7 +18348,7 @@ var FIELDS5 = {
   code: "Country code to pass as --location",
   name: "Country name"
 };
-var countriesCommand = defineCommand123({
+var countriesCommand = defineCommand125({
   meta: {
     name: "countries",
     description: "List all supported country codes for --location flag."
@@ -16241,7 +18359,7 @@ var countriesCommand = defineCommand123({
 });
 
 // src/commands/research/intent.ts
-import { defineCommand as defineCommand124 } from "citty";
+import { defineCommand as defineCommand126 } 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.",
@@ -16264,7 +18382,7 @@ var FIELDS6 = {
   intent: "Primary Google Search intent: informational, navigational, commercial, transactional",
   probability: "Confidence score 0.0-1.0"
 };
-var intentCommand = defineCommand124({
+var intentCommand = defineCommand126({
   meta: {
     name: "intent",
     description: `Classify Google Search intent for keywords. Returns intent type and confidence.
@@ -16312,7 +18430,7 @@ Examples:
 });
 
 // src/commands/research/keyword-gap.ts
-import { defineCommand as defineCommand125 } from "citty";
+import { defineCommand as defineCommand127 } 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.",
@@ -16341,7 +18459,7 @@ var FIELDS7 = {
   cpc: "Cost per click USD",
   their_position: "Competitor's ranking position"
 };
-var keywordGapCommand = defineCommand125({
+var keywordGapCommand = defineCommand127({
   meta: {
     name: "keyword-gap",
     description: `Find keywords a competitor has that you don't. Supports pagination via --offset.
@@ -16415,7 +18533,7 @@ Examples:
 });
 
 // src/commands/research/keywords-for-site.ts
-import { defineCommand as defineCommand126 } from "citty";
+import { defineCommand as defineCommand128 } 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.",
@@ -16448,7 +18566,7 @@ var FIELDS8 = {
   competition: "LOW, MEDIUM, or HIGH",
   competition_index: "Competition score 0-100"
 };
-var keywordsForSiteCommand = defineCommand126({
+var keywordsForSiteCommand = defineCommand128({
   meta: {
     name: "keywords-for-site",
     description: `Get keywords a competitor targets in Google. Use --type to filter paid/organic.
@@ -16501,7 +18619,7 @@ Examples:
 });
 
 // src/commands/research/languages.ts
-import { defineCommand as defineCommand127 } from "citty";
+import { defineCommand as defineCommand129 } from "citty";
 registerSchema({
   command: "research.languages",
   description: "List all supported language codes for --language flag in research commands.",
@@ -16531,7 +18649,7 @@ var FIELDS9 = {
   code: "Language code to pass as --language",
   name: "Language name (also accepted by --language)"
 };
-var languagesCommand2 = defineCommand127({
+var languagesCommand2 = defineCommand129({
   meta: {
     name: "languages",
     description: "List all supported language codes for --language flag."
@@ -16542,7 +18660,7 @@ var languagesCommand2 = defineCommand127({
 });
 
 // src/commands/research/lighthouse.ts
-import { defineCommand as defineCommand128 } from "citty";
+import { defineCommand as defineCommand130 } from "citty";
 registerSchema({
   command: "research.lighthouse",
   description: "Landing page performance audit. Returns metrics that affect Google Ads Quality Score and CPC.",
@@ -16561,7 +18679,7 @@ var FIELDS10 = {
   speed_index_ms: "Speed Index in ms (good: < 3400)",
   interactive_ms: "Time to Interactive in ms (good: < 3800)"
 };
-var lighthouseCommand = defineCommand128({
+var lighthouseCommand = defineCommand130({
   meta: {
     name: "lighthouse",
     description: `Landing page performance audit. Metrics affecting Google Ads Quality Score.
@@ -16599,7 +18717,7 @@ Examples:
 });
 
 // src/commands/research/relevant-pages.ts
-import { defineCommand as defineCommand129 } from "citty";
+import { defineCommand as defineCommand131 } 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).",
@@ -16625,7 +18743,7 @@ var FIELDS11 = {
   keywords: "Total organic keywords the page ranks for",
   top_10: "Keywords in positions 1-10"
 };
-var relevantPagesCommand = defineCommand129({
+var relevantPagesCommand = defineCommand131({
   meta: {
     name: "relevant-pages",
     description: `Get the top pages of a competitor domain with traffic data.
@@ -16671,7 +18789,7 @@ Examples:
 });
 
 // src/commands/research/web.ts
-import { defineCommand as defineCommand130 } from "citty";
+import { defineCommand as defineCommand132 } 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).",
@@ -16722,7 +18840,7 @@ async function runDeepResearch(question) {
   }
   throw new Error("Deep research timed out");
 }
-var webCommand = defineCommand130({
+var webCommand = defineCommand132({
   meta: {
     name: "web",
     description: `Search the web with AI to answer any open-ended marketing question. Uses live internet data via Google Search.
@@ -16782,7 +18900,7 @@ Examples:
 });
 
 // src/commands/research/index.ts
-var researchCommand = defineCommand131({
+var researchCommand = defineCommand133({
   meta: {
     name: "research",
     description: `Competitive intelligence and AI-powered research commands.
@@ -16822,10 +18940,10 @@ Examples:
 });
 
 // src/commands/scheduled-actions/index.ts
-import { defineCommand as defineCommand138 } from "citty";
+import { defineCommand as defineCommand140 } from "citty";
 
 // src/commands/scheduled-actions/create.ts
-import { defineCommand as defineCommand132 } from "citty";
+import { defineCommand as defineCommand134 } from "citty";
 
 // src/commands/scheduled-actions/shared.ts
 var TEMP_SCHEDULED_ACTION_PREFIX = "temp_sched_";
@@ -16940,7 +19058,7 @@ registerSchema({
     prompt: { type: "string", description: "Additional prompt instructions for the spawned agent", required: false }
   }
 });
-var createCommand2 = defineCommand132({
+var createCommand2 = defineCommand134({
   meta: {
     name: "create",
     description: 'Stage a scheduled action. Example: baker scheduled-actions create --name "Weekly report" --description "..." --cron "0 9 * * MON"'
@@ -16989,7 +19107,7 @@ var createCommand2 = defineCommand132({
 });
 
 // src/commands/scheduled-actions/delete.ts
-import { defineCommand as defineCommand133 } from "citty";
+import { defineCommand as defineCommand135 } from "citty";
 registerSchema({
   command: "scheduled-actions.delete",
   description: "Stage deletion of a published scheduled action or cancellation of a temp_sched_* draft creation.",
@@ -16997,7 +19115,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID or temp_sched_* draft ID", required: true }
   }
 });
-var deleteCommand2 = defineCommand133({
+var deleteCommand2 = defineCommand135({
   meta: {
     name: "delete",
     description: "Stage scheduled action deletion. Example: baker scheduled-actions delete <id-or-temp_sched_id>"
@@ -17026,7 +19144,7 @@ var deleteCommand2 = defineCommand133({
 });
 
 // src/commands/scheduled-actions/get.ts
-import { defineCommand as defineCommand134 } from "citty";
+import { defineCommand as defineCommand136 } from "citty";
 registerSchema({
   command: "scheduled-actions.get",
   description: "Get a published scheduled action or a temp_sched_* draft-created scheduled action.",
@@ -17034,7 +19152,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID or temp_sched_* draft ID", required: true }
   }
 });
-var getCommand3 = defineCommand134({
+var getCommand3 = defineCommand136({
   meta: {
     name: "get",
     description: "Get a scheduled action. Example: baker scheduled-actions get <id-or-temp_sched_id>"
@@ -17071,13 +19189,13 @@ var getCommand3 = defineCommand134({
 });
 
 // src/commands/scheduled-actions/list.ts
-import { defineCommand as defineCommand135 } from "citty";
+import { defineCommand as defineCommand137 } from "citty";
 registerSchema({
   command: "scheduled-actions.list",
   description: "List published scheduled actions. Includes draft state when BAKER_CHAT_ID is set.",
   args: {}
 });
-var listCommand3 = defineCommand135({
+var listCommand4 = defineCommand137({
   meta: {
     name: "list",
     description: "List scheduled actions. Includes staged draft ops when BAKER_CHAT_ID is set."
@@ -17098,7 +19216,7 @@ var listCommand3 = defineCommand135({
 });
 
 // src/commands/scheduled-actions/trigger.ts
-import { defineCommand as defineCommand136 } from "citty";
+import { defineCommand as defineCommand138 } 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.",
@@ -17106,7 +19224,7 @@ registerSchema({
     id: { type: "string", description: "Published scheduled action ID", required: true }
   }
 });
-var triggerCommand = defineCommand136({
+var triggerCommand = defineCommand138({
   meta: {
     name: "trigger",
     description: "Immediately trigger a published scheduled action. Example: baker scheduled-actions trigger <id>"
@@ -17143,7 +19261,7 @@ var triggerCommand = defineCommand136({
 });
 
 // src/commands/scheduled-actions/update.ts
-import { defineCommand as defineCommand137 } from "citty";
+import { defineCommand as defineCommand139 } from "citty";
 registerSchema({
   command: "scheduled-actions.update",
   description: "Stage an update to a published scheduled action or temp_sched_* draft-created scheduled action.",
@@ -17168,7 +19286,7 @@ registerSchema({
     prompt: { type: "string", description: "Replacement additional spawned-agent instructions", required: false }
   }
 });
-var updateCommand2 = defineCommand137({
+var updateCommand2 = defineCommand139({
   meta: {
     name: "update",
     description: "Stage a scheduled action update. Example: baker scheduled-actions update <id> --enabled false"
@@ -17239,7 +19357,7 @@ var updateCommand2 = defineCommand137({
 });
 
 // src/commands/scheduled-actions/index.ts
-var scheduledActionsCommand = defineCommand138({
+var scheduledActionsCommand = defineCommand140({
   meta: {
     name: "scheduled-actions",
     description: `Manage Scheduled Actions. Subcommands: list, get, create, update, delete, trigger.
@@ -17255,7 +19373,7 @@ Examples:
   baker scheduled-actions trigger <id>`
   },
   subCommands: {
-    list: listCommand3,
+    list: listCommand4,
     get: getCommand3,
     create: createCommand2,
     update: updateCommand2,
@@ -17265,8 +19383,8 @@ Examples:
 });
 
 // src/commands/schema.ts
-import { defineCommand as defineCommand139 } from "citty";
-var schemaCommand = defineCommand139({
+import { defineCommand as defineCommand141 } from "citty";
+var schemaCommand = defineCommand141({
   meta: {
     name: "schema",
     description: "Inspect command argument schemas (for AI agent introspection). Lists all commands if no argument given. Example: baker schema images.search"
@@ -17302,10 +19420,10 @@ var schemaCommand = defineCommand139({
 });
 
 // src/commands/testimonials/index.ts
-import { defineCommand as defineCommand143 } from "citty";
+import { defineCommand as defineCommand145 } from "citty";
 
 // src/commands/testimonials/get.ts
-import { defineCommand as defineCommand140 } from "citty";
+import { defineCommand as defineCommand142 } from "citty";
 registerSchema({
   command: "testimonials.get",
   description: "Get a single testimonial by ID",
@@ -17313,7 +19431,7 @@ registerSchema({
     id: { type: "string", description: "Testimonial ID", required: true }
   }
 });
-var getCommand4 = defineCommand140({
+var getCommand4 = defineCommand142({
   meta: { name: "get", description: "Get a single testimonial by ID. Example: baker testimonials get j571abc123" },
   args: {
     id: { type: "positional", description: "Testimonial ID", required: false },
@@ -17350,7 +19468,7 @@ var getCommand4 = defineCommand140({
 });
 
 // src/commands/testimonials/list.ts
-import { defineCommand as defineCommand141 } from "citty";
+import { defineCommand as defineCommand143 } from "citty";
 registerSchema({
   command: "testimonials.list",
   description: "List testimonials with optional filters.",
@@ -17380,7 +19498,7 @@ registerSchema({
     limit: { type: "number", description: "Max results (default 50)", required: false, default: 50 }
   }
 });
-var listCommand4 = defineCommand141({
+var listCommand5 = defineCommand143({
   meta: {
     name: "list",
     description: "List testimonials with optional filters. Example: baker testimonials list --source google --sentiment positive"
@@ -17429,7 +19547,7 @@ var listCommand4 = defineCommand141({
 });
 
 // src/commands/testimonials/search.ts
-import { defineCommand as defineCommand142 } from "citty";
+import { defineCommand as defineCommand144 } from "citty";
 registerSchema({
   command: "testimonials.search",
   description: "Search testimonials by text query. Uses hybrid BM25 + vector + reranking.",
@@ -17460,7 +19578,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand2 = defineCommand142({
+var searchCommand2 = defineCommand144({
   meta: {
     name: "search",
     description: "Semantic search testimonials by text query. Uses hybrid BM25 + vector + reranking. Example: baker testimonials search 'great service' --rating-min 4"
@@ -17534,7 +19652,7 @@ var searchCommand2 = defineCommand142({
 var tagsCommand3 = makeTagsCommand("testimonials", "testimonial", "/api/testimonials/tags");
 
 // src/commands/testimonials/index.ts
-var testimonialsCommand = defineCommand143({
+var testimonialsCommand = defineCommand145({
   meta: {
     name: "testimonials",
     description: `Find and browse testimonials in Baker. Subcommands: search, get, list, tags.
@@ -17549,16 +19667,16 @@ Examples:
   subCommands: {
     get: getCommand4,
     search: searchCommand2,
-    list: listCommand4,
+    list: listCommand5,
     tags: tagsCommand3
   }
 });
 
 // src/commands/videos/index.ts
-import { defineCommand as defineCommand148 } from "citty";
+import { defineCommand as defineCommand150 } from "citty";
 
 // src/commands/videos/delete.ts
-import { defineCommand as defineCommand144 } from "citty";
+import { defineCommand as defineCommand146 } from "citty";
 registerSchema({
   command: "videos.delete",
   description: "Delete a video by ID",
@@ -17572,7 +19690,7 @@ registerSchema({
     }
   }
 });
-var deleteCommand3 = defineCommand144({
+var deleteCommand3 = defineCommand146({
   meta: {
     name: "delete",
     description: "Delete a video by ID. Use --dry-run to preview. Example: baker videos delete j571abc123 --dry-run"
@@ -17613,7 +19731,7 @@ var deleteCommand3 = defineCommand144({
 });
 
 // src/commands/videos/get.ts
-import { defineCommand as defineCommand145 } from "citty";
+import { defineCommand as defineCommand147 } from "citty";
 registerSchema({
   command: "videos.get",
   description: "Get a single video by ID",
@@ -17621,7 +19739,7 @@ registerSchema({
     id: { type: "string", description: "Video ID", required: true }
   }
 });
-var getCommand5 = defineCommand145({
+var getCommand5 = defineCommand147({
   meta: { name: "get", description: "Get a single video by ID. Example: baker videos get j571abc123" },
   args: {
     id: { type: "positional", description: "Video ID", required: false },
@@ -17658,7 +19776,7 @@ var getCommand5 = defineCommand145({
 });
 
 // src/commands/videos/search.ts
-import { defineCommand as defineCommand146 } from "citty";
+import { defineCommand as defineCommand148 } from "citty";
 registerSchema({
   command: "videos.search",
   description: "Search videos by text query. Only returns ready videos.",
@@ -17668,7 +19786,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand3 = defineCommand146({
+var searchCommand3 = defineCommand148({
   meta: {
     name: "search",
     description: "Semantic search videos by text query. Uses hybrid BM25 + vector + reranking. Example: baker videos search 'product demo' --tags tutorial"
@@ -17720,7 +19838,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 defineCommand147 } from "citty";
+import { defineCommand as defineCommand149 } from "citty";
 var MIME_MAP = {
   ".mp4": "video/mp4",
   ".mov": "video/quicktime",
@@ -17754,7 +19872,7 @@ function detectContentType(filePath) {
   }
   return mime;
 }
-var uploadCommand2 = defineCommand147({
+var uploadCommand2 = defineCommand149({
   meta: {
     name: "upload",
     description: "Upload a video file to Baker via Mux direct upload. Auto-detects content type. Example: baker videos upload ./demo.mp4"
@@ -17808,7 +19926,7 @@ var uploadCommand2 = defineCommand147({
 });
 
 // src/commands/videos/index.ts
-var videosCommand = defineCommand148({
+var videosCommand = defineCommand150({
   meta: {
     name: "videos",
     description: `Find and manage videos in Baker. Subcommands: search, get, upload, delete, tags.
@@ -17831,10 +19949,10 @@ Examples:
 });
 
 // src/commands/winning-ads/index.ts
-import { defineCommand as defineCommand151 } from "citty";
+import { defineCommand as defineCommand153 } from "citty";
 
 // src/commands/winning-ads/advertisers.ts
-import { defineCommand as defineCommand149 } from "citty";
+import { defineCommand as defineCommand151 } 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).",
@@ -17847,7 +19965,7 @@ registerSchema({
 function identity(record) {
   return record;
 }
-var advertisersCommand2 = defineCommand149({
+var advertisersCommand2 = defineCommand151({
   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'
@@ -17898,7 +20016,7 @@ var advertisersCommand2 = defineCommand149({
 });
 
 // src/commands/winning-ads/search.ts
-import { defineCommand as defineCommand150 } from "citty";
+import { defineCommand as defineCommand152 } 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.",
@@ -18006,7 +20124,7 @@ function buildSearchBody(args) {
   }
   return body;
 }
-var searchCommand4 = defineCommand150({
+var searchCommand4 = defineCommand152({
   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"
@@ -18118,7 +20236,7 @@ var searchCommand4 = defineCommand150({
 });
 
 // src/commands/winning-ads/index.ts
-var winningAdsCommand = defineCommand151({
+var winningAdsCommand = defineCommand153({
   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.
@@ -18142,7 +20260,7 @@ Examples:
 });
 
 // src/version.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 function packageJsonUrl() {
   return new URL("../package.json", import.meta.url);
 }
@@ -18154,11 +20272,11 @@ function parsePackageVersion(raw) {
   throw new Error("Invalid CLI package.json: missing version");
 }
 function getCliVersion() {
-  return parsePackageVersion(readFileSync9(packageJsonUrl(), "utf8"));
+  return parsePackageVersion(readFileSync10(packageJsonUrl(), "utf8"));
 }
 
 // src/cli.ts
-var main = defineCommand152({
+var main = defineCommand154({
   meta: {
     name: "baker",
     version: getCliVersion(),