@koda-sl/baker-cli 0.451.0-dev.b2a4eba2b → 0.451.0-dev.d9192b76e

package/dist/chunk-4NDCTLI5.js

@@ -0,0 +1,191 @@
+import {
+  hintLines,
+  splitHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  isNotConnectedError,
+  writeJsonEnvelope
+} from "./chunk-VFIOJD5M.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-XBOK23HI.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-NAWWC5I3.js";
+
+// src/commands/ga4/shared.ts
+import { readFileSync } from "fs";
+function failValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function requireTarget(args, entity) {
+  const positional = Array.isArray(args._) ? args._[0] : void 0;
+  const target = args.id ?? args.target ?? positional;
+  if (typeof target !== "string" || target.length === 0) {
+    failValidation(`pass the ${entity} id as the positional argument`);
+  }
+  return target;
+}
+function readJsonSource(args, flag) {
+  const inline = args[flag];
+  const file = args.file;
+  const raw = typeof file === "string" && file.length > 0 ? readFileSync(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
+  if (raw === void 0) {
+    failValidation(`pass --${flag} with inline JSON or --file with a path to a JSON file`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return failValidation(`--${flag} is not valid JSON`);
+  }
+}
+function asObject(value, flag, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    failValidation(
+      index === void 0 ? `--${flag} must be a JSON object` : `--${flag}[${index}] must be a JSON object`
+    );
+  }
+  return value;
+}
+function loadJsonArg(args, flag = "json") {
+  return asObject(readJsonSource(args, flag), flag);
+}
+function loadJsonPayloads(args) {
+  const parsed = readJsonSource(args, "json");
+  if (!Array.isArray(parsed)) {
+    return [asObject(parsed, "json")];
+  }
+  if (parsed.length === 0) {
+    failValidation("--json is an empty list \u2014 pass at least one definition");
+  }
+  return parsed.map((entry, index) => asObject(entry, "json", index));
+}
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["RATE_LIMITED", "UNAVAILABLE", "INTERNAL_ERROR", "NETWORK_ERROR", "TIMEOUT"]);
+function handleError(err) {
+  if (err instanceof ApiError) {
+    const readOnly = err.code === "FORBIDDEN" && /read the property but not change it/i.test(err.message);
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        ...readOnly ? {
+          fix: {
+            action: "reconnect",
+            explanation: "The Google Analytics connection is read-only. Ask the user to reconnect Google Analytics \u2014 in the dashboard, Brain \u2192 Integrations \u2192 Platforms \u2192 Google Analytics \u2014 which grants the permission to change the property. Reporting (`baker ga4 query`, `baker ga4 audit`) keeps working meanwhile, so carry on with the rest of the job and tell them what you will set up once they have reconnected. Don't claim anything was configured."
+          }
+        } : err.code === "UNAUTHORIZED" || err.code === "FORBIDDEN" && isNotConnectedError(err.code, err.message) ? {
+          fix: {
+            action: "request_connection",
+            explanation: 'Google Analytics is not connected for this company yet, or no property has been picked. Don\'t send the user to Settings \u2014 call the `request_connection` tool with { platform: "google-analytics", reason } and they connect and pick their property from inside the chat. If the `request_connection` call fails, say so plainly and give the exact route: dashboard \u2192 Brain \u2192 Integrations \u2192 Platforms \u2192 Google Analytics. Then carry on with the rest of the task.'
+          }
+        } : {},
+        retryable: RETRYABLE_CODES.has(err.code)
+      }
+    });
+    process.exit(1);
+  }
+  writeJsonEnvelope({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error", retryable: true } });
+  process.exit(1);
+}
+var STAGE_HINTS = [
+  "Staged only \u2014 nothing has changed in Google Analytics yet. These apply when the chat completes, and an applied change takes effect on the property immediately: there is no version to publish afterwards and no undo. Say the changes are ready and take effect when the user completes the chat \u2014 not that they are done already."
+];
+var WARNING_HINT = "Read the warnings above before telling the user this is ready.";
+async function stageOp(op) {
+  const chatId = requireChatId();
+  try {
+    const { data, hints } = splitHints(await apiPost("/api/ga4/draft/stage", { chatId, op }));
+    writeJsonEnvelope({
+      ok: true,
+      data,
+      hints: [...hints, ...STAGE_HINTS, ...data.warnings.length > 0 ? [WARNING_HINT] : []]
+    });
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function stageOps(ops) {
+  const [only] = ops;
+  if (ops.length === 1 && only) {
+    await stageOp(only);
+    return;
+  }
+  const chatId = requireChatId();
+  try {
+    const { data, hints } = splitHints(
+      await apiPost("/api/ga4/draft/stage-batch", { chatId, ops })
+    );
+    writeJsonEnvelope({
+      ok: true,
+      data,
+      hints: [...hints, ...STAGE_HINTS, ...data.ops.some((op) => op.warnings.length > 0) ? [WARNING_HINT] : []]
+    });
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function draftAction(path, body, chat) {
+  const chatId = resolveChatId(chat);
+  try {
+    const { data, hints } = splitHints(await apiPost(path, { chatId, ...body }));
+    writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+    return data;
+  } catch (err) {
+    handleError(err);
+  }
+}
+function renderDraft(response) {
+  if (response.count === 0) {
+    return "No Google Analytics changes staged on this chat.";
+  }
+  const lines = [
+    `${response.count} staged Google Analytics change(s)`,
+    ...response.ops.map((op) => {
+      const status = op.result ? ` [${op.result.status}]` : "";
+      return `  ${op.ref}  ${op.summary}${status}`;
+    })
+  ];
+  if (response.status === "applied") {
+    const failed = response.ops.filter((op) => op.result?.status !== "applied");
+    lines.push(
+      "",
+      failed.length === 0 ? "All applied \u2014 these are in effect on the property now." : `${failed.length} of ${response.count} did not apply. The rest are in effect on the property.`
+    );
+  }
+  if (response.publishError) {
+    lines.push("", response.publishError);
+  }
+  return lines.join("\n");
+}
+async function draftList(json, chat) {
+  const chatId = resolveChatId(chat);
+  try {
+    const response = await apiPost("/api/ga4/draft", { chatId });
+    const { data, hints } = splitHints(response);
+    if (json) {
+      writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+      return;
+    }
+    process.stdout.write(`${renderDraft(data)}${hintLines(response)}
+`);
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+export {
+  failValidation,
+  requireTarget,
+  loadJsonArg,
+  loadJsonPayloads,
+  handleError,
+  stageOp,
+  stageOps,
+  draftAction,
+  draftList
+};
+//# sourceMappingURL=chunk-4NDCTLI5.js.map

package/dist/chunk-4QEY2L6U.js

@@ -0,0 +1,486 @@
+import {
+  rememberedJev
+} from "./chunk-F2S5BLPE.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-WTOYCUKH.js";
+import {
+  staticFormatPatternSchema
+} from "./chunk-TEINLN64.js";
+
+// src/commands/creatives/ideas-model.ts
+import { parse as parseYaml, YAMLParseError } from "yaml";
+var IDEA_ANGLES = [
+  "pain_relief",
+  "aspiration",
+  "status",
+  "fear",
+  "FOMO",
+  "identity",
+  "contrarian",
+  "education",
+  "novelty",
+  "authority",
+  "community",
+  "transformation",
+  "convenience",
+  "save_money",
+  "save_time",
+  "save_effort",
+  "named_enemy",
+  "objection_crusher",
+  "villain_democratization",
+  "commiseration",
+  "recognition_mirror",
+  "flipped_idiom"
+];
+var IDEA_VIDEO_FORMATS = [
+  "video_ugc",
+  "video_founder",
+  "video_testimonial",
+  "video_demo",
+  "video_screen_recording",
+  "video_explainer",
+  "video_motion_graphics"
+];
+var IDEA_FORMATS = [...staticFormatPatternSchema.options, ...IDEA_VIDEO_FORMATS];
+var AWARENESS_STAGES = ["unaware", "problem_aware", "solution_aware", "product_aware", "most_aware"];
+var EVIDENCE_LEVELS = ["observed", "interpreted", "hypothesized", "generated"];
+var IDEA_STATUSES = ["idea", "built", "testing", "winner", "failed", "inconclusive", "retired"];
+var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---/;
+function frontmatterOf(markdown) {
+  const block = FRONTMATTER.exec(markdown)?.[1];
+  if (block === void 0) return null;
+  try {
+    const parsed = parseYaml(block);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function frontmatterError(markdown) {
+  const block = FRONTMATTER.exec(markdown)?.[1];
+  if (block === void 0) return null;
+  try {
+    parseYaml(block);
+    return null;
+  } catch (e) {
+    const line = e instanceof YAMLParseError ? e.linePos?.[0]?.line : void 0;
+    const at = line ? ` at line ${line} (\`${block.split(/\r?\n/)[line - 1]?.trim() ?? ""}\`)` : "";
+    return `the frontmatter is not valid YAML${at}: put each text value wholly in double quotes, with any quote inside it as \\" or as single quotes`;
+  }
+}
+function text(value) {
+  if (typeof value === "string") return value.trim() || void 0;
+  if (typeof value === "number") return String(value);
+  return void 0;
+}
+function oneOf(values, value) {
+  return typeof value === "string" && values.includes(value) ? value : void 0;
+}
+var CHECKABLE_SOURCE = /^(?:https?:\/\/\S+|[a-z_]+:[\w-]+)$/i;
+function evidenceStatus(stated, source) {
+  if (stated !== "observed") return stated;
+  return CHECKABLE_SOURCE.test(source) ? "observed" : "interpreted";
+}
+function parseInsight(id, markdown) {
+  const fm = frontmatterOf(markdown);
+  const quote = text(fm?.quote);
+  const source = text(fm?.source);
+  if (!fm || !quote || !source) return null;
+  const force = text(fm.force);
+  const persona = text(fm.persona);
+  const sourceKind = text(fm.sourceKind);
+  const author = markdown.replace(/^---[\s\S]*?\n---/, "").match(/\bby ([\p{Lu}][\p{L}'’-]*\.?(?: [\p{Lu}][\p{L}'’-]*\.?)?)/u)?.[1]?.replace(new RegExp("(\\p{L}{2,})\\.$", "u"), "$1");
+  return {
+    id,
+    type: text(fm.type) ?? "other",
+    quote,
+    source,
+    status: evidenceStatus(oneOf(EVIDENCE_LEVELS, fm.status) ?? "observed", source),
+    ...sourceKind ? { sourceKind } : {},
+    ...force ? { force } : {},
+    ...persona ? { persona } : {},
+    ...author ? { author } : {}
+  };
+}
+function evidenceList(value) {
+  if (Array.isArray(value)) return value.flatMap((e) => text(e) ? [String(text(e))] : []);
+  const single = text(value);
+  return single ? [single] : [];
+}
+function fieldProblems(f) {
+  const problems = [];
+  if (!f.who) problems.push("who is missing: the persona it is for");
+  if (!f.message)
+    problems.push(
+      "message is missing: the one promise a stranger should get, what is offered and what changes for them"
+    );
+  if (!f.why) problems.push("why is missing: the brief finding it answers");
+  if (!f.awareness) {
+    const written = f.awarenessWritten ? `"${f.awarenessWritten}" ` : "";
+    problems.push(`awareness ${written}must be one of ${AWARENESS_STAGES.join(", ")}`);
+  }
+  if (!(f.angle && IDEA_ANGLES.includes(f.angle)))
+    problems.push(`angle ${f.angle ? `"${f.angle}" ` : ""}must be one of ${IDEA_ANGLES.join(", ")}`);
+  if (!(f.format && IDEA_FORMATS.includes(f.format)))
+    problems.push(`format ${f.format ? `"${f.format}" ` : ""}must be one of ${IDEA_FORMATS.join(", ")}`);
+  return problems;
+}
+function parseIdea(id, markdown) {
+  const unparsable = frontmatterError(markdown);
+  if (unparsable) return { problems: [unparsable] };
+  const fm = frontmatterOf(markdown) ?? {};
+  const f = {
+    who: text(fm.who),
+    message: text(fm.message),
+    why: text(fm.why),
+    angle: text(fm.angle),
+    format: text(fm.format),
+    awareness: oneOf(AWARENESS_STAGES, fm.awareness),
+    awarenessWritten: text(fm.awareness)
+  };
+  const problems = fieldProblems(f);
+  const { who, message, why, angle, format, awareness } = f;
+  if (problems.length > 0 || !who || !message || !why || !awareness || !angle || !format) return { problems };
+  return {
+    idea: {
+      id,
+      who,
+      message,
+      evidence: evidenceList(fm.evidence),
+      awareness,
+      angle,
+      format,
+      job: fm.job === "closer" ? "closer" : "opener",
+      why,
+      status: oneOf(IDEA_STATUSES, fm.status) ?? "idea"
+    },
+    problems
+  };
+}
+var EVIDENCE_WEIGHT = {
+  observed: 3,
+  interpreted: 2,
+  hypothesized: 1,
+  generated: 0,
+  explore: 0
+};
+var LIVE_STATUSES = ["built", "testing", "winner"];
+function claimsOf(message) {
+  return [...message.matchAll(/\d[\d.,]*\s?(?:%|€|\$|£|x\b|k\b)?/gi)].map((m) => m[0].trim());
+}
+function figureOf(claim) {
+  return claim.replace(/[^\d]/g, "");
+}
+function figuresIn(text2) {
+  return new Set([...text2.matchAll(/\d(?:[\d.,]*\d)?/g)].map((m) => figureOf(m[0])));
+}
+function normalize(value) {
+  return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function sentencesOf(message) {
+  return message.split(/[.!?]+(?:\s|$)/).filter((s) => s.trim().length > 0).length;
+}
+var SAME_WORDS = (a, b) => normalize(a) === normalize(b);
+function repeatedFailure(idea, failed, sameMessage) {
+  const lost = failed.find(
+    (f) => f.id !== idea.id && (sameMessage(f.message, idea.message) || f.angle === idea.angle && f.format === idea.format)
+  );
+  return lost ? [`says what "${lost.id}" said, and that idea failed in the account: change the message, not just the picture`] : [];
+}
+function likelyMeant(id, insights) {
+  const words = (text2) => new Set(
+    text2.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((w) => w.length >= 3)
+  );
+  const wanted = words(id);
+  let best;
+  for (const insight of insights.values()) {
+    const said = words(`${insight.id} ${insight.quote}`);
+    const shared = [...wanted].filter((w) => said.has(w)).length;
+    if (shared > 0 && shared > (best?.shared ?? 0)) best = { id: insight.id, shared };
+  }
+  return best?.id;
+}
+function backingOf(idea, insights, problems) {
+  const backing = idea.evidence.flatMap((id) => {
+    const insight = insights.get(id);
+    if (!insight) {
+      const meant = likelyMeant(id, insights);
+      problems.push(
+        `evidence "${id}" is not in src/content/insights/: ${meant ? `did you mean "${meant}"? ` : ""}name an insight on file by its id, or leave it out`
+      );
+    }
+    return insight ? [insight] : [];
+  });
+  return [...backing].sort((a, b) => EVIDENCE_WEIGHT[b.status] - EVIDENCE_WEIGHT[a.status])[0];
+}
+function unsourcedClaims(text2, corpusFigures) {
+  return claimsOf(text2).filter((claim) => {
+    const figure = figureOf(claim);
+    return figure !== "" && !corpusFigures.has(figure);
+  });
+}
+function claimProblems(message, corpusFigures) {
+  return unsourcedClaims(message, corpusFigures).map(
+    (claim) => `"${claim}" is in no customer quote, COMPANY.md or Knowledge entry: source it or drop it`
+  );
+}
+var MARKET_SOURCES = ["reddit", "forum", "web"];
+var TESTIMONIAL_FORMATS = ["review_screenshot", "testimonial_quote", "video_testimonial"];
+function fromMarket(insight) {
+  return insight?.sourceKind !== void 0 && MARKET_SOURCES.includes(insight.sourceKind);
+}
+function sourcesClaims(insight) {
+  return insight.status === "observed" && !fromMarket(insight);
+}
+function borrowedProof(idea, insights) {
+  return idea.evidence.find((id) => {
+    const insight = insights.get(id);
+    return fromMarket(insight) && insight?.type === "proof";
+  });
+}
+function fakeReviewProblem(idea, insights) {
+  if (!TESTIMONIAL_FORMATS.includes(idea.format)) return [];
+  const cited = idea.evidence.flatMap((id) => insights.get(id) ?? []);
+  if (cited.length === 0 || !cited.every(fromMarket)) return [];
+  return [
+    `${idea.format} needs a quote from our own customer (a review, testimonial, call or survey); every one cited was said by someone in the market. Pick another format, or cite our own customer`
+  ];
+}
+function warningsOf(idea, evidence, personas, insights) {
+  const warnings = [];
+  const borrowed = borrowedProof(idea, insights);
+  if (borrowed) {
+    warnings.push(
+      `"${borrowed}" was said by someone in the market, not a customer of ours: use their words for the problem, never show it as our review, testimonial or result`
+    );
+  }
+  if (sentencesOf(idea.message) > 1 || idea.message.split(/\s+/).length > 25) {
+    warnings.push(
+      'the message says more than one thing: keep one promise that still names what is offered ("a free roof survey that shows your real saving", never a slogan like "the numbers, explained"), the rest goes to the ad text'
+    );
+  }
+  if (personas.length > 0 && !personas.includes(idea.who)) {
+    warnings.push(`who "${idea.who}" is not a persona in the Knowledge (${personas.join(", ")})`);
+  }
+  if (evidence === "explore") {
+    warnings.push("no customer evidence: an explore bet. `baker research customers` may find some");
+  }
+  return warnings;
+}
+function checkOne(idea, ctx) {
+  const problems = [];
+  const best = backingOf(idea, ctx.insights, problems);
+  const evidence = best?.status ?? "explore";
+  problems.push(...claimProblems(idea.message, ctx.corpusFigures), ...fakeReviewProblem(idea, ctx.insights));
+  const duplicate = ctx.duplicateOf.get(idea.id);
+  if (duplicate) {
+    problems.push(
+      `same angle and format, or the same message, as "${duplicate}": to the platform it is the same ad. Change the angle or the format`
+    );
+  }
+  const gaps = [];
+  if (!ctx.covered.has(idea.awareness)) gaps.push(`no live ad speaks to ${idea.awareness} people`);
+  if (idea.job === "closer" && ctx.closersLive === 0) gaps.push("no live ad closes warm people");
+  return {
+    id: idea.id,
+    status: idea.status,
+    message: idea.message,
+    evidence,
+    ...best ? { quote: best.quote } : {},
+    awareness: idea.awareness,
+    angle: idea.angle,
+    format: idea.format,
+    problems,
+    warnings: [
+      ...warningsOf(idea, evidence, ctx.personas, ctx.insights),
+      ...repeatedFailure(idea, ctx.failed, ctx.sameMessage)
+    ],
+    gaps,
+    score: EVIDENCE_WEIGHT[evidence] + gaps.length - (problems.length > 0 ? 10 : 0)
+  };
+}
+function duplicatesOf(ideas, insights) {
+  const active = ideas.filter((i) => i.status !== "retired" && i.status !== "failed");
+  const strength = (idea) => Math.max(0, ...idea.evidence.map((id) => EVIDENCE_WEIGHT[insights.get(id)?.status ?? "explore"]));
+  const position = new Map(ideas.map((idea, index) => [idea.id, index]));
+  const order = [...active].sort(
+    (a, b) => Number(LIVE_STATUSES.includes(b.status)) - Number(LIVE_STATUSES.includes(a.status)) || strength(b) - strength(a) || (position.get(a.id) ?? 0) - (position.get(b.id) ?? 0)
+  );
+  const seenPairs = /* @__PURE__ */ new Map();
+  const seenMessages = /* @__PURE__ */ new Map();
+  const duplicateOf = /* @__PURE__ */ new Map();
+  for (const idea of order) {
+    const pair = `${idea.angle}\xD7${idea.format}`;
+    const message = normalize(idea.message);
+    const earlier = seenPairs.get(pair) ?? seenMessages.get(message);
+    if (earlier) duplicateOf.set(idea.id, earlier);
+    if (!seenPairs.has(pair)) seenPairs.set(pair, idea.id);
+    if (!seenMessages.has(message)) seenMessages.set(message, idea.id);
+  }
+  return duplicateOf;
+}
+function checkIdeas(input) {
+  const insights = new Map(input.insights.map((insight) => [insight.id, insight]));
+  const ownQuotes = input.insights.filter(sourcesClaims).map((i) => i.quote);
+  const corpusFigures = figuresIn(`${input.knowledge}
+${ownQuotes.join("\n")}`);
+  const covered = new Set(input.coveredAwareness);
+  const duplicateOf = duplicatesOf(input.ideas, insights);
+  const checks = input.ideas.map(
+    (idea) => checkOne(idea, {
+      insights,
+      corpusFigures,
+      covered,
+      duplicateOf,
+      personas: input.personas,
+      closersLive: input.closersLive,
+      failed: input.ideas.filter((i) => i.status === "failed"),
+      sameMessage: input.sameMessage ?? SAME_WORDS
+    })
+  );
+  const toBuild = (c) => c.status === "idea";
+  return checks.sort(
+    (a, b) => Number(toBuild(b)) - Number(toBuild(a)) || b.score - a.score || a.id.localeCompare(b.id)
+  );
+}
+
+// src/commands/creatives/ideas-judgments.ts
+var STATISTIC_QUESTION = `\`quote\` was filed as something a customer said. Is it instead a statistic about a group of people, a share or a figure from a survey, a study or an article ("39% of UK homeowners say\u2026", "a quarter of buyers\u2026", "1 in 3 owners\u2026"), rather than one person's own words about their own experience? A person giving their own number ("My bill dropped 40%") is their own words. The quote may be in any language.`;
+var STATISTIC_HELD = 0.65;
+var SAME_MESSAGE_QUESTION = `\`a\` and \`b\` are the messages of two ads. Do they make the same core promise to the viewer (the same benefit, the same reason to act), even when one adds a detail or a few words, says it in other words, or is in another language? Two messages that promise different things about the same product are not the same.`;
+var SAME_MESSAGE_HELD = 0.42;
+async function withStatisticsRead(insights, ask) {
+  const observed = insights.filter((i) => i.status === "observed");
+  if (observed.length === 0) return [...insights];
+  const answers = await ask(observed.map((i) => ({ instructions: { quote: i.quote, question: STATISTIC_QUESTION } })));
+  if (answers === null) return [...insights];
+  const statistics = new Set(observed.filter((_, i) => (answers[i] ?? 0) >= STATISTIC_HELD).map((i) => i.id));
+  return insights.map((i) => statistics.has(i.id) ? { ...i, status: "interpreted" } : i);
+}
+async function sameMessageRead(ideas, ask) {
+  const failed = ideas.filter((i) => i.status === "failed");
+  const pairs = failed.flatMap(
+    (f) => ideas.filter((i) => i.id !== f.id && !SAME_WORDS(i.message, f.message)).map((i) => [f.message, i.message])
+  );
+  if (pairs.length === 0) return SAME_WORDS;
+  const answers = await ask(pairs.map(([a, b]) => ({ instructions: { a, b, question: SAME_MESSAGE_QUESTION } })));
+  if (answers === null) return SAME_WORDS;
+  const same = new Set(
+    pairs.filter((_, i) => (answers[i] ?? 0) >= SAME_MESSAGE_HELD).map(([a, b]) => `${a}\0${b}`)
+  );
+  return (a, b) => SAME_WORDS(a, b) || same.has(`${a}\0${b}`) || same.has(`${b}\0${a}`);
+}
+
+// src/commands/creatives/ideas-workspace.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+var IDEAS_DIR = path.join("src", "creatives", "_ideas");
+var INSIGHTS_DIR = path.join("src", "content", "insights");
+async function markdownFiles(dir, recursive = false) {
+  const entries = await readdir(dir, { recursive }).catch(() => []);
+  return entries.filter((f) => f.endsWith(".md")).sort();
+}
+var idOf = (file) => file.replace(/\\/g, "/").replace(/\.md$/, "");
+function workspaceIdeasJudge(root) {
+  const cacheDir = path.join(root, "canvas", ".cache");
+  const spent = [];
+  return {
+    ask: rememberedJev(path.join(cacheDir, "ideas-answers.json"), (u) => spent.push(u)),
+    done: () => holdUnbilledSpend(cacheDir, spent.splice(0)).catch(() => void 0)
+  };
+}
+async function readInsights(root, opts = {}) {
+  const dir = path.join(root, INSIGHTS_DIR);
+  const insights = [];
+  for (const file of await markdownFiles(dir, true)) {
+    const insight = parseInsight(idOf(file), await readFile(path.join(dir, file), "utf8").catch(() => ""));
+    if (insight) insights.push(insight);
+  }
+  if (opts.ask) return withStatisticsRead(insights, opts.ask);
+  const judge = workspaceIdeasJudge(root);
+  const read = await withStatisticsRead(insights, judge.ask);
+  await judge.done();
+  return read;
+}
+async function readIdeas(root) {
+  const dir = path.join(root, IDEAS_DIR);
+  const ideas = [];
+  const unreadable = [];
+  for (const file of await markdownFiles(dir)) {
+    const id = idOf(file);
+    const parsed = parseIdea(id, await readFile(path.join(dir, file), "utf8").catch(() => ""));
+    if (parsed.idea) ideas.push(parsed.idea);
+    else unreadable.push({ id, problems: parsed.problems });
+  }
+  return { ideas, unreadable };
+}
+async function readPersonaIds(root) {
+  return (await markdownFiles(path.join(root, "src", "content", "personas"), true)).map(idOf);
+}
+var MAX_KNOWLEDGE_CHARS = 2e5;
+async function readKnowledgeCorpus(root) {
+  const parts = [];
+  const company = await readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => "");
+  if (company) parts.push(company);
+  const content = path.join(root, "src", "content");
+  const insights = path.relative(content, path.join(root, INSIGHTS_DIR));
+  const files = (await markdownFiles(content, true)).filter((f) => !f.replace(/\\/g, "/").startsWith(`${insights}/`));
+  for (const file of files) {
+    parts.push(await readFile(path.join(content, file), "utf8").catch(() => ""));
+    if (parts.join("").length > MAX_KNOWLEDGE_CHARS) break;
+  }
+  return parts.join("\n").slice(0, MAX_KNOWLEDGE_CHARS);
+}
+async function readCreativeRecords(root) {
+  const dir = path.join(root, "src", "creatives");
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith("_")) continue;
+    const raw = await readFile(path.join(dir, entry.name, "_definition.md"), "utf8").catch(() => null);
+    if (raw === null) continue;
+    const fm = frontmatterOf(raw) ?? {};
+    const pick = (key) => typeof fm[key] === "string" && fm[key] ? { [key]: fm[key] } : {};
+    records.push({
+      slug: entry.name,
+      ...pick("status"),
+      ...pick("idea"),
+      ...pick("awareness"),
+      ...pick("angle"),
+      ...pick("kind")
+    });
+  }
+  return records;
+}
+var SHOWN_STATUSES = /* @__PURE__ */ new Set(["rendered", "published"]);
+function coverageOf(ideas, creatives) {
+  const live = ideas.filter((i) => i.status === "built" || i.status === "testing" || i.status === "winner");
+  const awareness = new Set(live.map((i) => i.awareness));
+  for (const creative of creatives) {
+    if (creative.awareness && SHOWN_STATUSES.has(creative.status ?? "")) awareness.add(creative.awareness);
+  }
+  return { coveredAwareness: [...awareness].sort(), closersLive: live.filter((i) => i.job === "closer").length };
+}
+
+export {
+  IDEA_ANGLES,
+  IDEA_VIDEO_FORMATS,
+  IDEA_FORMATS,
+  AWARENESS_STAGES,
+  figuresIn,
+  unsourcedClaims,
+  sourcesClaims,
+  checkIdeas,
+  sameMessageRead,
+  IDEAS_DIR,
+  workspaceIdeasJudge,
+  readInsights,
+  readIdeas,
+  readPersonaIds,
+  readKnowledgeCorpus,
+  readCreativeRecords,
+  coverageOf
+};
+//# sourceMappingURL=chunk-4QEY2L6U.js.map