@koda-sl/baker-cli 0.559.0 → 0.561.0

package/dist/rules-Y75KR2PC.js

@@ -0,0 +1,217 @@
+import {
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-5H6N36LS.js";
+import "./chunk-QALAJNBG.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-RBCO3C3Q.js";
+import {
+  apiGet
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/rules.ts
+import { defineCommand } from "citty";
+function compactRule(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    status: row.status,
+    does: row.description,
+    ...row.disable_error_code ? { disable_error_code: row.disable_error_code } : {},
+    updated_time: row.updated_time
+  };
+}
+function ruleListHints(rows) {
+  const hints = [];
+  if (rows.length === 0) {
+    hints.push(
+      'No automated rules on this account. Stage one with `baker ads meta rules create --name \u2026 --apply-to ad --when "cost_per_result>20" --action pause`.'
+    );
+  }
+  const issues = rows.filter((row) => row.status === "HAS_ISSUES");
+  if (issues.length > 0) {
+    hints.push(
+      `${issues.map((row) => row.name ?? row.id).join(", ")} ${issues.length === 1 ? "has" : "have"} been stopped by Meta (HAS_ISSUES) \u2014 read it with --rule-id and fix the spec with \`rules update\`.`
+    );
+  }
+  if (rows.length > 0) {
+    hints.push(
+      "`rules history --rule-id <id>` shows what a rule did and when; `rules preview <id>` what it would act on now."
+    );
+  }
+  return hints;
+}
+registerSchema({
+  command: "ads.meta.rules",
+  description: "List the automated rules on a Meta ad account (Ads Manager \u2192 Automated rules): each rule's status and what it does, in words. --rule-id reads one; --full adds its evaluation_spec, execution_spec and schedule_spec in the shape `rules update --file` takes (money in major units of the account currency).",
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID (act_123)", required: false },
+    "rule-id": { type: "string", description: "Read one rule", required: false },
+    full: { type: "boolean", description: "Include the specs and timestamps", required: false }
+  }
+});
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List automated rules. Runs by default. Example: baker ads meta rules --account-id act_123 \xB7 one rule in full: baker ads meta rules --rule-id 1132635173044914 --full"
+  },
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID" },
+    "rule-id": { type: "string", description: "Read one rule" },
+    full: { type: "boolean", description: "Include the specs and timestamps" }
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["rule-id"]) params["rule-id"] = String(args["rule-id"]);
+      const rows = await apiGet("/api/ads/meta/rules", params);
+      const full = Boolean(args.full) || Boolean(args["rule-id"]);
+      writeJsonEnvelope({ ok: true, data: full ? rows : rows.map(compactRule), hints: ruleListHints(rows) });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+function compactHistory(row) {
+  const changes = (row.results ?? []).flatMap(
+    (result) => (result.actions ?? []).map((action) => ({
+      object_id: result.object_id,
+      action: action.action,
+      ...action.field ? { field: action.field } : {},
+      ...action.old_value !== void 0 ? { from: action.old_value } : {},
+      ...action.new_value !== void 0 ? { to: action.new_value } : {}
+    }))
+  );
+  return {
+    timestamp: row.timestamp,
+    rule_id: row.rule_id,
+    ...row.is_manual ? { manual: true } : {},
+    changes,
+    ...row.exception_message ? { error: row.exception_message } : {}
+  };
+}
+registerSchema({
+  command: "ads.meta.rules.history",
+  description: "What automated rules did and when: each run with the objects it changed (PAUSED, CHANGED_BUDGET, \u2026, old \u2192 new value). Without --rule-id, every rule on the account, newest first.",
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID (act_123)", required: false },
+    "rule-id": { type: "string", description: "One rule's runs", required: false },
+    "object-id": { type: "string", description: "Only runs that touched this ad, ad set or campaign", required: false },
+    action: { type: "string", description: "Only this action, e.g. PAUSED, CHANGED_BUDGET", required: false },
+    "hide-no-changes": { type: "boolean", description: "Drop runs that changed nothing", required: false },
+    limit: { type: "string", description: "Max runs (default 50)", required: false },
+    full: { type: "boolean", description: "Include the rule's specs at each run", required: false }
+  }
+});
+var historyCommand = defineCommand({
+  meta: {
+    name: "history",
+    description: "What rules did and when. Example: baker ads meta rules history --rule-id 1132635173044914 --hide-no-changes \xB7 every rule: baker ads meta rules history --account-id act_123"
+  },
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID" },
+    "rule-id": { type: "string", description: "One rule's runs" },
+    "object-id": { type: "string", description: "Only runs that touched this object" },
+    action: { type: "string", description: "Only this action (PAUSED, CHANGED_BUDGET, \u2026)" },
+    "hide-no-changes": { type: "boolean", description: "Drop runs that changed nothing" },
+    limit: { type: "string", description: "Max runs (default 50)" },
+    full: { type: "boolean", description: "Include the rule's specs at each run" }
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      for (const key of ["rule-id", "object-id", "action", "limit"]) {
+        if (args[key]) params[key] = String(args[key]);
+      }
+      if (args["hide-no-changes"]) params["hide-no-changes"] = "true";
+      const rows = await apiGet("/api/ads/meta/rules/history", params);
+      const hints = rows.length === 0 ? [
+        "No runs recorded. A daily rule first runs just after midnight in the ad account's time zone; a switched-off rule never runs."
+      ] : [];
+      writeJsonEnvelope({ ok: true, data: args.full ? rows : rows.map(compactHistory), hints });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.rules.preview",
+  description: "Which ads, ad sets or campaigns a live schedule rule would act on right now, by Meta's own evaluation. Changes nothing.",
+  args: {
+    id: { type: "positional", description: "Rule id", required: true },
+    "account-id": { type: "string", description: "Meta ad account ID (act_123)", required: false }
+  }
+});
+var previewCommand = defineCommand({
+  meta: {
+    name: "preview",
+    description: "What a rule would act on right now (changes nothing). Example: baker ads meta rules preview 1132635173044914"
+  },
+  args: {
+    id: { type: "positional", description: "Rule id", required: true },
+    "account-id": { type: "string", description: "Meta ad account ID" }
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const data = await apiGet("/api/ads/meta/rules/preview", {
+        "account-id": accountId,
+        "rule-id": String(args.id)
+      });
+      const hints = data.matched.length === 0 ? ["Nothing matches right now \u2014 the rule would change nothing if it ran now."] : [];
+      writeJsonEnvelope({ ok: true, data, hints });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+var rulesCommand = defineCommand({
+  meta: {
+    name: "rules",
+    description: `Meta automated rules \u2014 Meta's own automation, which runs on Meta with no Baker involvement once created.
+Use one for a standing "if this metric crosses that line, do X" that needs no judgement; use a Baker scheduled agent when the call needs reasoning.
+
+Examples:
+  baker ads meta rules --account-id act_123                                     # every rule, what it does
+  baker ads meta rules --rule-id 1132635173044914                                # one rule with its specs
+  baker ads meta rules history --rule-id 1132635173044914 --hide-no-changes      # what it did
+  baker ads meta rules preview 1132635173044914                                  # what it would act on now
+  baker ads meta rules create --name "Stop expensive ads" --apply-to ad --when "cost_per_result>20" --action pause
+  baker ads meta rules update 1132635173044914 --name "Stop very expensive ads"
+  baker ads meta rules disable|enable|delete 1132635173044914
+  baker ads meta rules run 1132635173044914                                     # run it once, at publish`
+  },
+  subCommands: {
+    list: listCommand,
+    history: historyCommand,
+    preview: previewCommand,
+    create: () => import("./rule-writes-WT6DQZZE.js").then((m) => m.rulesCreateCommand),
+    update: () => import("./rule-writes-WT6DQZZE.js").then((m) => m.rulesUpdateCommand),
+    enable: () => import("./rule-writes-WT6DQZZE.js").then((m) => m.rulesEnableCommand),
+    disable: () => import("./rule-writes-WT6DQZZE.js").then((m) => m.rulesDisableCommand),
+    delete: () => import("./rule-writes-WT6DQZZE.js").then((m) => m.rulesDeleteCommand),
+    run: () => import("./rule-writes-WT6DQZZE.js").then((m) => m.rulesRunCommand)
+  },
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID" },
+    "rule-id": { type: "string", description: "Read one rule" },
+    full: { type: "boolean", description: "Include the specs and timestamps" }
+  },
+  default: "list"
+});
+export {
+  compactHistory,
+  compactRule,
+  ruleListHints,
+  rulesCommand
+};
+//# sourceMappingURL=rules-Y75KR2PC.js.map

package/dist/rules-add-2GIJGODB.js

@@ -0,0 +1,465 @@
+import {
+  loadCandidate
+} from "./chunk-V6N6UBOT.js";
+import {
+  rulesView
+} from "./chunk-QVQKCVP7.js";
+import {
+  fetchRunRecord
+} from "./chunk-UKDILXEA.js";
+import {
+  readAllRules
+} from "./chunk-3FLSRUID.js";
+import {
+  RULES_DIR,
+  RULE_APPLIES,
+  RULE_KINDS,
+  RULE_STRENGTHS,
+  parseRuleFile
+} from "./chunk-UKZKLXTE.js";
+import "./chunk-KDAINT54.js";
+import {
+  holdWorkspaceSpend
+} from "./chunk-Y5PNLB24.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-N3PASNUA.js";
+import {
+  reviewAgainstRules
+} from "./chunk-6QINKM6T.js";
+import {
+  reviewedRules
+} from "./chunk-DLM5OSHM.js";
+import "./chunk-MCJ5I5LR.js";
+import {
+  askJev
+} from "./chunk-E56V3RFO.js";
+import "./chunk-EL3TDR5S.js";
+import "./chunk-G6U45QD3.js";
+import "./chunk-X6U3B6YK.js";
+import "./chunk-TK7VRZKM.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/rules-add.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+import sharp from "sharp";
+
+// src/engine/creative-rules/admission.ts
+async function breaks(rule, version, review) {
+  const found = await review(version, [rule]).catch(() => null);
+  return found === null ? null : found.filter((f) => f.kind?.rule === rule.id && f.severity === "blocking");
+}
+async function admissionTest(rule, origin, approved, review) {
+  const untested = { origin: "untested", approved: { checked: 0, blocked: [] } };
+  const tested = { ...rule, strength: rule.strength === "prefer" ? "must" : rule.strength };
+  if (reviewedRules([tested]).length === 0) return untested;
+  const own = origin ? await breaks(tested, origin, review) : null;
+  const results = await Promise.all(
+    approved.map(async (v) => ({ runId: v.runId, found: await breaks(tested, v, review) }))
+  );
+  const looked = results.filter((r) => r.found !== null);
+  return {
+    origin: own === null ? "untested" : own.length > 0 ? "caught" : "missed",
+    approved: {
+      checked: looked.length,
+      blocked: looked.flatMap(
+        (r) => r.found?.[0] ? [{ runId: r.runId, what: r.found[0].what.replace(/^.*?\): /, "") }] : []
+      )
+    }
+  };
+}
+function admissionRefusal(rule, admission) {
+  if (admission.origin === "missed") {
+    return {
+      code: "RULE_MISSES_ITS_AD",
+      message: `Not saved: "${rule.text}" does not catch the version it came from (${rule.source.runId ?? "the rejected one"}), so it is worded for something else.`,
+      fix: "Reword it to name exactly what was wrong on that version, in the person's words, and add it again; or ask the person what the rule is."
+    };
+  }
+  const blocked = admission.approved.blocked;
+  if (blocked.length > 0) {
+    return {
+      code: "RULE_BLOCKS_APPROVED",
+      message: `Not saved: "${rule.text}" would block ${blocked.length} version${blocked.length === 1 ? "" : "s"} the person approved: ${blocked.map((b) => `${b.runId} (${b.what})`).join("; ")}.`,
+      fix: "Ask the person whether those approved ads break it. If they do not, reword the rule so it names only what they reject, and add it again."
+    };
+  }
+  return null;
+}
+
+// src/engine/creative-rules/compare.ts
+var SAME = "Do rules `a` and `b` ask the same thing of an ad, in any words or language, so that an ad keeping one keeps the other?";
+var CONFLICT = "Do rules `a` and `b` contradict each other, so that no ad could keep both: following one breaks the other?";
+var SAME_BAND = 0.6;
+var CONFLICT_BAND = 0.6;
+var BATCH = 40;
+function jevPairs(onSpend) {
+  return async (pairs) => {
+    const answers = [];
+    for (let i = 0; i < pairs.length; i += BATCH) {
+      const batch = pairs.slice(i, i + BATCH);
+      const got = await askJev(
+        batch.map((p) => ({ instructions: { a: p.a, b: p.b, question: p.question === "same" ? SAME : CONFLICT } })),
+        onSpend
+      );
+      if (!got) return null;
+      answers.push(...got);
+    }
+    return answers;
+  };
+}
+async function compareRule(candidate, existing, ask) {
+  const active = existing.filter((r) => r.status === "active" && r.id !== candidate.id);
+  if (active.length === 0) return { same: [], conflicts: [], judged: true };
+  const pairs = active.flatMap((r) => [
+    { a: candidate.text, b: r.text, question: "same" },
+    { a: candidate.text, b: r.text, question: "conflict" }
+  ]);
+  const answers = await ask(pairs).catch(() => null);
+  if (!answers || answers.length !== pairs.length) return { same: [], conflicts: [], judged: false };
+  return {
+    same: active.filter((_, i) => (answers[2 * i] ?? 0) >= SAME_BAND),
+    conflicts: active.filter((_, i) => (answers[2 * i + 1] ?? 0) >= CONFLICT_BAND),
+    judged: true
+  };
+}
+
+// src/engine/creative-rules/write.ts
+import { stringify as stringifyYaml } from "yaml";
+function ruleFileText(rule) {
+  const frontmatter = {
+    strength: rule.strength,
+    applies: rule.applies,
+    ...Object.keys(rule.scope).length > 0 ? { scope: rule.scope } : {},
+    ...rule.check && Object.keys(rule.check).length > 0 ? { check: rule.check } : {},
+    source: rule.source,
+    status: rule.status,
+    ...rule.retiredBy ? { retiredBy: rule.retiredBy } : {}
+  };
+  const yaml = stringifyYaml(frontmatter, { defaultStringType: "QUOTE_DOUBLE", defaultKeyType: "PLAIN", lineWidth: 0 });
+  return `---
+${yaml}---
+${rule.text.trim()}
+${rule.why ? `
+Why: ${rule.why.trim()}
+` : ""}`;
+}
+var SLUG_WORDS = 8;
+function ruleSlug(text2, taken) {
+  const base = text2.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean).slice(0, SLUG_WORDS).join("-") || "rule";
+  if (!taken.includes(base)) return base;
+  let n = 2;
+  while (taken.includes(`${base}-${n}`)) n++;
+  return `${base}-${n}`;
+}
+
+// src/commands/creatives/rules-add.ts
+var oneOf = (values, value) => value && values.includes(value) ? value : void 0;
+var defined = (value) => Object.fromEntries(
+  Object.entries(value).filter(([, v]) => v !== void 0 && !(Array.isArray(v) && v.length === 0))
+);
+function scopeOf(f, c) {
+  return defined({
+    kinds: (f.kinds ?? c?.kinds)?.flatMap((k) => oneOf(RULE_KINDS, k) ?? []),
+    products: f.products,
+    platforms: f.platforms ?? c?.platforms,
+    language: f.language ?? c?.language
+  });
+}
+function checkOf(f, c) {
+  const realPeople = f.people === void 0 ? c?.people === "real" : f.people === "real";
+  return defined({
+    forbid: f.forbid ?? c?.forbid,
+    require: f.require ?? c?.require,
+    allow: f.allow ?? c?.allow,
+    people: realPeople ? "real" : void 0
+  });
+}
+function ruleFromInputs(inputs, at) {
+  const c = inputs.candidate;
+  const f = inputs.flags ?? {};
+  const text2 = (f.text ?? c?.text)?.trim();
+  if (!text2) return { error: "--text: the rule, in the person's words (or --candidate <id> from `feedback record`)." };
+  const check = checkOf(f, c);
+  const source = defined({
+    kind: c ? "feedback" : "user",
+    slug: f.slug ?? c?.source.slug,
+    runId: f.run ?? c?.source.runId,
+    quote: f.quote ?? c?.source.quote,
+    date: at.today
+  });
+  return {
+    id: ruleSlug(f.id ?? text2, at.taken),
+    origin: "learned",
+    strength: oneOf(RULE_STRENGTHS, f.strength) ?? c?.strength ?? "must",
+    applies: oneOf(RULE_APPLIES, f.applies) ?? c?.applies ?? "any",
+    scope: scopeOf(f, c),
+    ...Object.keys(check).length > 0 ? { check } : {},
+    text: text2,
+    ...f.why ? { why: f.why } : {},
+    source,
+    status: "active"
+  };
+}
+async function versionOf(runId) {
+  const record = await fetchRunRecord(runId).catch(() => null);
+  const images = (record?.finalOutputs ?? []).filter((o) => o.kind === "image" && o.url);
+  const stills = await Promise.all(
+    images.map(async (o) => {
+      const response = await fetch(o.url).catch(() => null);
+      if (!response?.ok) return null;
+      const bytes = Buffer.from(await response.arrayBuffer());
+      return (await sharp(bytes).resize({ width: 1024 }).jpeg({ quality: 85 }).toBuffer()).toString("base64");
+    })
+  );
+  const kept = images.flatMap(
+    (o, i) => stills[i] ? [{ still: stills[i], format: o.label ?? "image" }] : []
+  );
+  return kept.length > 0 ? { runId, stills: kept.map((k) => k.still), formats: kept.map((k) => k.format) } : null;
+}
+var APPROVED_VERSIONS = 3;
+async function approvedVersions(except, slug) {
+  const feedback = await apiPost("/api/creatives/feedback", { full: true }).catch(
+    () => null
+  );
+  const approved = (feedback?.data.recent ?? []).filter((e) => e.verdict === "approved" && e.runId !== except);
+  const ordered = [...approved.filter((e) => e.creative !== slug), ...approved.filter((e) => e.creative === slug)];
+  const runIds = [...new Set(ordered.map((e) => e.runId))];
+  const versions = [];
+  for (const runId of runIds) {
+    if (versions.length === APPROVED_VERSIONS) break;
+    const version = await versionOf(runId);
+    if (version) versions.push(version);
+  }
+  return versions;
+}
+async function admit(rule) {
+  const spent = [];
+  const review = (version, rules) => reviewAgainstRules({ ...version, rules, onSpend: (u) => spent.push(u) });
+  const [origin, approved] = await Promise.all([
+    rule.source.runId ? versionOf(rule.source.runId) : Promise.resolve(null),
+    approvedVersions(rule.source.runId, rule.source.slug)
+  ]);
+  const admission = await admissionTest(rule, origin, approved, review);
+  await holdWorkspaceSpend(spent);
+  return admission;
+}
+async function compareHoldingSpend(rule, existing) {
+  const spent = [];
+  try {
+    return await compareRule(
+      rule,
+      existing,
+      jevPairs((u) => spent.push(u))
+    );
+  } finally {
+    await holdWorkspaceSpend(spent);
+  }
+}
+async function retireFile(root, id, by) {
+  const file = path.join(root, RULES_DIR, `${id}.md`);
+  const rule = parseRuleFile(id, await readFile(file, "utf8").catch(() => ""));
+  if (!rule) return null;
+  const retired = { ...rule, status: "retired", ...by ? { retiredBy: by } : {} };
+  await writeFile(file, ruleFileText(retired), "utf8");
+  return retired;
+}
+function fail(code, message, fix, extra = {}) {
+  writeJson({ ok: false, error: { code, message, ...fix ? { fix } : {}, ...extra } });
+  process.exit(1);
+}
+var list = (value) => typeof value === "string" && value.trim() ? value.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+var text = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+var ADD_DESCRIPTION = `Save a rule the person agreed to, for every ad from now on: one file in src/content/creative-rules/, published with the Session. Only after they said yes to "make this a rule for every ad?".
+Start here: baker creatives rules add --candidate rc-1a2b3c4d          # a rule \`feedback record\` drafted from their words
+  baker creatives rules add --text "No AI-generated people." --strength never --applies cast --people real --quote "<their words>" --slug <ad> --run <r_\u2026>
+It is refused when the company already has it (DUPLICATE_RULE), when it contradicts one (RULE_CONFLICT: ask which wins, then --replaces <id>), when it does not catch the version it came from (RULE_MISSES_ITS_AD), or would block versions the person approved (RULE_BLOCKS_APPROVED): ask the person, never save it anyway.`;
+var ADD_ARGS = {
+  candidate: {
+    type: "string",
+    description: "A rule `feedback record` drafted (rc-\u2026): the flags below override its parts",
+    required: false
+  },
+  text: {
+    type: "string",
+    description: "The rule, one sentence, in the person's own language and words",
+    required: false
+  },
+  strength: {
+    type: "string",
+    description: `${RULE_STRENGTHS.join(" | ")}: never and must are checked and block; prefer is a note`,
+    required: false
+  },
+  applies: { type: "string", description: `What of the ad it is about: ${RULE_APPLIES.join(", ")}`, required: false },
+  forbid: {
+    type: "string",
+    description: 'Words it bans, comma-separated, only when a word decides it ("online")',
+    required: false
+  },
+  allow: { type: "string", description: 'The right phrase that holds a banned word ("100 % online")', required: false },
+  require: { type: "string", description: "Words every ad must say, comma-separated (rare)", required: false },
+  people: {
+    type: "string",
+    description: "real: only real people appear (a real person's Avatar, a customer, footage or nobody)",
+    required: false
+  },
+  kinds: { type: "string", description: "static,video: only ads of these kinds", required: false },
+  products: { type: "string", description: "Product slugs (a business unit): only ads of these", required: false },
+  platforms: { type: "string", description: "meta,linkedin,\u2026: only ads for these", required: false },
+  language: {
+    type: "string",
+    description: "The language its words are in (es): its banned words are checked only in ads in it",
+    required: false
+  },
+  quote: { type: "string", description: "The person's own words it came from, verbatim", required: false },
+  slug: { type: "string", description: "The creative they said it about", required: false },
+  run: { type: "string", description: "The version they said it about (r_\u2026): the rule must catch it", required: false },
+  why: { type: "string", description: "Why, in a sentence, when the person said", required: false },
+  id: { type: "string", description: "The rule's id (its file name); default: from its words", required: false },
+  replaces: {
+    type: "string",
+    description: "A rule of the person's it contradicts and wins over: retired, never deleted",
+    required: false
+  }
+};
+registerSchema({ command: "creatives.rules.add", description: ADD_DESCRIPTION, args: ADD_ARGS });
+function brandMdHint(declared, relation) {
+  return relation === "same" ? `BRAND.md states this too ("${declared.text}"): now the person confirmed it, every finished ad is checked against it.` : `BRAND.md says otherwise ("${declared.text}"): tell the person, and change only that line of BRAND.md (/brand-build) so it no longer says otherwise; never write the rule itself into BRAND.md, or retiring it would leave it in force.`;
+}
+var rulesAddCommand = defineCommand({
+  meta: { name: "add", description: ADD_DESCRIPTION },
+  args: ADD_ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const cacheDir = path.join(root, "canvas", ".cache");
+    const candidateId = text(args.candidate);
+    const candidate = candidateId ? await loadCandidate(cacheDir, candidateId) : void 0;
+    if (candidateId && !candidate) {
+      fail(
+        "VALIDATION_ERROR",
+        `No drafted rule ${candidateId} here.`,
+        "Use the id `feedback record` printed in this chat, or pass --text."
+      );
+    }
+    const all = await readAllRules(root);
+    const rule = ruleFromInputs(
+      {
+        ...candidate ? { candidate } : {},
+        flags: {
+          text: text(args.text),
+          strength: text(args.strength),
+          applies: text(args.applies),
+          forbid: list(args.forbid),
+          allow: list(args.allow),
+          require: list(args.require),
+          people: text(args.people),
+          kinds: list(args.kinds),
+          products: list(args.products),
+          platforms: list(args.platforms),
+          language: text(args.language),
+          quote: text(args.quote),
+          slug: text(args.slug),
+          run: text(args.run),
+          why: text(args.why),
+          id: text(args.id)
+        }
+      },
+      { today: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), taken: all.map((r) => r.id) }
+    );
+    if ("error" in rule) fail("VALIDATION_ERROR", rule.error);
+    const replaces = text(args.replaces);
+    const compared = await compareHoldingSpend(rule, all);
+    const sameTaught = compared.same.filter((r) => r.origin === "learned");
+    if (sameTaught.length > 0) {
+      fail(
+        "DUPLICATE_RULE",
+        `The company already has this rule: ${sameTaught.map((r) => `${r.id} ("${r.text}")`).join("; ")}.`,
+        "Nothing to add. If the person wants it worded otherwise, retire that one and add this."
+      );
+    }
+    const conflicts = compared.conflicts.filter((r) => r.origin === "learned" && r.id !== replaces);
+    if (conflicts.length > 0) {
+      fail(
+        "RULE_CONFLICT",
+        `It contradicts ${conflicts.map((r) => `${r.id} ("${r.text}")`).join("; ")}.`,
+        "Ask the person which one wins. This one: add it again with --replaces <id> (that rule is retired, never deleted). The other: do not add this one."
+      );
+    }
+    const admission = await admit(rule);
+    const refusal = admissionRefusal(rule, admission);
+    if (refusal) fail(refusal.code, refusal.message, refusal.fix, { admission });
+    await mkdir(path.join(root, RULES_DIR), { recursive: true });
+    const file = path.join(RULES_DIR, `${rule.id}.md`);
+    await writeFile(path.join(root, file), ruleFileText(rule), "utf8");
+    const retired = replaces ? await retireFile(root, replaces, rule.id) : null;
+    const declared = [...compared.same, ...compared.conflicts].filter((r) => r.origin === "declared");
+    writeJson({
+      ok: true,
+      data: {
+        rule: rulesView([rule], { full: true })[0],
+        file,
+        admission,
+        ...retired ? { retired: retired.id } : {}
+      },
+      hints: [
+        `Saved for every ad from now on${admission.origin === "untested" ? " (not tested on a version: nothing a picture shows decides it, or the version had no picture)" : ""}. Tell the person in one line, then run \`baker creatives check\`: which ads already made break it.`,
+        ...compared.judged ? [] : [
+          "Whether it repeats or contradicts another rule could not be read (the decision model did not answer): look at `baker creatives rules list`."
+        ],
+        ...declared.map((r) => brandMdHint(r, compared.same.includes(r) ? "same" : "conflict"))
+      ]
+    });
+  }
+});
+var RETIRE_DESCRIPTION = `Retire a rule a person taught, when they say it no longer holds or another replaces it: it stays in its file as retired, never deleted, and no ad is held to it.
+Start here: baker creatives rules retire cien-por-cien-online [--by <rule id>|BRAND.md]
+A rule of BRAND.md is changed in BRAND.md (/brand-build).`;
+var RETIRE_ARGS = {
+  id: { type: "positional", description: "The rule's id (`baker creatives rules list`)", required: true },
+  by: { type: "string", description: "What replaces it: another rule's id, or BRAND.md", required: false }
+};
+registerSchema({ command: "creatives.rules.retire", description: RETIRE_DESCRIPTION, args: RETIRE_ARGS });
+var rulesRetireCommand = defineCommand({
+  meta: { name: "retire", description: RETIRE_DESCRIPTION },
+  args: RETIRE_ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const id = String(args.id);
+    if (/^brand-[0-9a-f]{8}$/.test(id)) {
+      fail("VALIDATION_ERROR", `${id} is a rule of BRAND.md.`, "Change it in BRAND.md with /brand-build.");
+    }
+    const retired = await retireFile(root, id, text(args.by));
+    if (!retired) fail("NOT_FOUND", `No rule ${id} in ${RULES_DIR}.`, "See `baker creatives rules list --all`.");
+    writeJson({
+      ok: true,
+      data: { rule: rulesView([retired], { full: true })[0] },
+      hints: ["Retired: no ad is held to it from now on."]
+    });
+  }
+});
+export {
+  brandMdHint,
+  compareHoldingSpend,
+  ruleFromInputs,
+  rulesAddCommand,
+  rulesRetireCommand
+};
+//# sourceMappingURL=rules-add-2GIJGODB.js.map