@koda-sl/baker-cli 0.477.0-dev.55c09e3e8 → 0.477.0

package/dist/changes-AZ6EUVFN.js

@@ -0,0 +1,135 @@
+import {
+  getFieldDescriptions
+} from "./chunk-JPK34QPS.js";
+import {
+  parseApiError,
+  resolveChangesWindow
+} from "./chunk-UARL36OD.js";
+import {
+  CHANGE_SCOPE_MAX_DAYS,
+  DEFAULT_CHANGE_DAYS
+} from "./chunk-7VHPAGPK.js";
+import {
+  getManagerIdForCustomer,
+  resolveCustomerId,
+  writeAdsJson,
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-AAF7HL4I.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-7ANWFQEA.js";
+import "./chunk-KODTY7PB.js";
+import "./chunk-H5CGVMQW.js";
+import {
+  registerSchema
+} from "./chunk-ANYMWCST.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/google/changes.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.google.changes",
+  description: "Read the account's change history. --scope detail (default) shows what changed and to what value, back 30 days; --scope summary shows which resources changed, back 90 days.",
+  args: {
+    "customer-id": {
+      type: "string",
+      description: "Google Ads customer ID (10 digits, no dashes). Falls back to BAKER_GOOGLE_ADS_CUSTOMER_ID env var.",
+      required: false
+    },
+    days: {
+      type: "string",
+      description: `Lookback days (default: ${DEFAULT_CHANGE_DAYS}). Max ${CHANGE_SCOPE_MAX_DAYS.detail} with --scope detail, ${CHANGE_SCOPE_MAX_DAYS.summary} with --scope summary. Google keeps nothing older behind any API.`,
+      required: false,
+      default: DEFAULT_CHANGE_DAYS
+    },
+    scope: {
+      type: "string",
+      description: `detail|summary (default: detail). detail = old/new values plus who made the change, ${CHANGE_SCOPE_MAX_DAYS.detail} days. summary = which resources were added, changed or removed, ${CHANGE_SCOPE_MAX_DAYS.summary} days, without values.`,
+      required: false,
+      default: "detail"
+    },
+    "resource-type": {
+      type: "string",
+      description: "Filter by type: CAMPAIGN, CAMPAIGN_CRITERION, AD_GROUP, AD_GROUP_AD, AD_GROUP_CRITERION. CAMPAIGN_CRITERION covers campaign-level negatives, location and audience exclusions.",
+      required: false
+    },
+    limit: { type: "string", description: "Max change events (default: 50, max: 1000)", required: false, default: 50 },
+    output: { type: "string", description: "Format: json|csv|jsonl|md", required: false, default: "json" },
+    "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false }
+  }
+});
+var changesCommand = defineCommand({
+  meta: {
+    name: "changes",
+    description: `Read the change history of a Google Ads account.
+
+Google keeps account history in two layers, and neither reaches past 90 days:
+  --scope detail  (default)  what changed, old \u2192 new value, who changed it   \u2014 last ${CHANGE_SCOPE_MAX_DAYS.detail} days
+  --scope summary            which resources were added, changed or removed  \u2014 last ${CHANGE_SCOPE_MAX_DAYS.summary} days
+
+For anything older, infer it from performance instead \u2014 a monthly spend trend per
+campaign shows what started or stopped, just not who did it.
+
+Examples:
+  baker ads google changes --customer-id 1234567890
+  baker ads google changes --customer-id 1234567890 --days 14 --resource-type CAMPAIGN
+  baker ads google changes --customer-id 1234567890 --days 60 --scope summary`
+  },
+  args: {
+    "customer-id": { type: "string", description: "Google Ads customer ID", required: false },
+    days: { type: "string", description: `Lookback days (default ${DEFAULT_CHANGE_DAYS})`, required: false },
+    scope: { type: "string", description: "detail (30 days) or summary (90 days)", required: false },
+    "resource-type": { type: "string", description: "Filter by resource type", required: false },
+    limit: { type: "string", description: "Max results (default 50)", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false },
+    output: { type: "string", description: "Format: json|csv|jsonl|md", required: false, default: "json" }
+  },
+  run: async ({ args }) => {
+    const customerId = await resolveCustomerId(args);
+    const window = resolveChangesWindow({
+      days: args.days ? Number(args.days) : void 0,
+      scope: args.scope
+    });
+    if (!window.ok) {
+      writeJsonEnvelope({ ok: false, error: { ...window.error, retryable: false } });
+      process.exit(1);
+      return;
+    }
+    const body = {
+      customerId,
+      days: window.days,
+      scope: window.scope,
+      limit: args.limit ? Number(args.limit) : 50
+    };
+    const managerId = getManagerIdForCustomer(customerId);
+    if (managerId) body.managerId = managerId;
+    if (args["resource-type"]) body.resourceType = args["resource-type"];
+    if (args["no-cache"]) body.skipCache = true;
+    try {
+      const data = await apiPost("/api/ads/google/changes", body);
+      const format = args.output || "json";
+      if (format !== "json") {
+        writeAdsOutput(data, format);
+        return;
+      }
+      const first = data[0];
+      const fields = first ? Object.keys(first) : [];
+      const fieldDescs = getFieldDescriptions(fields);
+      writeJsonEnvelope({ ok: true, data, fields: fieldDescs, hints: window.hints });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeAdsJson(parseApiError(err.message, "", customerId, err.code));
+        process.exit(1);
+      }
+      writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  changesCommand
+};
+//# sourceMappingURL=changes-AZ6EUVFN.js.map

package/dist/chatgpt-M27OEM7J.js

@@ -0,0 +1,47 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/index.ts
+import { defineCommand } from "citty";
+var chatgptCommand = defineCommand({
+  meta: {
+    name: "chatgpt",
+    description: `ChatGPT Ads (OpenAI's ads inside ChatGPT) \u2014 read the connected account, its campaigns, ad groups and ads, and how they perform; stage changes that apply when the chat is published.
+
+Start here:
+  baker ads chatgpt account                          \u2014 currency, timezone, and whether reviews let anything serve
+  baker ads chatgpt insights                         \u2014 last 7 days, one row per campaign
+
+Examples:
+  baker ads chatgpt campaigns
+  baker ads chatgpt ad-groups --campaign-id cmpn_123
+  baker ads chatgpt ads --ad-group-id adgrp_123
+  baker ads chatgpt conversions                      \u2014 pixels and conversion events
+  baker ads chatgpt insights --days 30 --granularity daily --segment country
+  baker ads chatgpt campaigns create --name "Spring push" --objective clicks --daily-budget 20
+  baker ads chatgpt draft                            \u2014 what this chat has staged
+
+Writes never reach ChatGPT Ads mid-chat: create, update, pause, resume and archive stage
+changes on this chat, and they apply when the chat is published.
+
+One company connects one ChatGPT Ads account, so there is no account id to pass.
+Full guide: __tooling__/docs/tools/baker/ads-chatgpt.md`
+  },
+  subCommands: {
+    account: () => import("./account-IFB6V6GL.js").then((m) => m.accountCommand),
+    campaigns: () => import("./campaigns-DJV4W6UP.js").then((m) => m.campaignsCommand),
+    "ad-groups": () => import("./ad-groups-UN52WNJN.js").then((m) => m.adGroupsCommand),
+    ads: () => import("./ads-NEJKXB4L.js").then((m) => m.adsCommand),
+    conversions: () => import("./conversions-OPNDVQ56.js").then((m) => m.conversionsCommand),
+    pixels: () => import("./pixels-HJYPX6RR.js").then((m) => m.pixelsCommand),
+    audiences: () => import("./audiences-BWDG2R2U.js").then((m) => m.audiencesCommand),
+    catalogs: () => import("./catalogs-2HT3VRRI.js").then((m) => m.catalogsCommand),
+    history: () => import("./history-4S3YEIPK.js").then((m) => m.historyCommand),
+    insights: () => import("./insights-K2CMI3K5.js").then((m) => m.insightsCommand),
+    locations: () => import("./locations-VYIDAVD4.js").then((m) => m.locationsCommand),
+    draft: () => import("./draft-DK4NZ6PW.js").then((m) => m.draftCommand)
+  }
+});
+export {
+  chatgptCommand
+};
+//# sourceMappingURL=chatgpt-M27OEM7J.js.map

package/dist/chats-OXIYXI4U.js

@@ -0,0 +1,262 @@
+import {
+  failApi
+} from "./chunk-R4CDO5YH.js";
+import "./chunk-GAJQPQWS.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiPost
+} from "./chunk-7ANWFQEA.js";
+import "./chunk-KODTY7PB.js";
+import {
+  getEnv
+} from "./chunk-H5CGVMQW.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-ANYMWCST.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/chats/index.ts
+import { defineCommand } from "citty";
+var STATUS_GROUPS = ["active", "archived", "all"];
+var REPO_SURFACES = ["knowledge", "company", "brand", "landings", "flows", "creatives"];
+function parseBoundedInt(raw, name, min, max) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const value = Number.parseInt(raw, 10);
+  if (Number.isNaN(value) || value < min || value > max) {
+    throw new Error(`--${name} must be an integer between ${min} and ${max}`);
+  }
+  return value;
+}
+registerSchema({
+  command: "chats.list",
+  description: "Start here: list other Sessions on this account (newest first) so you can reuse what was done before. Each row shows the Session id, title, status, and a count of what it produced (creatives, landings, actions, flows, reports\u2026). Then drill in with `baker chats view <id>`, `baker chats transcript <id>`, or `baker chats diff <id>`. Read-only.",
+  args: {
+    status: { type: "string", description: "Filter: active|archived|all (default: all)", required: false },
+    limit: { type: "string", description: "Max Sessions to return, 1-100 (default: 20)", required: false },
+    full: { type: "boolean", description: "Include each Session's full change list", required: false, default: false }
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List other Sessions on this account, newest first." },
+  args: {
+    status: { type: "string", description: "Filter: active|archived|all (default: all)", required: false },
+    limit: { type: "string", description: "Max Sessions (1-100, default 20)", required: false },
+    full: { type: "boolean", description: "Include each Session's full change list", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = {};
+      if (args.status) {
+        if (!STATUS_GROUPS.includes(args.status)) {
+          throw new Error(`--status must be one of: ${STATUS_GROUPS.join("|")}`);
+        }
+        body.status = args.status;
+      }
+      const limit = parseBoundedInt(args.limit, "limit", 1, 100);
+      if (limit !== void 0) {
+        body.limit = limit;
+      }
+      if (args.full) {
+        body.full = true;
+      }
+      const selfChatId = getEnv().BAKER_CHAT_ID;
+      if (selfChatId) {
+        body.excludeChatId = selfChatId;
+      }
+      const response = await apiPost("/api/chats/list", body);
+      writeJson({
+        ...response,
+        meta: { count: response.data.chats.length },
+        ...response.data.chats.length === 0 ? { hints: ["No Sessions matched. Widen with --status all or a larger --limit."] } : {
+          hints: [
+            "Drill in: `baker chats view <id>` for outputs, `chats transcript <id>` for the conversation, `chats diff <id>` for the real file changes."
+          ]
+        }
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+registerSchema({
+  command: "chats.view",
+  description: "Inspect one Session's FULL picture of what it changed \u2014 the unified `effects`: git content (landings, creatives, flows, knowledge, brand), plus DB-only effects that never touch the repo \u2014 Actions, Scheduled agents, Tags, Tag Manager, Google Analytics, ad-platform writes, the funnel (`funnel`: which steps it added, changed or removed, and which ways in it added or removed in `triggersAdded`/`triggersRemoved`), what counts as a conversion (`conversions`), conversion sends, event sources, and every other staged or already-applied change (`otherChanges`: A/B tests, recipes, library images) \u2014 each resolved to real detail (names, descriptions, priorities, tag types, ad operations) and, once published, its `outcome`. Also `publish` (what each external surface actually did, with the provider's own error), `activity` (the chat's own timeline: status changes, publish start/fail, workspace recoveries, timeouts), `usage` (per-thread cost and the Session's token totals), the kickoff (how it was asked), threads, and commits. Effects are `staged` (in-progress draft) or applied. A completed Session is NOT proof its external changes landed \u2014 read `publish`. Use after `baker chats list` to decide whether to reuse it. Read-only.",
+  args: {
+    id: { type: "positional", description: "The Session id (from `baker chats list`)", required: true },
+    full: {
+      type: "boolean",
+      description: "Untruncated effect lists and full activity metadata (compact caps each list at 25)",
+      required: false,
+      default: false
+    }
+  }
+});
+var viewCommand = defineCommand({
+  meta: {
+    name: "view",
+    description: "Inspect one Session's full effects \u2014 git content + actions/tags/ads, kickoff, commits."
+  },
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    full: { type: "boolean", description: "Include full detail", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const response = await apiPost("/api/chats/view", {
+        chatId: args.id,
+        ...args.full ? { full: true } : {}
+      });
+      const hints = [];
+      if (response.data.publish && !response.data.publish.complete) {
+        const failed = response.data.publish.failedTotal;
+        hints.push(
+          `This Session's publish left ${failed} change${failed === 1 ? "" : "s"} behind \u2014 see \`publish.surfaces\` for the platform's own words. Do not report those changes as live.`
+        );
+      }
+      if (response.data.diffAvailable) {
+        hints.push("See the real file-level diff of the git content with `baker chats diff <id> --full`.");
+      } else if (response.data.status === "in_progress" || response.data.status === "publishing") {
+        hints.push(
+          "This Session is still in progress \u2014 read its current file changes with `baker chats diff <id> --live`."
+        );
+      }
+      hints.push("Read the conversation with `baker chats transcript <id>`.");
+      writeJson({ ...response, hints });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+registerSchema({
+  command: "chats.transcript",
+  description: "Read another Session's conversation (user + agent turns), most-recent first-capped. Use to see exactly how a past request was phrased and iterated before replaying it for a new goal. Compact truncates long messages; add --full for verbatim text. Read-only.",
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    limit: { type: "string", description: "Max messages to return, 1-1000 (default: 100)", required: false },
+    full: {
+      type: "boolean",
+      description: "Return verbatim (untruncated) message text",
+      required: false,
+      default: false
+    }
+  }
+});
+var transcriptCommand = defineCommand({
+  meta: { name: "transcript", description: "Read another Session's conversation." },
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    limit: { type: "string", description: "Max messages (1-1000, default 100)", required: false },
+    full: { type: "boolean", description: "Verbatim message text", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = { chatId: args.id };
+      const limit = parseBoundedInt(args.limit, "limit", 1, 1e3);
+      if (limit !== void 0) {
+        body.limit = limit;
+      }
+      if (args.full) {
+        body.full = true;
+      }
+      const response = await apiPost("/api/chats/transcript", body);
+      writeJson({
+        ...response,
+        meta: { count: response.data.entries.length },
+        ...response.data.truncated ? { hints: ["Older messages were dropped to fit --limit. Raise --limit to see more."] } : {}
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+registerSchema({
+  command: "chats.diff",
+  description: "See the real file-level changes a Session made (landings, creatives, brand, flows, knowledge). Published Sessions read from git; for an in-progress (unpublished) Session pass --live to read its changes straight from its running workspace. Without --live, an unpublished Session returns available:false \u2014 use `baker chats view` for the staged summary. Compact lists changed files with +/- counts; add --full for the actual diff text. Read-only.",
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    surface: {
+      type: "string",
+      description: "Filter to one surface: knowledge|company|brand|landings|flows|creatives",
+      required: false
+    },
+    full: {
+      type: "boolean",
+      description: "Include the unified-diff patch text per file",
+      required: false,
+      default: false
+    },
+    live: {
+      type: "boolean",
+      description: "For an in-progress Session, read its changes from the live workspace (slower; resumes the paused Runtime). Ignored for published Sessions.",
+      required: false,
+      default: false
+    }
+  }
+});
+var diffCommand = defineCommand({
+  meta: { name: "diff", description: "See a published Session's real file-level changes." },
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    surface: {
+      type: "string",
+      description: "Filter: knowledge|company|brand|landings|flows|creatives",
+      required: false
+    },
+    full: { type: "boolean", description: "Include the diff patch text per file", required: false, default: false },
+    live: {
+      type: "boolean",
+      description: "Read an in-progress Session's changes from its live workspace (slower)",
+      required: false,
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = { chatId: args.id };
+      if (args.surface) {
+        if (!REPO_SURFACES.includes(args.surface)) {
+          throw new Error(`--surface must be one of: ${REPO_SURFACES.join("|")}`);
+        }
+        body.surface = args.surface;
+      }
+      if (args.full) {
+        body.full = true;
+      }
+      if (args.live) {
+        body.live = true;
+      }
+      const response = await apiPost("/api/chats/diff", body);
+      writeJson({
+        ...response,
+        meta: { count: response.data.files.length },
+        ...!response.data.available && response.data.reason ? { hints: [response.data.reason] } : {},
+        ...response.data.available && !args.full && response.data.files.length > 0 ? { hints: ["Add --full to read the actual diff text for each file."] } : {}
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var chatsCommand = defineCommand({
+  meta: {
+    name: "chats",
+    description: `Inspect other Sessions on this account (read-only): list them, view what they produced, read their conversation, and see their real file changes \u2014 so you can reuse past work for a new goal.
+Full guide: __tooling__/docs/tools/baker/chats.md`
+  },
+  subCommands: {
+    list: listCommand,
+    view: viewCommand,
+    transcript: transcriptCommand,
+    diff: diffCommand
+  }
+});
+export {
+  chatsCommand
+};
+//# sourceMappingURL=chats-OXIYXI4U.js.map

package/dist/chunk-26HCUIW2.js

@@ -0,0 +1,166 @@
+import {
+  HEADLINE_SET_FLOOR,
+  SAME_CLAIM_HELD,
+  TELL_QUESTIONS,
+  copySentences,
+  sameClaimQuestion,
+  tellQuestionsFor
+} from "./chunk-4NZ47VXO.js";
+import {
+  rememberedJev
+} from "./chunk-QKUBK3AD.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-HH5PFZ7U.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-ANWV2VTO.js";
+import {
+  CAPABILITY_SURFACE_SPECS
+} from "./chunk-XQIOCIDO.js";
+
+// src/commands/capabilities/fix.ts
+function capabilityFix(surface) {
+  const spec = CAPABILITY_SURFACE_SPECS[surface];
+  return {
+    action: `baker capabilities ${surface}`,
+    explanation: `Do not guess another field name. \`baker capabilities ${surface}\` lists every ${spec.label} change with its required and optional fields and the exact values each field accepts, plus what cannot be changed here at all and why. Read it, then either re-stage correctly or tell the user this part is out of reach \u2014 and carry on with the rest of the job either way.`
+  };
+}
+
+// src/commands/ads/boolean-word-positional.ts
+var BOOLEAN_WORD = /^(true|false)$/i;
+function booleanWordPositionalError(args, entity) {
+  const positionals = Array.isArray(args._) ? args._ : [];
+  const word = positionals.find((value2) => typeof value2 === "string" && BOOLEAN_WORD.test(value2));
+  if (word === void 0) {
+    return void 0;
+  }
+  const value = word.toLowerCase();
+  const raised = Object.keys(args).filter((key) => key !== "_" && args[key] === true);
+  const named = raised.length > 0 ? raised.map((flag) => `--${flag}`).join(" or ") : "a boolean flag";
+  const fix = raised.length > 0 ? raised.map((flag) => `--${flag}=${value}`).join(" or ") : `--<flag>=${value}`;
+  const negated = raised.length === 1 && value === "false" ? ` (or --no-${raised[0]})` : "";
+  return `"${word}" was read as the ${entity} target, not as a value for ${named}. A boolean flag written with a space is set to TRUE and the word is dropped \u2014 attach it instead: ${fix}${negated}.`;
+}
+
+// src/commands/ads/copy-hints.ts
+import path from "path";
+
+// src/engine/copy-tells/judge.ts
+var SAMPLE_MAX = 60;
+var sample = (text) => text.length <= SAMPLE_MAX ? text : `${text.slice(0, SAMPLE_MAX)}\u2026`;
+async function judgedCopyTells(input, ask) {
+  const sentences = input.texts.flatMap((t) => copySentences(t));
+  const pairs = (input.headlineSets ?? []).map((set) => set.map((h) => h.trim()).filter(Boolean)).filter((set) => set.length >= HEADLINE_SET_FLOOR).flatMap((set, s) => set.flatMap((a, i) => set.slice(i + 1).map((b) => ({ set: s, a, b }))));
+  const questions = [...sentences.flatMap(tellQuestionsFor), ...pairs.map(({ a, b }) => sameClaimQuestion(a, b))];
+  if (questions.length === 0) return [];
+  const answers = await ask(questions);
+  if (answers === null) return null;
+  const tells = [];
+  TELL_QUESTIONS.forEach((tell, t) => {
+    const hits = sentences.filter((_, s) => (answers[s * TELL_QUESTIONS.length + t] ?? 0) >= tell.threshold);
+    if (hits.length > 0) tells.push({ id: tell.id, count: hits.length, sample: sample(hits[0]?.text ?? "") });
+  });
+  const offset = sentences.length * TELL_QUESTIONS.length;
+  const cycled = pairs.filter((_, p) => (answers[offset + p] ?? 0) >= SAME_CLAIM_HELD);
+  for (const set of new Set(cycled.map((p) => p.set))) {
+    const inSet = cycled.filter((p) => p.set === set);
+    const { a, b } = inSet[0] ?? { a: "", b: "" };
+    tells.push({ id: "synonym-cycling", count: inSet.length, sample: sample(`"${a}" / "${b}"`) });
+  }
+  return tells;
+}
+
+// src/commands/ads/copy-hints.ts
+var COPY_KEYS = /* @__PURE__ */ new Set([
+  "headline",
+  "headlines",
+  "longheadline",
+  "longheadlines",
+  "shortheadline",
+  "shortheadlines",
+  "description",
+  "descriptions",
+  "primarytext",
+  "primarytexts",
+  "message",
+  "messages",
+  "commentary",
+  "body",
+  "bodies",
+  "text",
+  "calltoaction",
+  "linkdescription",
+  "sitelinktext",
+  "callout",
+  "callouts",
+  "introtext"
+]);
+var HEADLINE_SET_KEYS = /* @__PURE__ */ new Set(["headlines", "longheadlines", "shortheadlines"]);
+var MAX_HINTS = 5;
+var SYNONYM_PAIR_FLOOR = 2;
+function asStrings(value) {
+  const one = (v) => {
+    const text = typeof v === "string" ? v : v !== null && typeof v === "object" ? v.text : "";
+    return typeof text === "string" && text.trim() ? text : void 0;
+  };
+  const values = Array.isArray(value) ? value : [value];
+  return values.map(one).filter((v) => v !== void 0);
+}
+function collectCopy(value, depth = 0) {
+  const texts = [];
+  const headlineSets = [];
+  if (depth > 4 || value === null || typeof value !== "object") return { texts, headlineSets };
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const nested = collectCopy(item, depth + 1);
+      texts.push(...nested.texts);
+      headlineSets.push(...nested.headlineSets);
+    }
+    return { texts, headlineSets };
+  }
+  for (const [key, raw] of Object.entries(value)) {
+    const normalized = key.toLowerCase().replace(/[_-]/g, "");
+    const strings = COPY_KEYS.has(normalized) ? asStrings(raw) : [];
+    if (strings.length > 0) {
+      texts.push(...strings);
+      if (HEADLINE_SET_KEYS.has(normalized) && strings.length > 1) headlineSets.push(strings);
+      continue;
+    }
+    const nested = collectCopy(raw, depth + 1);
+    texts.push(...nested.texts);
+    headlineSets.push(...nested.headlineSets);
+  }
+  return { texts, headlineSets };
+}
+function hintFor(tell) {
+  if (tell.id === "synonym-cycling") {
+    return `AI COPY TELL \u2014 ${tell.count} headline pairs are the same claim reworded (${tell.sample}). A cycled set gives the auction nothing to choose between: make each headline a different claim, not a different verb.`;
+  }
+  return `AI COPY TELL (${tell.id}) \u2014 "${tell.sample}". This construction reads as machine-written; rewrite it as a plain, specific claim before publishing.`;
+}
+async function adCopyHints(payload, ask) {
+  const { texts, headlineSets } = collectCopy(payload);
+  if (texts.length === 0) return [];
+  const cacheDir = path.join(findWorkspaceRoot(process.cwd()) ?? process.cwd(), "canvas", ".cache");
+  const spent = [];
+  const judged = await judgedCopyTells(
+    { texts: texts.flatMap((t) => t.split("\n")), headlineSets },
+    ask ?? rememberedJev(path.join(cacheDir, "copy-tells.json"), (u) => spent.push(u))
+  ).catch(() => null);
+  await holdUnbilledSpend(cacheDir, spent).catch(() => void 0);
+  const cycled = (judged ?? []).filter((t) => t.id === "synonym-cycling" && t.count >= SYNONYM_PAIR_FLOOR).sort((a, b) => b.count - a.count).slice(0, 1);
+  const tells = [...cycled, ...(judged ?? []).filter((t) => t.id !== "synonym-cycling")];
+  tells.sort(
+    (a, b) => (b.id === "synonym-cycling" ? 1 : 0) - (a.id === "synonym-cycling" ? 1 : 0) || b.count - a.count
+  );
+  return tells.slice(0, MAX_HINTS).map(hintFor);
+}
+
+export {
+  capabilityFix,
+  booleanWordPositionalError,
+  adCopyHints
+};
+//# sourceMappingURL=chunk-26HCUIW2.js.map