@koda-sl/baker-cli 0.174.0 → 0.177.0-dev.0cbdaa224

package/README.md

@@ -577,6 +577,14 @@ baker ads google draft show g_temp_ab12      # full staged payload — the recei
 baker ads google draft amend g_temp_ab12 --patch '{"amountMicros": 60000000}'   # update in place, never remove+recreate
 baker ads google draft remove g_temp_ab12    # cascades to dependents
 baker ads google draft clear
+
+# Read an earlier chat's changes (read-only; staging stays on the current chat)
+baker ads google draft list --chat <chat-id>
+baker ads google draft show --chat <chat-id> g_temp_ab12
+baker ads meta draft show --chat <chat-id> meta_temp_ab12
+baker ads linkedin draft show --chat <chat-id> li_temp_ab12
+baker tag-manager draft show --chat <chat-id> gtm_temp_ab12
+baker actions draft --chat <chat-id>
 ```
 
 Command groups: `budgets`, `campaigns`, `ad-groups`, `keywords` (add/update/remove), `negative-keywords`, `keyword-lists`, `ads`, `assets` (create/update/attach/detach), `asset-groups` (create/update/attach/detach — Performance Max), `audiences`, `conversions` (create/update/goal), `bidding-strategies`, `labels`, `campaign-criteria`, and `draft`. Amounts are in major currency units (converted to micros). Money/bids: `--amount`, `--cpc-bid`, `--target-cpa`, `--max-cpc` take major units; `--target-roas` a ratio. `--max-cpc` sets the max CPC bid ceiling for `TARGET_IMPRESSION_SHARE` / `TARGET_SPEND` / `PERCENT_CPC` and must be paired with `--bidding-strategy`. Less-common ops accept a `--file <payload.json>` (flags override file keys). Updates target a resource name or bare id as the positional argument; a target that names an op staged earlier **amends it in place**.
@@ -591,6 +599,8 @@ Command groups: `budgets`, `campaigns`, `ad-groups`, `keywords` (add/update/remo
 
 **Amending a staged op** — `draft amend <ref> (--file patch.json | --patch '<json>')` merges a JSON patch into an already-staged op's payload (objects deep-merge, `null` deletes a key, arrays/scalars replace) and re-validates it in full. Always prefer this over removing and re-staging — it preserves the op's ref (so dependents don't break) and its position in the draft. `draft show <ref>` prints the full staged payload (including warnings/annotations) so you can verify a change looks right before publish.
 
+**Reading an earlier chat's changes** — `draft list` and `draft show` take `--chat <chat-id>` to read another chat in the same company instead of the current one. Every staged-draft family accepts it: `ads google|meta|linkedin draft list|show`, `tag-manager draft list|show`, `actions draft`, `tags draft`, and `scheduled-actions list|get`. A published draft is kept in full, so this returns what that chat actually wrote — every headline, bid and target — plus each op's outcome and error. Use it when asked to redo or reapply earlier work rather than reconstructing copy from a summary. Read-only: staging, `amend`, `remove` and `clear` stay bound to `BAKER_CHAT_ID`, so one chat can never edit another's draft. To re-run only the changes a publish failed to land, use the chat's **Retry** control in the dashboard — it re-sends exactly those and leaves the ones that applied untouched.
+
 **Already-satisfied writes aren't staged** — an update or pause/resume whose every field already holds the requested value on the live account is dropped instead of staged: the envelope returns `"staged": false, "noop": true` with a `reason` ("this ad is already Paused on Google Ads"), plus a hint. This is a success, not an error — there is nothing to publish. Only a positively-read live snapshot can trigger it; a failed or empty read always stages. Batch responses list the dropped ops under `skipped`, and `count` reflects what actually entered the draft.
 
 **Batch keyword adds** — `keywords add`, `negative-keywords add`, and `keyword-lists add` take a whole batch in one command: comma-separate `--text` entries and/or pass `--file <list.txt>` (one keyword per line). A `:EXACT`/`:PHRASE`/`:BROAD` suffix per entry overrides the `--match-type` default. Batches stage all-or-nothing as one request (limit 500); each keyword still lands as its own draft op, so it stays individually removable/amendable.
@@ -786,6 +796,7 @@ baker ads meta ads create         --account-id act_123 --name "Ad 1" --adset met
 
 # review + edit before publish
 baker ads meta draft
+baker ads meta draft show meta_temp_cr     # full staged payload — the receipt before publish
 baker ads meta draft remove meta_temp_cr   # removing a create cascades to dependents
 baker ads meta draft clear
 ```
@@ -1090,7 +1101,11 @@ Each finding: `{id, area, check, status, severity, evidence, fix: {explanation,
 
 ### Google Analytics 4 (`baker ga4`)
 
-GA4 commands for multi-channel audits. Playbook-aligned presets, property health audits, and free-form Data API queries.
+GA4 commands for multi-channel audits **and** for configuring what the property measures. Playbook-aligned report presets, property health audits, free-form Data API queries, and staged Admin API writes.
+
+Reads (`properties`, `config`, `audit`, `query`) happen immediately. Writes (`key-event`, `custom-dimension`, `custom-metric`, `custom-event`, `data-retention`) are **staged** onto the chat, reviewed in the dashboard's Analytics tab, and applied when the chat completes — at which point they take effect on the property immediately. There is no simulated mode and no undo.
+
+A Google Analytics connection made before writes shipped is read-only and every write command refuses with a message saying to reconnect. `baker ga4 config` reports `canWrite`.
 
 ---
 
@@ -1104,6 +1119,18 @@ baker ga4 properties
 
 ---
 
+### `baker ga4 config`
+
+What the property measures today — key events, custom dimensions and metrics, custom events, data streams, retention — plus whether this connection may change it. Run before staging any write: every id an update or removal targets comes from here.
+
+```bash
+baker ga4 config
+baker ga4 config --property-id 123456789
+baker ga4 config --full
+```
+
+---
+
 ### `baker ga4 audit`
 
 Run all GA4 admin health checks at once. Checks data retention, Google Ads linkage, phantom conversions, audience defaults, data streams, and attribution settings.
@@ -1172,6 +1199,58 @@ baker ga4 query --dimensions "date,sessionSourceMedium" --metrics "sessions,conv
 
 ---
 
+### `baker ga4 key-event` / `custom-dimension` / `custom-metric` / `custom-event` / `data-retention`
+
+Staged Admin API writes. Each stages one change onto the chat; nothing reaches Google Analytics until the chat completes.
+
+```bash
+# What GA4 counts as a conversion (and Google Ads imports for bidding)
+baker ga4 key-event create --json '{"eventName":"generate_lead","countingMethod":"ONCE_PER_EVENT"}'
+baker ga4 key-event update 4185 --json '{"countingMethod":"ONCE_PER_SESSION"}'
+baker ga4 key-event delete 4185
+
+# Make an event parameter reportable
+baker ga4 custom-dimension create --json '{"parameterName":"plan_tier","displayName":"Plan tier","scope":"EVENT"}'
+baker ga4 custom-dimension update 12 --json '{"displayName":"Plan"}'
+baker ga4 custom-dimension archive 12
+baker ga4 custom-metric create --json '{"parameterName":"deal_value","displayName":"Deal value","scope":"EVENT","measurementUnit":"CURRENCY","restrictedMetricType":["REVENUE_DATA"]}'
+baker ga4 custom-metric update 8 --json '{"description":"Closed-won value"}'
+baker ga4 custom-metric archive 8
+
+# A new event built from one the site already sends (GA4's "Create event")
+baker ga4 custom-event create --json '{"destinationEvent":"quote_request","eventConditions":[{"field":"event_name","comparisonType":"EQUALS","value":"form_submit"},{"field":"page_location","comparisonType":"CONTAINS","value":"/quote"}],"sourceCopyParameters":true}'
+baker ga4 custom-event update 7 --json '{"sourceCopyParameters":false}'
+baker ga4 custom-event delete 7
+
+# How long data is kept (months: 2, 14, 26, 38, 50 — over 14 needs Analytics 360)
+baker ga4 data-retention set --event-data 14 --user-data 14
+
+# Several definitions in one call — one read of the property instead of one per definition
+baker ga4 custom-dimension create --json '[{"parameterName":"plan_tier","displayName":"Plan tier","scope":"EVENT"},{"parameterName":"lead_source","displayName":"Lead source","scope":"EVENT"}]'
+```
+
+Every `create` accepts a JSON array as well as a single object, and stages the whole list in one request (all-or-nothing). Prefer it for bulk work: each stage reads the property's full configuration first, so separate calls multiply that read.
+
+Custom dimensions and metrics are **archived**, not deleted (the slot frees, past data stays); key events and custom events are **deleted**. Neither is reversible from Baker. Because `parameterName` and `scope` are immutable, changing one is an archive plus a create staged on the same chat — the removal applies first and frees the name. `--property-id` is required when more than one property is connected, and one chat stages changes for one property; `--data-stream` is required for a custom event when the property has more than one website stream.
+
+---
+
+### `baker ga4 draft`
+
+Review and undo the Analytics changes staged on this chat.
+
+```bash
+baker ga4 draft list                                   # everything staged (--json for the envelope)
+baker ga4 draft show ga4_temp_keyEvent_x_0             # one change in full, with today's values
+baker ga4 draft amend keyEvent:4185 --patch '{"countingMethod":"ONCE_PER_EVENT"}'
+baker ga4 draft remove keyEvent:4185
+baker ga4 draft clear
+```
+
+`list` and `show` take `--chat <id>` to read an earlier chat's staged changes.
+
+---
+
 ### Google Search Console (`baker gsc`)
 
 GSC commands for PPC-SEO arbitrage, brand halo analysis, and negative keyword discovery.
@@ -4930,6 +5009,7 @@ This CLI is designed for AI agent consumption. Key patterns:
 
   Shipped with it: **staging a second removal of the same shape silently did nothing.** Amend-matching reduced any composite ref to the segment after its last `~` — built for the two-segment `adGroupId~adId` refs that ad and keyword targets heal to, where that segment really is the entity's own id. It is not, in three other places: an asset-group asset (`{assetGroup}~{asset}~{FIELD_TYPE}`) and a customer-level asset link (`{asset}~{FIELD_TYPE}`) both end in a field type every asset of that ratio shares, and a campaign shared set (`{campaign}~{sharedSet}`) ends in the list's id, the same in every campaign it is attached to. So the second detach amended the first instead of staging, returned the first's ref and reported success: a PMax creative swap could only ever remove one image per ratio, and detaching one negative list from three campaigns removed it from one. Nothing in the output said the rest had been dropped. Refs now compare whole, with one one-sided exception — a **bare** id still collapses onto the two-segment composite whose child it names, which is the only case the reduction ever existed for. The duplicate copy of the same helper in the staging path is gone rather than fixed twice. Also: linking an asset Google created automatically is refused at stage time on an asset group, not just on a campaign/ad-group/customer link — a Performance Max group is where auto-created creative is most likely to be picked up. And the live-context resolver now reads the asset group and asset an attach/detach names, so the review of a swap shows names and the images themselves rather than the ids inside a resource name.
 
+- **0.177.0**: `baker ga4` can change what a property measures, not only report on it. Five staged write families — `key-event` (create|update|delete), `custom-dimension` and `custom-metric` (create|update|archive), `custom-event` (create|update|delete), `data-retention set` — plus `baker ga4 config` to read the property's current configuration and `baker ga4 draft` (list|show|amend|remove|clear) to review the staged set. `custom-event` is GA4's "Create event" rule: build a new event out of one the site already sends (a `form_submit` on `/quote` becomes `quote_request`), then mark it a key event so Google Ads imports it — the loop that previously ended with "do this by hand in Analytics". Staging follows Tag Manager: nothing is sent during the chat, the user reviews the whole set in the dashboard's **Analytics** tab, and it applies when they complete the chat. Unlike Tag Manager there is no version left over — an applied change is in effect at once, and there is no undo, so removals ask for confirmation first. Everything Google would reject is refused at stage time against a fresh read of the property rather than discovered at publish: a duplicate `eventName` or `parameterName` (including against another change staged on the same chat), an immutable field in an update, a currency metric with no restricted type, a retention window past 14 months on a standard property, a target the property does not have. Marking an event Google fires by itself (`page_view`, `scroll`, …) as a key event is a **warning**, not a refusal — it is legal, it just inflates conversions and poisons Smart Bidding. The one thing that is *not* a duplicate is the replacement of something the same chat has already staged the removal of: ops apply in stage order, so `custom-dimension archive 12` followed by a create on the same `parameterName` works, which is the only way to change a field GA4 marks immutable. Every `create` also takes a JSON array and stages the list in one request, because each stage costs a full read of the property. One chat stages changes for one property. **The OAuth scope changed:** Baker now requests `analytics.edit`, so every Google Analytics connection made before this is read-only until it is reconnected; the write commands refuse up front with that as the fix, and `baker ga4 config` reports `canWrite`. Reporting is unaffected. Not covered, and reported as such by `baker capabilities`: property create/rename/merge, data streams, the Google Ads link, and audiences.
 - **0.169.0**: `baker capabilities` — one call, before any platform work, that answers what Baker **cannot** do. Everything else (`baker schema`, the family docs, `--help`) describes what it can, so the only way to learn a capability was absent was to try it, usually after telling the user it would happen. Per surface (`google-ads`, `meta-ads`, `linkedin-ads`, `x-ads`, `tag-manager`, `ga4`, `gsc`) it reports: what is connected and which accounts/properties/containers were picked; whether writes are **live** or **simulated** for this company, and that Tag Manager has neither mode — completing the chat changes the real container; and a `limits` list separating *not built yet* from *the platform forbids it* from *we hold no permission for it*, because each leads to something different to tell the user. Naming one surface (`baker capabilities google-ads`) also returns `ops`: every change with its required and optional fields and the exact values each accepts — so "is there a field to demote a conversion action, and how is it spelled?" is one call instead of four guesses. Almost everything is derived rather than written down: the accounts and permissions come from the connection, the write mode from the company's gate, the writable entities and field contracts from the same schemas the backend parses with, and read-only vs read-write from the OAuth scopes the app actually requests (which is why "GA4 is read-only" is a fact, not a sentence). The handful of hand-written entries each carry a machine-checkable claim about the code behind them, and a coverage test fails when one stops holding. A rejected staged write on Google, Meta or LinkedIn now points at this command instead of leaving the agent to guess another field name.
 
 ## Publishing

package/dist/{chunk-7I2POXSJ.js → chunk-K3PWXVF7.js}

@@ -1,6 +1,6 @@
 import {
   debugLogSetting
-} from "./chunk-RK67WL4O.js";
+} from "./chunk-YL3HDEIJ.js";
 
 // src/debugLog.ts
 import { appendFileSync, mkdirSync, renameSync, statSync } from "fs";
@@ -150,4 +150,4 @@ export {
   readBodyForLog,
   installStreamTaps
 };
-//# sourceMappingURL=chunk-7I2POXSJ.js.map
+//# sourceMappingURL=chunk-K3PWXVF7.js.map

package/dist/{chunk-7QMWNMRW.js → chunk-PXXJ3HJW.js}

@@ -2,13 +2,13 @@ import {
   handleConnectionError,
   needsConnectionFix,
   writeAdsJson
-} from "./chunk-TFPZLUVM.js";
+} from "./chunk-X5C6HE24.js";
 import {
   ApiError
-} from "./chunk-ZH6ZNYPB.js";
+} from "./chunk-ZWYQIEBI.js";
 import {
   getEnv
-} from "./chunk-RK67WL4O.js";
+} from "./chunk-YL3HDEIJ.js";
 
 // src/commands/ads/meta/shared.ts
 var DAY_MS = 864e5;
@@ -108,4 +108,4 @@ export {
   csvOrJson,
   resolveEffectiveStatus
 };
-//# sourceMappingURL=chunk-7QMWNMRW.js.map
+//# sourceMappingURL=chunk-PXXJ3HJW.js.map

package/dist/{chunk-CG6OTNUU.js → chunk-QPVJGKV7.js}

@@ -1,15 +1,15 @@
 import {
   debugLogHttp,
   readBodyForLog
-} from "./chunk-7I2POXSJ.js";
+} from "./chunk-K3PWXVF7.js";
 import {
   __commonJS,
   __toESM
-} from "./chunk-RK67WL4O.js";
+} from "./chunk-YL3HDEIJ.js";
 
-// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js
+// ../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/810146e81bae4e3a061fe487864f2fde80c4b03b886877dc0f1fffbc6480b67e/node_modules/safe-stable-stringify/index.js
 var require_safe_stable_stringify = __commonJS({
-  "../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js"(exports, module) {
+  "../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/810146e81bae4e3a061fe487864f2fde80c4b03b886877dc0f1fffbc6480b67e/node_modules/safe-stable-stringify/index.js"(exports, module) {
     "use strict";
     var { hasOwnProperty } = Object.prototype;
     var stringify = configure2();
@@ -1075,7 +1075,7 @@ function resolveAdaptFormats(params) {
   return params.formats ?? [];
 }
 
-// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/esm/wrapper.js
+// ../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/810146e81bae4e3a061fe487864f2fde80c4b03b886877dc0f1fffbc6480b67e/node_modules/safe-stable-stringify/esm/wrapper.js
 var import__ = __toESM(require_safe_stable_stringify(), 1);
 var configure = import__.default.configure;
 var wrapper_default = import__.default;
@@ -8028,4 +8028,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-CG6OTNUU.js.map
+//# sourceMappingURL=chunk-QPVJGKV7.js.map