@koda-sl/baker-cli 0.121.0-dev.87e882ae1 → 0.121.0-dev.ea15b0199

package/README.md

@@ -1142,7 +1142,7 @@ Notes:
 - All write commands take `--file <json>` payloads; explicit flags override file keys. `baker schema ads.linkedin.campaigns.create` for exact args.
 - Money flags (`--bid`, `--daily-budget`, `--total-budget`) require `--currency`.
 - Creative media comes from the Baker library (`--image-id`/`--video-id` from `baker images`/`baker videos` — uploaded to LinkedIn at publish) or as LinkedIn URNs (`--image-urn`/`--video-urn`). Formats: `image|video|text|spotlight|follower|document|carousel|conversation|tla|jobs`; complex formats take `--file` with the full content object; conversation ads take `--file` with the message flow (`{message: {subject, body, senderName?, buttons[]}}` — buttons `NESTED` (with `nestedMessage`) or `LANDING_PAGE` (with `landingPageUrl`), ≤25 messages, bodies ≤500 chars, labels ≤25). Limits: headline ≤70, text-ad 25/75, intro soft-truncates at 600 chars. TLA sponsors an existing post via `--post-urn`.
-- Lead forms are file-first (`lead-forms create --file form.json`). Required: name, headline (≤60), privacyPolicyUrl, questions[] (≤12; playbook: ≤4 for completion). Each question is a predefined profile field (`{ name, predefinedField: "EMAIL" }` — Contact/Work/Company/Education/Demographic library) or a custom question (`{ name, questionType: "SINGLE_LINE_TEXT" | "MULTIPLE_CHOICE", options?: [...] }`; ≤3 custom, MULTIPLE_CHOICE needs 2–30 options). Also supported: `locale {country,language}`, `formImageId`/`formImageUrn` (banner), `consents[]` (≤5 disclosure checkboxes `{text, required}`), `hiddenFields[]` (≤20 `{name, value}` tracking fields), `legalDisclaimer`, `thankYou {message, cta, landingUrl | appointmentUrl}` (Calendly/Chili Piper booking link). The staged preview emits non-blocking best-practice warnings when a form has no qualifying question, no confirmation message/action, or no consent checkbox.
+- Lead forms are file-first (`lead-forms create --file form.json`). Required: name, headline (≤60), privacyPolicyUrl, questions[] (≤12; playbook: ≤4 for completion). Each question is a predefined profile field (`{ name, predefinedField: "EMAIL" }` — Contact/Work/Company/Education/Demographic library) or a custom question (`{ name, questionType: "SINGLE_LINE_TEXT" | "MULTIPLE_CHOICE", options?: [...] }`; ≤3 custom, MULTIPLE_CHOICE needs 2–30 options). Also supported: `locale {country,language}`, `formImageId`/`formImageUrn` (banner), `privacyPolicyText`, `consents[]` (≤5 disclosure checkboxes `{text, required}`), `hiddenFields[]` (≤20 `{name, value}` tracking fields), `legalDisclaimer`, `thankYou {message, cta, landingUrl | appointmentUrl}` (Calendly/Chili Piper booking link). The staged preview emits non-blocking best-practice warnings when a form has no qualifying question, no confirmation message/action, or no consent checkbox.
 
 #### `audit` — playbook diagnostic
 
@@ -2504,22 +2504,26 @@ Rules:
 
 ### Marketing Tags (`baker tags`)
 
-Read the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, PostHog, …) — production tags overlaid with the changes staged in this chat.
-
-**The CLI is read-only.** Every tag change (create, edit, delete) goes through the `request_tag_input` tool (`baker_ui` MCP server): the agent proposes one or more changes — each becomes a tab in one blocking approval form — pre-filling the non-secret fields it knows; the user reviews, edits, fills secret fields, and approves or skips each tab. Approved changes stage on the chat and apply when the chat is published; discarding the chat drops them.
+Manage the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, PostHog, …) as per-chat **staged** changes. Nothing touches production tags until the chat is published; discarding the chat drops the draft.
 
 `BAKER_CHAT_ID` must be set.
 
 ```bash
-baker tags list       # effective view: production + staged, with secret status
-baker tags draft      # review the staged changes awaiting publish
+baker tags list                                              # effective view: production + staged, with secret status
+baker tags add clarity --set projectId=abcde12345            # client-only tag, no secrets needed
+baker tags add meta --set pixelId=123 --request-secret accessToken
+baker tags update <ref> --set pixelId=999 --clear testEventCode
+baker tags remove <ref>                                      # stage deletion (tag_temp_* ref drops the staged create)
+baker tags draft                                             # review staged ops
+baker tags draft remove <ref>                                # drop one staged op
+baker tags draft clear                                       # drop everything staged
 ```
 
 Notes:
 
-- **Secrets never travel through this CLI or the chat.** Secret fields (`accessToken`, `apiSecret`, `authorizationToken`, `apiKey`, `conversionToken`, `oauthProviderId`) are entered only in the dashboard's secure tag form and flow straight into the staged draft; tool responses only ever name which secret fields are set/pending.
-- Staged creates get a server-generated `tag_temp_*` ref (returned in the tool result and printed by `list`). Use it (or a real tag id) as flow side-effect `tagIds` — the published tag keeps resolving under the temp ref.
-- Proposing a delete on a `tag_temp_*` ref drops the staged create instead.
+- **Secrets never travel through this CLI.** Secret fields (`accessToken`, `apiSecret`, `authorizationToken`, `apiKey`, `conversionToken`, `oauthProviderId`) are rejected in `--set`. Stage with `--request-secret <field>`; the user provides values via the secure tag form in the chat (`request_tag_input`), which writes them straight into the staged draft. Responses only ever name which secret fields are set/pending.
+- Staged creates get a server-generated `tag_temp_*` ref. Use it (or a real tag id) as flow side-effect `tagIds` — the published tag keeps resolving under the temp ref.
+- `update`/`remove` with a `tag_temp_*` ref amend/drop the staged create in place.
 - Single-instance types (`code`, `posthog`, `datafast`) reject a second instance against the chat's effective view.
 - Conflicts at publish (tag deleted in the dashboard, config invalid) skip the op with a recorded reason — they never block the publish.
 
@@ -4541,7 +4545,6 @@ This CLI is designed for AI agent consumption. Key patterns:
 - **0.105.0**: `baker images ...`, `baker videos ...`, and `baker testimonials ...` commands now type their `/api/{images,videos,testimonials}/...` request/response payloads from the shared `@baker/api` contract package instead of hand-written local interfaces. No command, flag, or output-shape changes.
 - **0.106.0**: `baker ads linkedin` gains staged write commands — `campaign-groups`/`campaigns`/`creatives` create|update|pause|resume|(archive|)duplicate, `audiences create|upload`, `conversions create|update`, `lead-forms create|update`, plus `draft [remove|clear]` for review/undo. Ops validate at stage time, apply on chat publish, and run simulated (`urn:li:simulated:*`) unless LinkedIn writes are enabled for the company.
 - **0.116.0**: `lead-forms create` models the full Campaign Manager form — `locale`, form banner image (`formImageId`/`formImageUrn`), predefined profile-field questions (validated enum) vs custom questions (`SINGLE_LINE_TEXT`/`MULTIPLE_CHOICE` with `options`, ≤3 custom), `privacyPolicyText`, disclosure `consents[]` (≤5), tracking `hiddenFields[]` (≤20), and `thankYou` confirmation CTA + landing/appointment link. Staged preview surfaces best-practice warnings (no qualifying question, no confirmation, no consent). No breaking flag changes.
-- **0.121.0**: `lead-forms create` drops the `privacyPolicyText` field — LinkedIn's versioned lead-form API has no privacy-policy-text slot, so it was silently discarded on publish. Use `legalDisclaimer` (shown under the form) or `consents[]` (disclosure checkboxes) instead. (Companion backend fix: staged lead-form questions were serialized in a shape LinkedIn dropped — they now publish correctly, and the staged preview lists each question.)
 - **0.119.0**: `draft amend`/`draft show` land on both `baker ads google` and `baker ads linkedin` — a generic JSON-merge-patch to update any staged op in place plus a full-payload receipt, replacing remove+recreate as the correction path. Google gains `assets update` and `asset-groups create|update` (Performance Max asset groups are now their own entity — `ads create --format performanceMaxAssetGroup` never worked and is gone); `ads create --format video` moves from a bare YouTube id to `--video-assets` refs (**breaking flag change** — stage the video as an asset first); `--format demandGen` gains `--image-assets`/`--square-image-assets`/`--logo-image-assets` and flag-building for headlines/descriptions. LinkedIn's `draft list` now renders a readable Campaign group ▸ Campaign ▸ Creative tree by default (`--json` for raw), `creatives update` gains `--campaign` (re-parent while staged), and `campaigns update` passes create-only fields (`--group`/`--type`/`--locale`/`--associated-entity`) through when amending a `li_temp_*` staged create instead of always stripping them.
 
 ## Publishing

package/dist/cli.js

@@ -848,6 +848,7 @@ var LINKEDIN_LIMITS = {
     choiceOptionsMax: 30,
     choiceOptionTextMax: 100,
     thankYouMessageMax: 300,
+    privacyPolicyTextMax: 2e3,
     legalDisclaimerMax: 2e3,
     consentsMax: 5,
     // Campaign Manager caps disclosure checkboxes at 5
@@ -1442,6 +1443,7 @@ var leadFormFields = {
   /** Form language, e.g. { country: "US", language: "en" }. Defaults to the account locale on LinkedIn. */
   locale: z2.object({ country: z2.string().length(2), language: z2.string().length(2) }).optional(),
   privacyPolicyUrl: httpsUrlSchema,
+  privacyPolicyText: z2.string().max(LEAD.privacyPolicyTextMax).optional(),
   questions: z2.array(leadFormQuestionSchema).min(1).max(LEAD.questionsMax),
   consents: z2.array(leadFormConsentSchema).max(LEAD.consentsMax).optional(),
   hiddenFields: z2.array(leadFormHiddenFieldSchema).max(LEAD.hiddenFieldsMax).optional(),
@@ -1939,6 +1941,46 @@ var TAG_TYPES = [
   "twitterAds"
 ];
 var tagTypeSchema = z5.enum(TAG_TYPES);
+var TAG_SECRET_FIELDS = {
+  meta: ["accessToken"],
+  amplitude: [],
+  googleAds: ["oauthProviderId", "customerAccountId", "customerId", "loginCustomerId"],
+  tiktok: ["accessToken"],
+  vwo: [],
+  hotjar: [],
+  clarity: [],
+  pinterest: ["conversionToken"],
+  code: [],
+  googleAnalytics: ["apiSecret"],
+  googleTagManager: ["authorizationToken"],
+  hubspot: [],
+  linkedinInsightTag: ["oauthProviderId"],
+  onetrust: [],
+  posthog: [],
+  datafast: ["apiKey"],
+  recaptcha: [],
+  twitterAds: ["oauthProviderId"]
+};
+var TAG_REQUESTABLE_SECRET_FIELDS = {
+  meta: ["accessToken"],
+  amplitude: [],
+  googleAds: ["oauthProviderId", "customerAccountId"],
+  tiktok: ["accessToken"],
+  vwo: [],
+  hotjar: [],
+  clarity: [],
+  pinterest: ["conversionToken"],
+  code: [],
+  googleAnalytics: ["apiSecret"],
+  googleTagManager: ["authorizationToken"],
+  hubspot: [],
+  linkedinInsightTag: ["oauthProviderId"],
+  onetrust: [],
+  posthog: [],
+  datafast: ["apiKey"],
+  recaptcha: [],
+  twitterAds: ["oauthProviderId"]
+};
 var tagDraftOpKindSchema = z5.enum(["create", "update", "delete"]);
 var tagDraftOpViewSchema = z5.object({
   /** `tag_temp_*` for staged creates; the real tag id for update/delete ops. */
@@ -1974,17 +2016,49 @@ var tagsEffectiveEntrySchema = z5.object({
 });
 var tagsListRequestSchema = z5.object({ chatId: z5.string() });
 var tagsListResponseSchema = z5.object({ tags: z5.array(tagsEffectiveEntrySchema) });
+var tagsDraftStageRequestSchema = z5.discriminatedUnion("kind", [
+  z5.object({
+    kind: z5.literal("create"),
+    chatId: z5.string(),
+    type: tagTypeSchema,
+    config: z5.record(z5.string(), z5.string()),
+    requestSecrets: z5.array(z5.string()).optional(),
+    summary: z5.string().optional()
+  }),
+  z5.object({
+    kind: z5.literal("update"),
+    chatId: z5.string(),
+    ref: z5.string(),
+    config: z5.record(z5.string(), z5.string()).optional(),
+    clearFields: z5.array(z5.string()).optional(),
+    requestSecrets: z5.array(z5.string()).optional(),
+    summary: z5.string().optional()
+  }),
+  z5.object({
+    kind: z5.literal("delete"),
+    chatId: z5.string(),
+    ref: z5.string()
+  })
+]);
+var tagsDraftStageResponseSchema = z5.object({
+  /** Null when the request dissolved a staged create (delete/clearing an unpublished temp ref). */
+  op: tagDraftOpViewSchema.nullable(),
+  /** True when a `delete <tag_temp_*>` dropped the staged create instead of staging a delete. */
+  removedStagedCreate: z5.boolean().optional()
+});
 var tagsDraftListRequestSchema = z5.object({ chatId: z5.string() });
 var tagsDraftListResponseSchema = z5.object({
   status: z5.enum(["active", "publishing", "applied", "discarded", "none"]),
   ops: z5.array(tagDraftOpViewSchema)
 });
+var tagsDraftRemoveRequestSchema = z5.object({ chatId: z5.string(), ref: z5.string() });
+var tagsDraftRemoveResponseSchema = z5.object({ removed: z5.boolean() });
+var tagsDraftClearRequestSchema = z5.object({ chatId: z5.string() });
+var tagsDraftClearResponseSchema = z5.object({ cleared: z5.number() });
 var tagInputRequestSchema = z5.object({
-  // Every tag change is a tab in the approval form: create/edit show the full
-  // body; delete shows a confirm. No tag change bypasses this approval.
-  mode: z5.enum(["create", "edit", "delete"]),
+  mode: z5.enum(["create", "edit"]),
   tagType: tagTypeSchema,
-  /** Edit/delete mode — the real tag id or `tag_temp_*` ref being changed. */
+  /** Edit mode — the real tag id or `tag_temp_*` ref being edited. */
   ref: z5.string().optional(),
   /** Non-secret values the agent proposes to prefill. Secret keys are stripped at every boundary. */
   prefilledConfig: z5.record(z5.string(), z5.string()).optional(),
@@ -1993,9 +2067,6 @@ var tagInputRequestSchema = z5.object({
   /** Short message shown above the form explaining why the input is needed. */
   message: z5.string().optional()
 });
-var tagChangeToolInputSchema = z5.object({
-  changes: z5.array(tagInputRequestSchema).min(1).max(8)
-});
 var tagInputResultSchema = z5.discriminatedUnion("status", [
   z5.object({
     status: z5.literal("submitted"),
@@ -2011,9 +2082,6 @@ var tagInputResultSchema = z5.discriminatedUnion("status", [
     reason: z5.string().optional()
   })
 ]);
-var tagChangeToolResultSchema = z5.object({
-  results: z5.array(tagInputResultSchema)
-});
 
 // ../api/src/testimonials.ts
 import { z as z6 } from "zod";
@@ -9480,7 +9548,7 @@ var leadFormsCreateCommand = defineCommand38({
 Required: name, headline (\u226460), privacyPolicyUrl, questions[] (\u226412; playbook: \u22644 for completion).
 Each question is a predefined profile field ({ name, predefinedField: "EMAIL" }) or a custom question ({ name, questionType: "MULTIPLE_CHOICE", options: [...] }; \u22643 custom).
 Best-practice fields the preview will nudge for if missing: 1-3 qualifying questions, consents[] (disclosure checkboxes), thankYou.message + thankYou.landingUrl|appointmentUrl.
-Also supported: locale, formImageId|formImageUrn, hiddenFields[], legalDisclaimer, thankYou.cta. Example: baker ads linkedin lead-forms create --file form.json`
+Also supported: locale, formImageId|formImageUrn, privacyPolicyText, hiddenFields[], legalDisclaimer, thankYou.cta. Example: baker ads linkedin lead-forms create --file form.json`
   },
   args: {
     ...accountArgs,
@@ -23916,6 +23984,10 @@ var schemaCommand = defineCommand147({
 import { defineCommand as defineCommand148 } from "citty";
 
 // src/commands/tags/shared.ts
+function failValidation3(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
 function failApi3(err) {
   if (err instanceof ApiError) {
     writeJson({ ok: false, error: { code: err.code, message: err.message } });
@@ -23928,6 +24000,53 @@ function failApi3(err) {
   writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
   process.exit(1);
 }
+function parseTagType(value) {
+  const parsed = tagTypeSchema.safeParse(value);
+  if (!parsed.success) {
+    failValidation3(`Unknown tag type "${value}". Valid types: ${TAG_TYPES.join(", ")}.`);
+  }
+  return parsed.data;
+}
+function toArray(value) {
+  if (value === void 0 || typeof value === "boolean") {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+function parseSetArgs(value) {
+  const config = {};
+  for (const entry of toArray(value)) {
+    const eq = entry.indexOf("=");
+    if (eq <= 0) {
+      failValidation3(`--set expects key=value, got "${entry}".`);
+    }
+    config[entry.slice(0, eq)] = entry.slice(eq + 1);
+  }
+  return config;
+}
+function parseListArg(value) {
+  return toArray(value).flatMap(
+    (entry) => entry.split(",").map((item) => item.trim()).filter((item) => item !== "")
+  );
+}
+function rejectSecretSets(type, config) {
+  const secretFields = TAG_SECRET_FIELDS[type];
+  const offending = Object.keys(config).filter((key) => secretFields.includes(key));
+  if (offending.length > 0) {
+    failValidation3(
+      `${offending.join(", ")} ${offending.length === 1 ? "is a secret field" : "are secret fields"} \u2014 never pass secret values on the command line. Re-run with --request-secret ${offending[0]} and the user will provide it via the secure tag form in the chat.`
+    );
+  }
+}
+function validateRequestSecrets(type, fields) {
+  const requestable = TAG_REQUESTABLE_SECRET_FIELDS[type];
+  const invalid = fields.filter((field) => !requestable.includes(field));
+  if (invalid.length > 0) {
+    failValidation3(
+      `Cannot request ${invalid.join(", ")} for a ${type} tag. Requestable secret fields: ${requestable.length > 0 ? requestable.join(", ") : "(none \u2014 this type has no secret fields)"}.`
+    );
+  }
+}
 function renderEffectiveEntry(entry) {
   const parts = [entry.ref, entry.type];
   if (entry.identifier !== void 0) {
@@ -23949,11 +24068,47 @@ function renderEffectiveEntry(entry) {
 // src/commands/tags/index.ts
 registerSchema({
   command: "tags.list",
-  description: "Effective marketing tags for this chat: production tags overlaid with the changes staged in this chat. The printed refs (tag ids or tag_temp_*) are exactly what flow side-effect tagIds should reference. Read-only \u2014 every tag change (create, edit, delete) goes through the request_tag_input approval tool.",
+  description: "Effective marketing tags for this chat: production tags overlaid with the ops staged in this chat's draft. The printed refs (tag ids or tag_temp_*) are exactly what flow side-effect tagIds should reference.",
   args: {
     json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable list", required: false }
   }
 });
+registerSchema({
+  command: "tags.add",
+  description: "Stage creation of a marketing tag (applies when the chat publishes). Set every non-secret field with --set; request secret fields (API keys, tokens, OAuth connections) with --request-secret \u2014 the user provides them via the secure tag form in the chat, never through the CLI.",
+  args: {
+    type: {
+      type: "positional",
+      description: "Tag type (see `baker tags list` output / meta, googleAnalytics, clarity, \u2026)",
+      required: true
+    },
+    set: { type: "string", description: "Repeatable key=value for non-secret config fields", required: false },
+    "request-secret": {
+      type: "string",
+      description: "Repeatable secret field name to request from the user",
+      required: false
+    }
+  }
+});
+registerSchema({
+  command: "tags.update",
+  description: "Stage an update to a tag by ref (real tag id, or tag_temp_* to amend a create staged in this chat). --set patches fields, --clear removes them, --request-secret asks the user for secret values.",
+  args: {
+    ref: { type: "positional", description: "Tag ref from `baker tags list`", required: true },
+    set: { type: "string", description: "Repeatable key=value for non-secret config fields", required: false },
+    clear: { type: "string", description: "Repeatable field name to clear", required: false },
+    "request-secret": {
+      type: "string",
+      description: "Repeatable secret field name to request from the user",
+      required: false
+    }
+  }
+});
+registerSchema({
+  command: "tags.remove",
+  description: "Stage deletion of a tag by ref (applies on publish). Removing a tag_temp_* ref drops the staged create instead.",
+  args: { ref: { type: "positional", description: "Tag ref from `baker tags list`", required: true } }
+});
 async function listTags(json) {
   try {
     const chatId = requireChatId();
@@ -23963,7 +24118,7 @@ async function listTags(json) {
       return;
     }
     if (response.tags.length === 0) {
-      process.stdout.write("No tags configured. Propose one with the request_tag_input tool (baker_ui).\n");
+      process.stdout.write("No tags configured. Stage one with `baker tags add <type> --set key=value`.\n");
       return;
     }
     process.stdout.write(`${response.tags.map(renderEffectiveEntry).join("\n")}
@@ -23982,6 +24137,84 @@ var listCommand7 = defineCommand148({
     await listTags(args.json === true);
   }
 });
+async function stage(body) {
+  try {
+    const response = await apiPost("/api/tags/draft/stage", body);
+    writeJson({ ok: true, data: response });
+  } catch (err) {
+    failApi3(err);
+  }
+}
+var addCommand2 = defineCommand148({
+  meta: {
+    name: "add",
+    description: "Stage a new tag (applies on publish). Secret fields are never passed here \u2014 use --request-secret and the user fills them in the chat's secure tag form. Example: baker tags add meta --set pixelId=123456 --request-secret accessToken"
+  },
+  args: {
+    type: {
+      type: "positional",
+      description: "Tag type (meta, googleAnalytics, googleAds, clarity, \u2026)",
+      required: true
+    },
+    set: { type: "string", description: "key=value for a non-secret config field (repeatable)" },
+    "request-secret": { type: "string", description: "Secret field name the user should provide (repeatable)" }
+  },
+  run: async ({ args }) => {
+    const type = parseTagType(args.type);
+    const config = parseSetArgs(args.set);
+    const requestSecrets = parseListArg(args["request-secret"]);
+    rejectSecretSets(type, config);
+    validateRequestSecrets(type, requestSecrets);
+    const chatId = requireChatId();
+    await stage({
+      kind: "create",
+      chatId,
+      type,
+      config,
+      ...requestSecrets.length > 0 ? { requestSecrets } : {}
+    });
+  }
+});
+var updateCommand3 = defineCommand148({
+  meta: {
+    name: "update",
+    description: "Stage an update to a tag. A tag_temp_* ref amends the create staged in this chat. Example: baker tags update <ref> --set pixelId=999 --clear testEventCode"
+  },
+  args: {
+    ref: { type: "positional", description: "Tag ref from `baker tags list`", required: true },
+    set: { type: "string", description: "key=value patch for a non-secret config field (repeatable)" },
+    clear: { type: "string", description: "Field name to clear (repeatable)" },
+    "request-secret": { type: "string", description: "Secret field name the user should provide (repeatable)" }
+  },
+  run: async ({ args }) => {
+    const config = parseSetArgs(args.set);
+    const clearFields = parseListArg(args.clear);
+    const requestSecrets = parseListArg(args["request-secret"]);
+    if (Object.keys(config).length === 0 && clearFields.length === 0 && requestSecrets.length === 0) {
+      failValidation3("Nothing to update \u2014 pass --set, --clear, or --request-secret.");
+    }
+    const chatId = requireChatId();
+    await stage({
+      kind: "update",
+      chatId,
+      ref: args.ref,
+      ...Object.keys(config).length > 0 ? { config } : {},
+      ...clearFields.length > 0 ? { clearFields } : {},
+      ...requestSecrets.length > 0 ? { requestSecrets } : {}
+    });
+  }
+});
+var removeCommand5 = defineCommand148({
+  meta: {
+    name: "remove",
+    description: "Stage deletion of a tag (applies on publish). Removing a tag_temp_* ref drops the staged create instead. Example: baker tags remove <ref>"
+  },
+  args: { ref: { type: "positional", description: "Tag ref from `baker tags list`", required: true } },
+  run: async ({ args }) => {
+    const chatId = requireChatId();
+    await stage({ kind: "delete", chatId, ref: args.ref });
+  }
+});
 async function listDraft3() {
   try {
     const chatId = requireChatId();
@@ -23991,10 +24224,55 @@ async function listDraft3() {
     failApi3(err);
   }
 }
+var draftListCommand = defineCommand148({
+  meta: { name: "list", description: "Review the tag ops staged in this chat. Example: baker tags draft" },
+  run: async () => {
+    await listDraft3();
+  }
+});
+var draftRemoveCommand = defineCommand148({
+  meta: {
+    name: "remove",
+    description: "Drop one staged tag op by ref. Example: baker tags draft remove tag_temp_abc123"
+  },
+  args: { ref: { type: "positional", description: "Staged op ref", required: true } },
+  run: async ({ args }) => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/tags/draft/remove", {
+        chatId,
+        ref: args.ref
+      });
+      writeJson({ ok: true, data: response });
+    } catch (err) {
+      failApi3(err);
+    }
+  }
+});
+var draftClearCommand = defineCommand148({
+  meta: {
+    name: "clear",
+    description: "Drop ALL tag ops staged in this chat \u2014 nothing will apply on publish. Example: baker tags draft clear"
+  },
+  run: async () => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/tags/draft/clear", { chatId });
+      writeJson({ ok: true, data: response });
+    } catch (err) {
+      failApi3(err);
+    }
+  }
+});
 var draftCommand3 = defineCommand148({
   meta: {
     name: "draft",
-    description: "Review the tag changes staged in this chat (read-only). Staged changes were approved via request_tag_input and apply when the chat is published; to amend or drop one, propose a follow-up change through the same tool (a delete on a tag_temp_* ref drops the staged create)."
+    description: "Review and edit the tag ops staged in this chat BEFORE publish. Subcommands: list (default), remove, clear. Ops never touch production tags until the chat is published."
+  },
+  subCommands: {
+    list: draftListCommand,
+    remove: draftRemoveCommand,
+    clear: draftClearCommand
   },
   run: async () => {
     await listDraft3();
@@ -24003,18 +24281,25 @@ var draftCommand3 = defineCommand148({
 var tagsCommand3 = defineCommand148({
   meta: {
     name: "tags",
-    description: `Read the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, \u2026) \u2014 production tags plus the changes staged in this chat.
+    description: `Manage the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, \u2026) as per-chat STAGED changes \u2014 nothing touches production until the chat is published.
 
-This command is READ-ONLY. Every tag change \u2014 create, edit, or delete \u2014 goes through the request_tag_input tool (baker_ui MCP server): propose one or more changes (each becomes a tab in one approval form), pre-fill the non-secret fields you know, and the user reviews, fills secrets, and approves or skips each. Secret values (accessToken, apiSecret, authorizationToken, apiKey, conversionToken, OAuth connections) never pass through the CLI or the chat.
+Secrets: secret fields (accessToken, apiSecret, authorizationToken, apiKey, conversionToken, oauthProviderId) are NEVER typed into chat or passed to this CLI. Stage with --request-secret <field>, then invoke the request_tag_input tool (baker_ui) so the user fills them in the dashboard's secure tag form.
 
 Refs: \`baker tags list\` prints each tag's ref \u2014 a real tag id, or tag_temp_* for creates staged in this chat. Use these refs as flow side-effect tagIds; they keep resolving after publish.
 
 Examples:
-  baker tags list       # production + staged, with secret status
-  baker tags draft      # review the staged changes awaiting publish`
+  baker tags list                                              # production + staged, with secret status
+  baker tags add clarity --set projectId=abcde12345            # client-only tag, no secrets needed
+  baker tags add meta --set pixelId=123 --request-secret accessToken
+  baker tags update <ref> --set pixelId=999 --clear testEventCode
+  baker tags remove <ref>                                      # stage deletion (temp ref = drop the create)
+  baker tags draft                                             # review staged ops before finishing`
   },
   subCommands: {
     list: listCommand7,
+    add: addCommand2,
+    update: updateCommand3,
+    remove: removeCommand5,
     draft: draftCommand3
   },
   run: async () => {