@mirage-cli/contentdynamite-cli 0.0.0-stage → 1.0.0

package/dist/index-b00ea6js.js

@@ -0,0 +1,2158 @@
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/program.ts
+import { Command, CommanderError as CommanderError2, Option as Option4 } from "commander";
+
+// src/files.ts
+import { readFileSync, writeFileSync } from "node:fs";
+function bridgeFor(path) {
+  const bridge = globalThis.__MIRAGE_CLI_FILE_IO__;
+  return bridge?.canHandle(path) ? bridge : null;
+}
+function read(path) {
+  const bridge = bridgeFor(path);
+  if (!bridge)
+    return new Uint8Array(readFileSync(path));
+  const data = bridge.readFileSync(path);
+  if (data === null)
+    throw Object.assign(new Error(`ENOENT: ${path}`), { code: "ENOENT" });
+  return new Uint8Array(typeof data === "string" ? new TextEncoder().encode(data) : data);
+}
+function readBytes(path) {
+  try {
+    return read(path);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      throw new Error(`file not found: ${path}`);
+    throw error;
+  }
+}
+var readText = (path) => new TextDecoder().decode(readBytes(path));
+function writeFile(path, data) {
+  const bridge = bridgeFor(path);
+  if (!bridge) {
+    writeFileSync(path, data);
+    return;
+  }
+  if (!bridge.writeFileSync(path, data))
+    throw new Error(`could not write ${path}`);
+}
+
+// src/helpers.ts
+import { basename } from "node:path";
+import { CommanderError, InvalidArgumentError } from "commander";
+
+// src/output.ts
+var io = {
+  stdout: (text) => void process.stdout.write(text),
+  stderr: (text) => void process.stderr.write(text)
+};
+function out(data) {
+  io.stdout(`${JSON.stringify(data, null, 2)}
+`);
+}
+function err(message) {
+  io.stderr(`${message}
+`);
+}
+function line(message) {
+  io.stdout(`${message}
+`);
+}
+function write(text) {
+  io.stdout(text.endsWith(`
+`) || text === "" ? text : `${text}
+`);
+}
+var isoNow = () => new Date().toISOString();
+var isoFromMs = (ms) => new Date(ms).toISOString();
+
+// src/wire.js
+import { z as z4 } from "zod";
+import { z as z2 } from "zod";
+import { z } from "zod";
+import { z as z3 } from "zod";
+var USER_ROLES = ["admin", "normal"];
+var ARTICLE_STATUSES = ["pending", "success", "failed"];
+var ARTICLE_TYPES = ["listicle"];
+var INTERACTIVE_TYPES = ["quiz", "game", "calculator", "chart"];
+var GBP_POST_STATUSES = ["pending", "done", "failed"];
+var GBP_IMAGE_MODES = ["none", "supplied", "article", "generate"];
+var GBP_POST_SOURCES = ["article", "topic"];
+var LANDING_DELIVERABLES = ["copy", "page"];
+var LANDING_PAGE_STATUSES = ["pending", "success", "failed"];
+var REVISION_PARTS = ["intro", "section", "image", "feat_image", "faq", "video", "interactive"];
+var REVISION_STATUSES = ["pending", "ready", "failed"];
+var REVISION_VERDICTS = ["better", "same", "worse"];
+var REVISION_TARGETS = ["section", "heading", "passage", "question", "answer"];
+var ICP_SECTIONS = [
+  "business_overview",
+  "customer_profile",
+  "channel_analysis",
+  "pain_points",
+  "intent_funnel",
+  "competitive_landscape"
+];
+var WORD = "\\p{L}\\p{N}_";
+var PY_SPACE = "\\t\\n\\v\\f\\r\\u001c-\\u001f \\u0085\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000";
+var BOUNDARY = `(?:(?<=[${WORD}])(?![${WORD}])|(?<![${WORD}])(?=[${WORD}]))`;
+var NOT_BOUNDARY = `(?:(?<=[${WORD}])(?=[${WORD}])|(?<![${WORD}])(?![${WORD}]))`;
+var SYNTAX = new Set(["^", "$", "\\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", "|", "/"]);
+var PY_SPACE_RUN_RE = new RegExp(`[${PY_SPACE}]+`, "u");
+var PY_STRIP_RE = new RegExp(`^[${PY_SPACE}]+|[${PY_SPACE}]+$`, "g");
+var pyStrip = (text) => text.replace(PY_STRIP_RE, "");
+var PY_SPACE_RUNS_RE = new RegExp(`[${PY_SPACE}]+`, "gu");
+function wireLandingStatus(status) {
+  if (status === null || status === undefined)
+    return;
+  let value = status.toLowerCase();
+  if (value === "sucess")
+    value = "success";
+  if (!LANDING_PAGE_STATUSES.includes(value))
+    throw new Error(`invalid status '${status}', valid values: ${LANDING_PAGE_STATUSES.join(", ")}`);
+  return value;
+}
+function wireDeliverable(deliverable) {
+  const value = pyStrip(deliverable.toLowerCase());
+  if (!LANDING_DELIVERABLES.includes(value))
+    throw new Error(`invalid deliverable '${deliverable}', valid values: ${LANDING_DELIVERABLES.join(", ")}`);
+  return value;
+}
+var TAG_BY_TYPE = {
+  quiz: "cg-quiz",
+  game: "cg-game",
+  calculator: "cg-calculator",
+  chart: "cg-chart"
+};
+var EMBED_RE = new RegExp(String.raw`[ \t]*(?:<script\s+src="[^"]*"\s+defer\s*>\s*</script>\s*)?<(${Object.values(TAG_BY_TYPE).join("|")})\b[^>]*>[\s\S]*?</\1>[ \t]*`, "gi");
+var exportQuery = z.object({ format: z.enum(["docx", "md"]).default("docx") });
+var PYTHON_TRUTHY = ["1", "on", "t", "true", "y", "yes"];
+var PYTHON_FALSY = ["0", "off", "f", "false", "n", "no"];
+var queryBool = z.stringbool({ truthy: PYTHON_TRUTHY, falsy: PYTHON_FALSY, error: "Input should be a valid boolean, unable to interpret input" });
+function valueErrors(checks) {
+  return (_, context) => {
+    const failure = checks().find(([failed]) => failed);
+    if (failure)
+      context.addIssue({ code: "custom", message: `Value error, ${failure[1]}` });
+  };
+}
+var blank = (value) => value != null && !value.trim();
+var optionalText = z2.string().nullable().optional();
+var CLEARABLE_FIELDS = ["intro", "body", "faqs", "feat_image"];
+var articleParam = z2.object({ article_id: z2.coerce.number().int() });
+var batchParam = z2.object({ batch_id: z2.coerce.number().int() });
+var articlesQuery = z2.object({
+  page: z2.coerce.number().int().min(1).default(1),
+  limit: z2.coerce.number().int().min(1).max(100).default(10),
+  company_name: z2.string().optional(),
+  status: z2.enum(ARTICLE_STATUSES).optional(),
+  batch_id: z2.coerce.number().int().optional()
+});
+var listicleResearchQuery = z2.object({
+  profile_id: z2.coerce.number().int(),
+  keyword: z2.string(),
+  title: z2.string().optional(),
+  location: z2.string().optional(),
+  item_count: z2.coerce.number().int().optional()
+});
+var updateArticleDto = z2.object({
+  title: optionalText,
+  slug: optionalText,
+  intro: optionalText,
+  body: optionalText,
+  faqs: optionalText,
+  feat_image: optionalText
+}).superRefine((dto, context) => valueErrors(() => [
+  [dto.title === null || blank(dto.title), "title must not be empty if provided"],
+  [dto.slug === null || blank(dto.slug), "slug must not be empty if provided"],
+  ...CLEARABLE_FIELDS.map((field) => [blank(dto[field]), `${field} must not be empty if provided`])
+])(dto, context));
+var optionalList = z2.array(z2.string()).nullable().default(null);
+var articleJobItem = z2.object({
+  company_profile_id: z2.number().int(),
+  search_query: z2.string(),
+  primary_keywords: z2.string(),
+  secondary_keywords: z2.string().nullable().default(null),
+  location_to_rank_for: z2.string().nullable().default(null),
+  extra_guidelines: z2.string().nullable().default(null),
+  image_guideline: z2.string().nullable().default(null),
+  internal_links: optionalList,
+  external_links: optionalList,
+  competitor_links: optionalList,
+  infographic_feat_image: z2.boolean().default(false),
+  generate_video: z2.boolean().default(false),
+  generate_interactive: z2.boolean().default(false),
+  interactive_type: z2.enum(INTERACTIVE_TYPES).nullable().default(null),
+  gbp_post: z2.boolean().default(false),
+  dewatermark: z2.boolean().nullable().default(null),
+  article_type: z2.enum(ARTICLE_TYPES).nullable().default(null),
+  listicle_research: z2.string().nullable().default(null),
+  item_count: z2.number().int().nullable().default(null),
+  brand_facts: z2.string().nullable().default(null),
+  allowed_competitors: optionalList,
+  table_sources: z2.record(z2.string(), z2.string()).nullable().default(null)
+});
+var cleanList = (values) => values.filter((value) => value && value.trim()).map((value) => value.trim());
+var isHttpUrl = (url) => /^https?:\/\//.test(url.toLowerCase());
+var blankToNull = (value) => value !== null && !value.trim() ? null : value;
+function cleanTableSources(sources) {
+  const pairs = [];
+  const seen = new Map;
+  for (const [rawName, rawUrl] of Object.entries(sources)) {
+    const name = (rawName ?? "").trim();
+    const url = (rawUrl ?? "").trim();
+    if (!name || !url)
+      return `table_sources: '${name || url}' needs both an option name and a URL`;
+    if (!isHttpUrl(url))
+      return `table_sources: '${url}' is not an http(s) URL`;
+    const key = name.toLowerCase();
+    if (seen.has(key))
+      return `table_sources: '${name}' and '${seen.get(key)}' name the same option`;
+    seen.set(key, name);
+    pairs.push([name, url]);
+  }
+  if (pairs.length > 10)
+    return "table_sources: maximum 10 entries allowed";
+  return pairs.length > 0 ? Object.fromEntries(pairs) : null;
+}
+function normaliseJobItem(item) {
+  const out2 = { ...item, extra_guidelines: blankToNull(item.extra_guidelines), image_guideline: blankToNull(item.image_guideline) };
+  if (out2.internal_links !== null) {
+    const cleaned = cleanList(out2.internal_links);
+    out2.internal_links = cleaned.length > 0 ? cleaned : null;
+  }
+  if (out2.external_links !== null) {
+    const cleaned = cleanList(out2.external_links);
+    if (cleaned.length > 5)
+      return "external_links: maximum 5 URLs allowed";
+    const invalid = cleaned.find((url) => !isHttpUrl(url));
+    if (invalid !== undefined)
+      return `external_links: '${invalid}' is not an http(s) URL`;
+    out2.external_links = cleaned.length > 0 ? cleaned : null;
+  }
+  if (out2.competitor_links !== null) {
+    const cleaned = cleanList(out2.competitor_links);
+    if (cleaned.length > 3)
+      return "competitor_links: maximum 3 URLs allowed";
+    out2.competitor_links = cleaned.length > 0 ? cleaned : null;
+  }
+  out2.listicle_research = blankToNull(out2.listicle_research);
+  if (out2.article_type === "listicle" && !out2.listicle_research)
+    return "listicle_research is required when article_type is 'listicle'";
+  if (out2.item_count !== null && !(out2.item_count >= 3 && out2.item_count <= 10))
+    return "item_count must be between 3 and 10";
+  out2.brand_facts = blankToNull(out2.brand_facts);
+  if (out2.allowed_competitors !== null) {
+    const cleaned = cleanList(out2.allowed_competitors);
+    if (cleaned.length > 12)
+      return "allowed_competitors: maximum 12 names allowed";
+    out2.allowed_competitors = cleaned.length > 0 ? cleaned : null;
+  }
+  if (out2.table_sources !== null) {
+    const sources = cleanTableSources(out2.table_sources);
+    if (typeof sources === "string")
+      return sources;
+    out2.table_sources = sources;
+  }
+  return out2;
+}
+var articleDto = articleJobItem.transform((item, context) => {
+  const normalised = normaliseJobItem(item);
+  if (typeof normalised !== "string")
+    return normalised;
+  context.addIssue({ code: "custom", message: `Value error, ${normalised}` });
+  return z2.NEVER;
+});
+var batchWriteQuery = z2.object({
+  batch_name: z2.string(),
+  extra_guidelines: z2.string().optional(),
+  image_guideline: z2.string().optional(),
+  infographic_feat_image: queryBool.default(false),
+  generate_video: queryBool.default(false),
+  generate_interactive: queryBool.default(false),
+  interactive_type: z2.enum(INTERACTIVE_TYPES).optional(),
+  gbp_post: queryBool.default(false),
+  dewatermark: queryBool.optional(),
+  article_type: z2.enum(ARTICLE_TYPES).optional()
+});
+var batchFileForm = z2.object({ file: z2.file() });
+var editFeatImageDto = z2.object({ image_url: z2.string(), instruction: z2.string() }).superRefine((dto, context) => valueErrors(() => [
+  [!dto.image_url.trim(), "image_url must not be empty"],
+  [!dto.instruction.trim(), "instruction must not be empty"]
+])(dto, context));
+var commitFeatImageDto = z2.object({ image_url: z2.string() }).superRefine((dto, context) => valueErrors(() => [[!dto.image_url.trim(), "image_url must not be empty"]])(dto, context));
+var editJobParam = z2.object({ article_id: z2.coerce.number().int(), job_id: z2.string() });
+var exportToDocsQuery = z2.object({ replace: queryBool.default(false) });
+var auditPage = {
+  page: z2.coerce.number().int().min(1).default(1),
+  limit: z2.coerce.number().int().min(1).max(200).default(50)
+};
+var auditQuery = z2.object(auditPage);
+var qaAuditQuery = z2.object({ ...auditPage, company_name: z2.string().optional(), images: queryBool.default(true) });
+var articleQaQuery = z2.object({ model_checks: queryBool.default(false), store: queryBool.default(true) });
+var cleanProvenanceQuery = z2.object({ rewrite: queryBool.default(false) });
+var stripEmbedsBody = z2.array(z2.number().int()).nullable();
+var optionalText2 = z3.string().nullable().default(null);
+var gbpPostJobItem = z3.object({
+  company_profile_id: z3.number().int(),
+  topic: optionalText2,
+  article_id: z3.number().int().nullable().default(null),
+  location: optionalText2,
+  facts: optionalText2,
+  guidelines: optionalText2,
+  image_mode: z3.enum(GBP_IMAGE_MODES).nullable().default(null),
+  image_url: optionalText2,
+  image_guideline: optionalText2,
+  regenerate: z3.boolean().default(false)
+});
+var TEXT_FIELDS = ["topic", "location", "facts", "guidelines", "image_url", "image_guideline"];
+var isHttpUrl2 = (url) => /^https?:\/\//.test(url.toLowerCase());
+function normaliseGbpJob(item) {
+  const out2 = { ...item };
+  for (const field of TEXT_FIELDS) {
+    const value = out2[field];
+    if (value !== null)
+      out2[field] = value.trim() || null;
+  }
+  if (!out2.topic && out2.article_id === null)
+    return "a post needs either a topic or an article_id to repurpose";
+  const mode = out2.image_mode ?? (out2.image_url ? "supplied" : out2.article_id !== null ? "article" : "generate");
+  if (mode === "supplied" && !out2.image_url)
+    return "image_mode 'supplied' needs an image_url";
+  if (mode === "article" && out2.article_id === null)
+    return "image_mode 'article' needs an article_id to take the image from";
+  if (out2.image_url && !isHttpUrl2(out2.image_url))
+    return `image_url: '${out2.image_url}' is not an http(s) URL`;
+  if (out2.image_guideline && mode !== "generate")
+    return "image_guideline only applies when image_mode is 'generate'";
+  return { ...out2, image_mode: mode };
+}
+var gbpPostDto = gbpPostJobItem.transform((item, context) => {
+  const normalised = normaliseGbpJob(item);
+  if (typeof normalised !== "string")
+    return normalised;
+  context.addIssue({ code: "custom", message: `Value error, ${normalised}` });
+  return z3.NEVER;
+});
+var updateGbpPostDto = z3.object({
+  content: z3.string().nullable().optional(),
+  image_url: z3.string().nullable().optional(),
+  topic: z3.string().nullable().optional(),
+  status: z3.enum(GBP_POST_STATUSES).nullable().optional()
+}).transform((dto, context) => {
+  if (dto.content != null && !dto.content.trim())
+    context.addIssue({ code: "custom", message: "Value error, content must not be empty if provided" });
+  else if (dto.topic != null && !dto.topic.trim())
+    context.addIssue({ code: "custom", message: "Value error, topic must not be empty if provided" });
+  else if (dto.image_url != null && dto.image_url.trim() && !isHttpUrl2(dto.image_url.trim())) {
+    context.addIssue({ code: "custom", message: `Value error, image_url: '${dto.image_url.trim()}' is not an http(s) URL` });
+  } else {
+    const out2 = {};
+    if (dto.content != null)
+      out2.content = dto.content;
+    if (dto.status != null)
+      out2.status = dto.status;
+    if (dto.topic !== undefined)
+      out2.topic = dto.topic;
+    if (dto.image_url !== undefined)
+      out2.image_url = dto.image_url?.trim() || null;
+    return out2;
+  }
+  return z3.NEVER;
+});
+var gbpPostParam = z3.object({ post_id: z3.coerce.number().int() });
+var gbpPostsQuery = z3.object({
+  page: z3.coerce.number().int().min(1).default(1),
+  limit: z3.coerce.number().int().min(1).max(100).default(10),
+  company_name: z3.string().optional(),
+  status: z3.enum(GBP_POST_STATUSES).optional(),
+  source: z3.enum(GBP_POST_SOURCES).optional()
+});
+var legacyGbpPostsQuery = gbpPostsQuery.pick({ page: true, limit: true, status: true });
+var batchGbpQuery = z3.object({
+  location: z3.string().optional(),
+  facts: z3.string().optional(),
+  guidelines: z3.string().optional(),
+  image_mode: z3.enum(GBP_IMAGE_MODES).optional(),
+  image_guideline: z3.string().optional()
+});
+var imageOptionsQuery = z3.object({ company_profile_id: z3.coerce.number().int() });
+var STATUS_ALIASES = { pending: "pending", success: "success", sucess: "success", failed: "failed" };
+var BATCH_WIDE_ONLY_FIELDS = ["extra_guidelines", "image_guideline"];
+function withoutDefaults(shape) {
+  return Object.fromEntries(Object.entries(shape).map(([key, field]) => [key, field instanceof z4.ZodDefault ? field.unwrap().optional() : field]));
+}
+var batchArticleJob = z4.object(withoutDefaults(articleJobItem.shape));
+var batchGbpJob = z4.object(withoutDefaults(gbpPostJobItem.shape));
+function wireStatus(status) {
+  if (status == null)
+    return;
+  const mapped = STATUS_ALIASES[status.toLowerCase()];
+  if (!mapped)
+    throw new Error(`invalid status '${status}', valid values: ${ARTICLE_STATUSES.join(", ")}`);
+  return mapped;
+}
+function wireGbpStatus(status) {
+  if (status == null)
+    return;
+  const value = status.toLowerCase() === "success" ? "done" : status.toLowerCase();
+  if (!GBP_POST_STATUSES.includes(value))
+    throw new Error(`invalid status '${status}', valid values: ${GBP_POST_STATUSES.join(", ")}`);
+  return value;
+}
+function wireGbpSource(source) {
+  if (source == null)
+    return;
+  const value = source.toLowerCase();
+  if (!GBP_POST_SOURCES.includes(value))
+    throw new Error(`invalid source '${source}', valid values: ${GBP_POST_SOURCES.join(", ")}`);
+  return value;
+}
+function cell(value) {
+  if (value == null)
+    return "";
+  if (Array.isArray(value))
+    return value.join("|");
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "object")
+    return Object.entries(value).map(([name, url]) => `${name}=${url}`).join("|");
+  return String(value);
+}
+function quote(value) {
+  return /[",\r\n]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
+}
+function toCsv(jobs, required, optional) {
+  const columns = [...required, ...optional.filter((field) => jobs.some((job) => job[field] != null))];
+  const lines = [columns, ...jobs.map((job) => columns.map((column) => cell(job[column])))];
+  return lines.map((line2) => line2.map(quote).join(",") + `
+`).join("");
+}
+var ARTICLE_REQUIRED = ["company_profile_id", "search_query", "primary_keywords"];
+var GBP_REQUIRED = ["company_profile_id"];
+function articleJobsToCsv(jobs, guidelineHint) {
+  jobs.forEach((job, index) => {
+    if (BATCH_WIDE_ONLY_FIELDS.some((field) => job[field]))
+      throw new Error(`job ${index}: per job guidelines are not supported by the API, use ${guidelineHint}`);
+  });
+  const optional = Object.keys(articleJobItem.shape).filter((field) => !ARTICLE_REQUIRED.includes(field) && !BATCH_WIDE_ONLY_FIELDS.includes(field));
+  return new File([toCsv(jobs, ARTICLE_REQUIRED, optional)], "jobs.csv", { type: "text/csv" });
+}
+function gbpJobsToCsv(jobs) {
+  const optional = Object.keys(gbpPostJobItem.shape).filter((field) => !GBP_REQUIRED.includes(field));
+  return new File([toCsv(jobs, GBP_REQUIRED, optional)], "posts.csv", { type: "text/csv" });
+}
+var EOL = null;
+function parseCsv(text) {
+  const records = [];
+  let fields = [];
+  let field = "";
+  let state = "start_record";
+  const saveField = () => {
+    fields.push(field);
+    field = "";
+  };
+  const endRecord = () => {
+    records.push(fields);
+    fields = [];
+    state = "start_record";
+  };
+  const endOfLine = (character) => {
+    saveField();
+    state = character === EOL ? "start_record" : "eat_crnl";
+  };
+  const process2 = (character) => {
+    switch (state) {
+      case "eat_crnl":
+        if (character === `
+` || character === "\r")
+          return;
+        if (character === EOL) {
+          state = "start_record";
+          return;
+        }
+        endRecord();
+        process2(character);
+        return;
+      case "start_record":
+        if (character === EOL)
+          return;
+        if (character === `
+` || character === "\r") {
+          state = "eat_crnl";
+          return;
+        }
+        state = "start_field";
+        process2(character);
+        return;
+      case "start_field":
+        if (character === `
+` || character === "\r" || character === EOL)
+          endOfLine(character);
+        else if (character === '"')
+          state = "in_quoted_field";
+        else if (character === ",")
+          saveField();
+        else {
+          field += character;
+          state = "in_field";
+        }
+        return;
+      case "in_field":
+        if (character === `
+` || character === "\r" || character === EOL)
+          endOfLine(character);
+        else if (character === ",") {
+          saveField();
+          state = "start_field";
+        } else
+          field += character;
+        return;
+      case "in_quoted_field":
+        if (character === EOL)
+          return;
+        if (character === '"')
+          state = "quote_in_quoted_field";
+        else
+          field += character;
+        return;
+      case "quote_in_quoted_field":
+        if (character === '"') {
+          field += character;
+          state = "in_quoted_field";
+        } else if (character === ",") {
+          saveField();
+          state = "start_field";
+        } else if (character === `
+` || character === "\r" || character === EOL)
+          endOfLine(character);
+        else {
+          field += character;
+          state = "in_field";
+        }
+        return;
+    }
+  };
+  for (const line2 of text.match(/[^\n]*\n|[^\n]+$/g) ?? []) {
+    for (const character of line2)
+      process2(character);
+    process2(EOL);
+    if (state === "start_record")
+      endRecord();
+  }
+  if (field || state === "in_quoted_field") {
+    saveField();
+    endRecord();
+  }
+  return records;
+}
+function readCsvTable(text) {
+  const [header, ...records] = parseCsv(text);
+  if (header === undefined)
+    return { fieldnames: null, rows: [] };
+  const rows = records.filter((record) => record.length > 0).map((record) => {
+    const row = new Map;
+    header.forEach((name, index) => row.set(name, record[index] ?? ""));
+    return row;
+  });
+  return { fieldnames: header, rows };
+}
+
+// src/helpers.ts
+class Exit extends CommanderError {
+  constructor(code) {
+    super(code, "commander.exit", "");
+  }
+}
+var clock = {
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  now: () => performance.now()
+};
+var fmtNum = (value) => String(value);
+var splitCsv = (value) => value.split(",").map((part) => part.trim()).filter(Boolean);
+function integer(value) {
+  if (!/^[+-]?\d+$/.test(value.trim()))
+    throw new InvalidArgumentError("Not a valid integer.");
+  return Number.parseInt(value, 10);
+}
+function decimal(value) {
+  const parsed = Number(value);
+  if (!value.trim() || !Number.isFinite(parsed))
+    throw new InvalidArgumentError("Not a valid number.");
+  return parsed;
+}
+function between(low, high) {
+  return (value) => {
+    const parsed = decimal(value);
+    if (parsed < low || parsed > high)
+      throw new InvalidArgumentError(`Must be between ${low} and ${high}.`);
+    return parsed;
+  };
+}
+function either(value, file, flags) {
+  if (value && file)
+    throw new Error(`pass either ${flags}, not both`);
+  return file ? readText(file) : value;
+}
+function documentOutput(command, cli) {
+  if (cli.mount)
+    return command.requiredOption("-o, --output <path>", "Where to write it: a path the host shares with you, such as /data/report.docx");
+  return command.option("-o, --output <path>", "Where to write it, defaults to the server's filename in the current directory");
+}
+async function downloadDocument(cli, path, format, output, fallback) {
+  if (format !== "docx" && format !== "md")
+    throw new Error("--format must be docx or md");
+  const { content, filename } = await cli.client().getDownload(path, { format });
+  const target = output ?? (filename ? basename(filename) : `${fallback}.${format}`);
+  writeFile(target, content);
+  return target;
+}
+function interactiveFields(value) {
+  if (value === undefined)
+    return {};
+  if (value === true || value === "")
+    return { generate_interactive: true };
+  if (!INTERACTIVE_TYPES.includes(value)) {
+    throw new Error(`invalid interactive type '${value}', valid values: ${INTERACTIVE_TYPES.join(", ")}`);
+  }
+  return { generate_interactive: true, interactive_type: value };
+}
+async function watchLoop({ interval, timeout, poll, progress, done, timedOut }) {
+  const deadline = timeout === undefined ? null : clock.now() + timeout * 1000;
+  for (;; ) {
+    const item = await poll();
+    err(progress(item));
+    if (done(item))
+      return item;
+    if (deadline !== null && clock.now() >= deadline)
+      throw new Error(timedOut(item));
+    await clock.sleep(Math.max(1, interval) * 1000);
+  }
+}
+
+// src/commands/articles.ts
+var media = (article, field) => (article.status === "success" ? article[field] : null) ?? "null";
+function isTerminal(article) {
+  if (article.status === "failed")
+    return true;
+  if (article.status !== "success")
+    return false;
+  return article.video_status !== "pending" && article.interactive_status !== "pending";
+}
+function limitedList(value, name, max) {
+  const items = splitCsv(value);
+  if (items.length > max)
+    throw new Error(`${name} max out at ${max}, got ${items.length}`);
+  return items;
+}
+async function everyArticle(client, filter) {
+  const articles = [];
+  for (let page = 1;; page++) {
+    const res = await client.get("content-writing/articles", { page, limit: 100, ...filter });
+    articles.push(...res.articles);
+    if (page >= res.total_pages || res.articles.length === 0)
+      return articles;
+  }
+}
+function writeBody(options) {
+  const body = { company_profile_id: options.profileId, search_query: options.query, primary_keywords: options.primaryKeywords };
+  if (options.secondaryKeywords)
+    body.secondary_keywords = options.secondaryKeywords;
+  if (options.location)
+    body.location_to_rank_for = options.location;
+  if (options.guidelines)
+    body.extra_guidelines = options.guidelines;
+  if (options.imageGuideline)
+    body.image_guideline = options.imageGuideline;
+  if (options.internalLinks)
+    body.internal_links = splitCsv(options.internalLinks);
+  if (options.externalLinks)
+    body.external_links = limitedList(options.externalLinks, "external links", 5);
+  if (options.competitorLinks)
+    body.competitor_links = limitedList(options.competitorLinks, "competitor links", 3);
+  if (options.brandFacts)
+    body.brand_facts = options.brandFacts;
+  if (options.infographic)
+    body.infographic_feat_image = true;
+  if (options.video)
+    body.generate_video = true;
+  Object.assign(body, interactiveFields(options.interactive));
+  if (options.dewatermark !== undefined) {
+    body.dewatermark = options.dewatermark;
+    if (options.dewatermark)
+      err("--dewatermark adds one rewrite call per article and trades some of Claude's voice for hygiene.");
+  }
+  if (options.listicle) {
+    if (options.researchFile === undefined)
+      throw new Error("--listicle needs --research-file: paste the research from `ve-dynamite articles research-prompt` into a file first");
+    body.article_type = "listicle";
+    body.listicle_research = readText(options.researchFile);
+  } else if (options.researchFile !== undefined) {
+    throw new Error("--research-file only applies with --listicle");
+  }
+  if (options.itemCount !== undefined)
+    body.item_count = options.itemCount;
+  if (options.competitors)
+    body.allowed_competitors = splitCsv(options.competitors);
+  return body;
+}
+function updateBody(options) {
+  const body = either(options.body, options.bodyFile, "--body or --body-file");
+  const faqs = either(options.faqs, options.faqsFile, "--faqs or --faqs-file");
+  const payload = {};
+  if (options.title)
+    payload.title = options.title;
+  if (options.slug)
+    payload.slug = options.slug;
+  if (options.intro)
+    payload.intro = options.intro;
+  if (body)
+    payload.body = body;
+  if (faqs)
+    payload.faqs = faqs;
+  if (options.featImage)
+    payload.feat_image = options.featImage;
+  if (Object.keys(payload).length === 0) {
+    throw new Error("nothing to update, pass at least one of --title, --slug, --intro, --body, --body-file, --faqs, --faqs-file, --feat-image");
+  }
+  return payload;
+}
+function registerArticles(program, cli) {
+  const articles = program.command("articles").description("Manage articles");
+  articles.command("write").description("Queue an article for generation (async, costs real money per article)").requiredOption("--profile-id <id>", "Company profile id", integer).requiredOption("--query <query>", "Search query the article should target").requiredOption("--primary-keywords <keywords>", "Primary keywords").option("--secondary-keywords <keywords>", "Secondary keywords").option("--location <location>", "Location to rank for").option("--guidelines <text>", "Extra writing guidelines").option("--image-guideline <text>", "Featured image guideline").option("--internal-links <urls>", "Comma separated URLs on the company's own site that must be linked").option("--external-links <urls>", "Comma separated outside sources the article must cite (max 5)").option("--competitor-links <urls>", "Comma separated competitor URLs (max 3)").option("--brand-facts <text>", "Verified facts about the client the article may state, such as the CLIENT FACTS block from research-prompt").option("--infographic", "Generate the featured image as an infographic").option("--video", "Generate a companion video").option("--interactive [type]", `Generate an interactive component, optionally ${INTERACTIVE_TYPES.join("|")} (bare flag lets the server auto select)`).option("--dewatermark", "Rewrite the finished prose through a non-Claude model. Omit to follow DEWATERMARK_REWRITE_ENABLED").option("--no-dewatermark", "Keep the prose as written, whatever DEWATERMARK_REWRITE_ENABLED says").option("--listicle", "Write a structured listicle. Requires --research-file").option("--research-file <path>", "File holding the research and source links a listicle is built from").option("--item-count <count>", "How many options the listicle should cover (3 to 10)", integer).option("--competitors <names>", "Comma separated list of the only competitors a listicle may name").action(async (options) => {
+    const res = await cli.client().post("content-writing/article", writeBody(options));
+    cli.billed(1);
+    err(`Generation is asynchronous and spends real money (LLM, SERP, crawling, images). Poll with ${cli.follow(`articles watch ${res.article_id}`, `articles get ${res.article_id}`)}`);
+    out(res);
+  });
+  articles.command("research-prompt").description("Print the research prompt to run in an external AI tool before writing a listicle").requiredOption("--profile-id <id>", "Company profile id, names the client in the prompt", integer).requiredOption("--keyword <keyword>", "The keyword the listicle targets").option("--title <title>", "Working title, defaults to the keyword").option("--location <location>", "Location the reader is in").option("--item-count <count>", "How many options to research (3 to 10)", integer).action(async (options) => {
+    const res = await cli.client().get("content-writing/listicle-research-prompt", {
+      keyword: options.keyword,
+      profile_id: options.profileId,
+      title: options.title,
+      location: options.location,
+      item_count: options.itemCount
+    });
+    err(`Research prompt for ${res.company_name}. Paste the CLIENT FACTS block into --brand-facts, the rest into --research-file.`);
+    line(res.prompt);
+  });
+  documentOutput(articles.command("download").description("Download a finished article as a document (docx imports straight into Google Docs)").argument("<ID>", "Article id", integer).option("--format <format>", "docx (opens in Google Docs) or md", "docx"), cli).action(async (articleId, options) => {
+    const target = await downloadDocument(cli, `content-writing/article/${articleId}/export`, options.format, options.output, `article-${articleId}`);
+    err(`exported article ${articleId} to ${target}`);
+  });
+  articles.command("get").description("Show one article (slim {article_id, status} shape until the article completes)").argument("<ID>", "Article id", integer).action(async (articleId) => out(await cli.client().get(`content-writing/article/${articleId}`)));
+  articles.command("list").description("List articles, newest first").option("--page <page>", "Page number", integer, 1).option("--limit <limit>", "Page size (max 100)", integer, 10).option("--company <name>", "Filter by exact company name").option("--status <status>", "Filter by status: pending, success, failed").option("--batch-id <id>", "Filter by batch id", integer).action(async (options) => {
+    const status = wireStatus(options.status);
+    out(await cli.client().get("content-writing/articles", { page: options.page, limit: options.limit, company_name: options.company, status, batch_id: options.batchId }));
+  });
+  if (!cli.mount) {
+    articles.command("watch").description("Poll an article until the write AND any requested video/interactive are terminal").argument("<ID>", "Article id", integer).option("--interval <seconds>", "Seconds between polls", decimal, 10).option("--timeout <seconds>", "Give up after this many seconds", decimal).action(async (articleId, options) => {
+      const client = cli.client();
+      const article = await watchLoop({
+        interval: options.interval,
+        timeout: options.timeout,
+        poll: () => client.get(`content-writing/article/${articleId}`),
+        progress: (item) => `[${isoNow()}] status=${item.status} video=${media(item, "video_status")} interactive=${media(item, "interactive_status")}`,
+        done: isTerminal,
+        timedOut: (item) => `timed out after ${fmtNum(options.timeout)}s, article ${articleId} still ${item.status}`
+      });
+      out(article);
+      if (article.status === "failed")
+        throw new Exit(1);
+    });
+  }
+  articles.command("update").description("Update article fields (409 while the article is still being written)").argument("<ID>", "Article id", integer).option("--title <title>", "New title").option("--slug <slug>", "New slug").option("--intro <intro>", "New intro").option("--body <markdown>", "New body markdown").option("--body-file <path>", "Read the new body from a file").option("--faqs <faqs>", "New FAQs").option("--faqs-file <path>", "Read the new FAQs from a file").option("--feat-image <url>", "New featured image URL").action(async (articleId, options) => out(await cli.client().put(`content-writing/article/${articleId}`, updateBody(options))));
+  articles.command("embed-audit").description("List completed articles whose body still has the interactive block welded in (read only)").option("--limit <limit>", "Articles to scan per page", integer, 50).option("--page <page>", "Page of completed articles to scan", integer, 1).action(async (options) => {
+    const res = await cli.client().get("content-writing/articles/interactive-embed-audit", { page: options.page, limit: options.limit });
+    if (res.articles.length === 0) {
+      err(`Scanned ${res.total_success} completed article(s), none carry a welded embed.`);
+    } else {
+      err(`${res.articles.length} article(s) still carry the block inside the body:`);
+      for (const item of res.articles) {
+        err(`  #${item.article_id} [${item.company_name}] ${item.interactive_type} (${item.payload_stored ? "payload stored" : "NO PAYLOAD — leave alone"})`);
+      }
+    }
+    out(res);
+  });
+  articles.command("strip-embeds").summary("Take the interactive block out of shipped bodies, leaving the payload (no spend)").description(`Take the interactive block out of shipped bodies, leaving the payload (no spend)
+
+` + "The component then comes from `interactive_embed` on the API instead, which is what lets a site place it. " + "Run this only once whoever renders these articles reads that field: until then the block in the body is what a reader sees.").argument("[ID]", "Omit to strip every article you own", integer).option("--dry-run", "Only list what would be stripped, change nothing").action(async (articleId, options) => {
+    const client = cli.client();
+    if (options.dryRun) {
+      const res = await client.get("content-writing/articles/interactive-embed-audit", { limit: 200 });
+      const targets = res.articles.filter((item) => articleId === undefined || item.article_id === articleId);
+      err(`would strip ${targets.length} article(s): ${targets.map((item) => `#${item.article_id}`).join(", ") || "none"}`);
+      out({ would_strip: targets.map((item) => item.article_id) });
+      return;
+    }
+    out(await client.post("content-writing/articles/strip-interactive-embeds", articleId === undefined ? null : [articleId]));
+  });
+  articles.command("provenance-audit").description("List completed articles still carrying invisible characters (read only, no spend)").option("--limit <limit>", "Articles to scan per page", integer, 50).option("--page <page>", "Page of completed articles to scan", integer, 1).action(async (options) => {
+    const res = await cli.client().get("content-writing/articles/provenance-audit", { page: options.page, limit: options.limit });
+    if (res.articles.length === 0) {
+      err(`Scanned ${res.checked} completed article(s), none carry invisible characters.`);
+    } else {
+      err(`${res.articles.length} of ${res.checked} scanned article(s) carry invisible characters:`);
+      for (const item of res.articles) {
+        const classes = [...new Set(Object.values(item.findings).flatMap((counts) => Object.keys(counts)))].sort();
+        err(`  #${item.article_id} [${item.company_name}] ${item.total_findings} char(s): ${classes.join(", ")}`);
+      }
+    }
+    out(res);
+  });
+  const clean = articles.command("clean-provenance").description("Strip invisible characters from shipped articles in place (deterministic, no spend without --rewrite)").argument("[ID]", "Omit to clean every flagged article", integer).option("--rewrite", "Also run the Layer B prose rewrite. Costs an LLM call and some voice").option("--dry-run", "Only list what would be cleaned, change nothing");
+  if (!cli.mount) {
+    clean.option("--watch", "After cleaning, poll the audit until it comes back clean").option("--interval <seconds>", "Seconds between audit polls with --watch", decimal, 15).option("--timeout <seconds>", "Give up polling after this many seconds with --watch", decimal, 300);
+  }
+  clean.action(async (articleId, options) => {
+    const client = cli.client();
+    const audit = { limit: 200 };
+    const rewrite = options.rewrite ? { rewrite: true } : undefined;
+    if (options.rewrite) {
+      err("--rewrite sends the prose to the configured non-Claude model. It costs a call per article and");
+      err("the rewrite model's word choices replace Claude's. It cannot be certified against any detector.");
+    }
+    if (articleId !== undefined) {
+      if (options.dryRun) {
+        err(`would clean article #${articleId}`);
+        return;
+      }
+      const res = await client.post(`content-writing/article/${articleId}/clean-provenance`, undefined, rewrite);
+      if (rewrite)
+        cli.billed(1);
+      out(res);
+      return;
+    }
+    const flagged = await client.get("content-writing/articles/provenance-audit", audit);
+    if (flagged.articles.length === 0) {
+      err(`Scanned ${flagged.checked} completed article(s), nothing to clean.`);
+      out(flagged);
+      return;
+    }
+    err(`${flagged.articles.length} article(s) carry invisible characters:`);
+    for (const item of flagged.articles)
+      err(`  #${item.article_id} [${item.company_name}] ${item.total_findings} char(s)`);
+    if (options.dryRun) {
+      out(flagged);
+      return;
+    }
+    const cleaned = [];
+    try {
+      for (const item of flagged.articles) {
+        const res = await client.post(`content-writing/article/${item.article_id}/clean-provenance`, undefined, rewrite);
+        cleaned.push(res);
+        err(`cleaned #${item.article_id}: ${res.msg}`);
+      }
+    } finally {
+      if (rewrite)
+        cli.billed(cleaned.length);
+    }
+    if (!options.watch) {
+      out({ cleaned });
+      return;
+    }
+    out(await watchLoop({
+      interval: options.interval,
+      timeout: options.timeout,
+      poll: () => client.get("content-writing/articles/provenance-audit", audit),
+      progress: (res) => `[${isoNow()}] articles still carrying carriers: ${res.articles.length}`,
+      done: (res) => res.articles.length === 0,
+      timedOut: (res) => `timed out after ${fmtNum(options.timeout)}s, ${res.articles.length} article(s) still flagged`
+    }));
+  });
+  articles.command("delete").description("Delete an article permanently").argument("<ID>", "Article id", integer).option("--yes", "Confirm the deletion").action(async (articleId, options) => {
+    if (!options.yes)
+      throw new Error("deleting an article is permanent, re-run with --yes to confirm");
+    out(await cli.client().delete(`content-writing/article/${articleId}`));
+  });
+  articles.command("export").description("Export all matching articles via client side paging").option("--company <name>", "Filter by exact company name").option("--status <status>", "Filter by status: pending, success, failed").option("--batch-id <id>", "Filter by batch id", integer).option("--ndjson", "Newline delimited JSON instead of an array").option("-o, --output <path>", "Write to a file instead of stdout").action(async (options) => {
+    const status = wireStatus(options.status);
+    const found = await everyArticle(cli.client(), { company_name: options.company, status, batch_id: options.batchId });
+    const text = options.ndjson ? found.map((article) => `${JSON.stringify(article)}
+`).join("") : JSON.stringify(found, null, 2);
+    if (!options.output) {
+      write(text);
+      return;
+    }
+    writeFile(options.output, text);
+    err(`exported ${found.length} articles to ${options.output}`);
+  });
+  return articles;
+}
+
+// src/client.ts
+class ApiError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+function describeDetail(text) {
+  try {
+    const detail = JSON.parse(text).detail;
+    if (typeof detail === "string")
+      return detail;
+    if (Array.isArray(detail))
+      return detail.map((item) => `${(item.loc ?? []).slice(1).join(".")}: ${item.msg}`).join("; ");
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function apiError(response) {
+  const text = await response.text();
+  return new ApiError(response.status, `${response.status}: ${describeDetail(text) ?? (text || response.statusText)}`);
+}
+
+class ApiClient {
+  baseUrl;
+  token;
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  get(path, params) {
+    return this.json("GET", path, { params });
+  }
+  async getText(path, params) {
+    return (await this.request("GET", path, { params })).text();
+  }
+  async getDownload(path, params) {
+    const response = await this.request("GET", path, { params });
+    const filename = /filename="([^"]+)"/.exec(response.headers.get("content-disposition") ?? "")?.[1] ?? null;
+    return { content: new Uint8Array(await response.arrayBuffer()), filename };
+  }
+  post(path, body, params) {
+    return this.json("POST", path, { body, params });
+  }
+  postForm(path, file, filename, params) {
+    const form = new FormData;
+    form.append("file", file, filename);
+    return this.json("POST", path, { form, params });
+  }
+  put(path, body) {
+    return this.json("PUT", path, { body });
+  }
+  patch(path, body) {
+    return this.json("PATCH", path, { body });
+  }
+  delete(path) {
+    return this.json("DELETE", path, {});
+  }
+  async json(method, path, payload) {
+    return await (await this.request(method, path, payload)).json();
+  }
+  async request(method, path, { params, body, form }) {
+    const headers = this.token ? { Authorization: `Bearer ${this.token}` } : {};
+    let content = form;
+    if (!form && method !== "GET" && method !== "DELETE") {
+      headers["Content-Type"] = "application/json";
+      content = body == null ? undefined : JSON.stringify(body);
+    }
+    const response = await fetch(this.url(path, params), { method, headers, body: content, redirect: "manual" });
+    if (!response.ok)
+      throw await apiError(response);
+    return response;
+  }
+  url(path, params) {
+    const query = new URLSearchParams;
+    for (const [key, value] of Object.entries(params ?? {})) {
+      if (value !== null && value !== undefined && value !== "")
+        query.set(key, String(value));
+    }
+    const search = query.toString();
+    return `${this.baseUrl}/api/v1/${path}${search ? `?${search}` : ""}`;
+  }
+}
+
+// src/credentials.ts
+import { chmodSync, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { z as z5 } from "zod";
+
+// src/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_API_URL = "https://content-dynamite.alexthecomputer1.workers.dev";
+function configDir() {
+  const override = process.env.VE_DYNAMITE_CONFIG_DIR;
+  if (override)
+    return override;
+  const xdg = process.env.XDG_CONFIG_HOME;
+  return xdg ? join(xdg, "ve-dynamite") : join(homedir(), ".config", "ve-dynamite");
+}
+var credentialsPath = () => join(configDir(), "credentials.json");
+var imageJobsPath = () => join(configDir(), "image-jobs.json");
+function defaultApiUrl() {
+  return process.env.VE_DYNAMITE_API_URL || DEFAULT_API_URL;
+}
+function envToken() {
+  return process.env.VE_DYNAMITE_TOKEN || undefined;
+}
+
+// src/credentials.ts
+var PAT_PREFIX = "ved_";
+var EXPIRY_SKEW_MS = 60000;
+var storedCredentials = z5.object({
+  authToken: z5.string(),
+  email: z5.string(),
+  username: z5.string(),
+  profile: z5.string().nullable(),
+  expiresAt: z5.number().int().nullable()
+});
+var isPat = (token) => token.startsWith(PAT_PREFIX);
+function loadCredentials() {
+  try {
+    return storedCredentials.parse(JSON.parse(readFileSync2(credentialsPath(), "utf8")));
+  } catch {
+    return null;
+  }
+}
+function saveCredentials({ authToken, email, username, profile, expiresAt }) {
+  mkdirSync(configDir(), { recursive: true, mode: 448 });
+  const path = credentialsPath();
+  writeFileSync2(path, JSON.stringify({ authToken, email, username, profile, expiresAt }, null, 2), { mode: 384 });
+  chmodSync(path, 384);
+}
+function clearCredentials() {
+  try {
+    unlinkSync(credentialsPath());
+  } catch {
+    return;
+  }
+}
+function decodeJwtPayload(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token.split(".")[1] ?? "", "base64url").toString("utf8"));
+    return payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
+  } catch {
+    return null;
+  }
+}
+function decodeJwtExp(token) {
+  const exp = decodeJwtPayload(token)?.exp;
+  return typeof exp === "number" ? exp * 1000 : null;
+}
+function resolveToken(flagToken, stored = true) {
+  if (flagToken)
+    return { token: flagToken, source: "flag", credentials: null };
+  const env = envToken();
+  if (env)
+    return { token: env, source: "env", credentials: null };
+  if (!stored)
+    throw new Error("no API token, set VE_DYNAMITE_TOKEN or pass --token");
+  const credentials = loadCredentials();
+  if (!credentials)
+    throw new Error("not logged in, run `ve-dynamite login` or set VE_DYNAMITE_TOKEN");
+  if (credentials.expiresAt !== null && Date.now() >= credentials.expiresAt - EXPIRY_SKEW_MS)
+    throw new Error("token expired, run `ve-dynamite login`");
+  return { token: credentials.authToken, source: "stored", credentials };
+}
+
+// src/commands/auth.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+async function signedIn(client, rejected) {
+  try {
+    return await client.get("auth/me");
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 401)
+      throw new Error(rejected);
+    throw error;
+  }
+}
+function registerAuth(program, cli) {
+  if (!cli.mount)
+    registerLogin(program, cli);
+  program.command("whoami").description("Print the signed in identity and its role, checking the token against the API").action(async () => {
+    const resolved = cli.token();
+    const rejected = cli.mount ? "not authenticated, the API rejected the token" : "not authenticated, run `ve-dynamite login`";
+    const me = await signedIn(new ApiClient(cli.baseUrl(), resolved.token), rejected);
+    const expiresAt = decodeJwtExp(resolved.token);
+    out({
+      email: me.email,
+      username: me.username,
+      profile: me.profile,
+      role: me.role,
+      user_id: me.user_id,
+      token_source: resolved.source,
+      token_type: isPat(resolved.token) ? "pat" : "jwt",
+      expires_at: expiresAt ? isoFromMs(expiresAt) : null
+    });
+  });
+}
+function registerLogin(program, cli) {
+  program.command("login").description("Sign in with your Content Dynamite account and store the 24h token locally").requiredOption("--email <email>", "Account email").requiredOption("--password <password>", "Account password").action(async (options) => {
+    const res = await new ApiClient(cli.baseUrl(), "").post("auth/login", { email: options.email, passwd: options.password });
+    const expiresAt = decodeJwtExp(res.auth_token) ?? Date.now() + DAY_MS;
+    saveCredentials({ authToken: res.auth_token, email: res.email, username: res.username, profile: res.profile, expiresAt });
+    err(`✓ Logged in as ${res.username} (${res.email}), token valid until ${isoFromMs(expiresAt)}`);
+    out({ email: res.email, username: res.username, role: res.role });
+  });
+  program.command("logout").description("Delete the locally stored credential").action(() => {
+    clearCredentials();
+    err("✓ Logged out");
+  });
+}
+
+// src/commands/batches.ts
+import { basename as basename2 } from "node:path";
+
+// src/jobs.ts
+function valueAt(input, path) {
+  let value = input;
+  for (const key of path) {
+    if (value === null || typeof value !== "object")
+      return;
+    value = value[key];
+  }
+  return value;
+}
+function readJobs(path) {
+  const raw = JSON.parse(readText(path));
+  if (!Array.isArray(raw) || raw.length === 0)
+    throw new Error("--jobs file must be a non empty JSON array");
+  return raw;
+}
+function parseJobs(raw, schema) {
+  const fields = Object.keys(schema.shape);
+  return raw.map((item, index) => {
+    if (item === null || typeof item !== "object" || Array.isArray(item))
+      throw new Error(`job ${index}: must be a JSON object`);
+    const unknown = Object.keys(item).find((key) => !fields.includes(key));
+    if (unknown !== undefined)
+      throw new Error(`job ${index}: unknown field '${unknown}'`);
+    const parsed = schema.safeParse(item);
+    if (parsed.success)
+      return parsed.data;
+    const issue = parsed.error.issues[0];
+    const message = issue.code === "invalid_type" && valueAt(item, issue.path) === undefined ? "Field required" : issue.message;
+    const location = issue.path.map(String).join(".");
+    throw new Error(`job ${index}: ${location ? `${location}: ${message}` : message}`);
+  });
+}
+
+// src/commands/batches.ts
+var GUIDELINE_HINT = "the batch wide --guidelines / --image-guideline flags";
+var TRUTHY = ["true", "1", "yes"];
+async function findBatch(client, batchId) {
+  const batch = (await client.get("content-writing/batches")).find((item) => item.batch_id === batchId);
+  if (!batch)
+    throw new Error(`batch ${batchId} not found, run \`ve-dynamite batches list\``);
+  return batch;
+}
+async function jobsCsv(options) {
+  if (Boolean(options.csv) === Boolean(options.jobs))
+    throw new Error("pass exactly one of --csv or --jobs");
+  if (options.csv)
+    return { csv: readText(options.csv), filename: options.csv.endsWith(".csv") ? basename2(options.csv) : "batch.csv" };
+  const jobs = parseJobs(readJobs(options.jobs), batchArticleJob);
+  return { csv: await articleJobsToCsv(jobs, GUIDELINE_HINT).text(), filename: "batch.csv" };
+}
+var gbpPostsAsked = (csv) => readCsvTable(csv).rows.filter((row) => TRUTHY.includes((row.get("gbp_post") ?? "").trim().toLowerCase())).length;
+function batchParams(options) {
+  const params = { batch_name: options.name };
+  if (options.guidelines)
+    params.extra_guidelines = options.guidelines;
+  if (options.imageGuideline)
+    params.image_guideline = options.imageGuideline;
+  if (options.infographic)
+    params.infographic_feat_image = true;
+  if (options.video)
+    params.generate_video = true;
+  Object.assign(params, interactiveFields(options.interactive));
+  if (options.dewatermark !== undefined) {
+    params.dewatermark = options.dewatermark;
+    if (options.dewatermark)
+      err("--dewatermark adds one rewrite call PER ARTICLE and trades some of Claude's voice for hygiene.");
+  }
+  return params;
+}
+function registerBatches(program, cli) {
+  const batches = program.command("batches").description("Manage article batches");
+  batches.command("create").description("Queue a batch of articles (async, costs real money PER ARTICLE)").requiredOption("--name <name>", "Batch name (unique per user)").option("--csv <path>", "CSV file of jobs").option("--jobs <path>", "JSON file with an array of job objects").option("--guidelines <text>", "Batch wide extra writing guidelines").option("--image-guideline <text>", "Batch wide featured image guideline").option("--infographic", "Batch wide infographic featured images").option("--video", "Batch wide companion videos").option("--interactive [type]", `Batch wide interactive components, optionally ${INTERACTIVE_TYPES.join("|")}`).option("--dewatermark", "Batch wide prose rewrite through a non-Claude model. Omit to follow DEWATERMARK_REWRITE_ENABLED. A per row dewatermark column still wins").option("--no-dewatermark", "Batch wide: keep the prose as written. A per row dewatermark column still wins").action(async (options) => {
+    const { csv, filename } = await jobsCsv(options);
+    const params = batchParams(options);
+    const res = await cli.client().postForm("content-writing/articles/batch", new Blob([csv], { type: "text/csv" }), filename, params);
+    cli.billed(res.total + gbpPostsAsked(csv));
+    err(`Queued ${res.total} articles, each spends real money (LLM, SERP, crawling, images). Poll with ${cli.follow(`batches watch ${res.batch_id}`, `batches get ${res.batch_id}`)}`);
+    out(res);
+  });
+  batches.command("list").description("List your batches with progress counters").action(async () => out(await cli.client().get("content-writing/batches")));
+  batches.command("get").description("Show one batch with its member articles").argument("<ID>", "Batch id", integer).action(async (batchId) => {
+    const client = cli.client();
+    const batch = await findBatch(client, batchId);
+    out({ ...batch, articles: await everyArticle(client, { batch_id: batchId }) });
+  });
+  if (!cli.mount) {
+    batches.command("watch").description("Poll a batch until every article is completed or failed").argument("<ID>", "Batch id", integer).option("--interval <seconds>", "Seconds between polls", decimal, 10).option("--timeout <seconds>", "Give up after this many seconds", decimal).action(async (batchId, options) => {
+      const client = cli.client();
+      const settled = (batch2) => batch2.completed_articles + batch2.failed_articles;
+      const batch = await watchLoop({
+        interval: options.interval,
+        timeout: options.timeout,
+        poll: () => findBatch(client, batchId),
+        progress: (item) => `[${isoNow()}] completed=${item.completed_articles} failed=${item.failed_articles} total=${item.total_articles}`,
+        done: (item) => settled(item) >= item.total_articles,
+        timedOut: (item) => `timed out after ${fmtNum(options.timeout)}s, batch ${batchId} at ${settled(item)}/${item.total_articles}`
+      });
+      out(batch);
+      if (batch.failed_articles > 0)
+        throw new Exit(1);
+    });
+  }
+  batches.command("delete").description("Delete a batch permanently").argument("<ID>", "Batch id", integer).option("--yes", "Confirm the deletion").action(async (batchId, options) => {
+    if (!options.yes)
+      throw new Error("deleting a batch is permanent, re-run with --yes to confirm");
+    out(await cli.client().delete(`content-writing/batch/${batchId}`));
+  });
+}
+
+// src/commands/evals.ts
+var DEFAULT_THRESHOLD = 7;
+var ORIGIN_ORDER = ["copy", "inputs", "age", "blocked"];
+var articleIds = (value, previous = []) => [...previous, integer(value)];
+function originLine(lost) {
+  const origins = Object.keys(lost);
+  if (origins.length === 0)
+    return "nothing lost";
+  const ordered = [...ORIGIN_ORDER.filter((origin) => (origin in lost)), ...origins.filter((origin) => !ORIGIN_ORDER.includes(origin))];
+  return ordered.map((origin) => `${origin} ${lost[origin]}`).join(", ");
+}
+function exitOn(rows, threshold) {
+  const low = rows.filter((row) => row.score !== null && row.score < threshold);
+  if (low.length === 0)
+    return;
+  err(`${low.length} article(s) below ${threshold}`);
+  throw new Exit(1);
+}
+function printAudit(res) {
+  const summary = res.summary;
+  line(`${summary.count} article(s) of ${res.total_success} shipped  mean ${summary.mean ?? null}  range ${summary.min ?? null} to ${summary.max ?? null}` + `  ${summary.below_threshold ?? 0} below ${summary.threshold ?? null}`);
+  line(`points lost by origin: ${originLine(summary.points_lost_by_origin ?? {})}`);
+  line(`compliance mean counting COPY faults only: ${summary.mean_compliance_excluding_non_copy ?? null}`);
+  line("");
+  line(`${"score".padStart(7)} ${"content".padStart(8)} ${"image".padStart(7)}  article`);
+  for (const row of res.articles) {
+    line(`${String(row.score).padStart(7)} ${String(row.content_score).padStart(8)} ${String(row.image_score ?? "-").padStart(7)}  #${String(row.article_id).padEnd(5)} ${row.title.slice(0, 46)}`);
+    if (Object.keys(row.lost_by_origin).length > 0)
+      line(`${"".padStart(24)}  lost: ${originLine(row.lost_by_origin)}`);
+  }
+}
+function printPart(name, part) {
+  line(`  ${name}  ${part.score}/${part.budget}${part.trusted === false ? "   (reported, NOT counted in the score)" : ""}`);
+  for (const deduction of part.deductions) {
+    line(`    -${String(deduction.points).padEnd(5)} ${deduction.origin.padEnd(7)} ${deduction.code.padEnd(33)} ${deduction.message}`);
+    if (deduction.evidence)
+      line(`           evidence: ${deduction.evidence.slice(0, 110)}`);
+  }
+  for (const skipped of part.skipped)
+    line(`    skipped: ${skipped}`);
+}
+function printReport(articleId, res) {
+  const { content, image } = res.report;
+  const blended = content.score_with_model ?? content.score;
+  const contentColumn = blended !== content.score ? `content ${blended} (code ${content.score})` : `content ${content.score}`;
+  line("");
+  line(`#${articleId}  SCORE ${res.score}   ${contentColumn}   image ${image?.scaled_score ?? "-"}${res.stored ? "   [stored]" : ""}`);
+  const verdict = content.judge;
+  if (verdict) {
+    line(`  judge  ${verdict.total}/${verdict.ceiling} -> ${verdict.score}/10   ${verdict.verdict.toUpperCase()}   (${verdict.model})`);
+    for (const [dimension, score] of Object.entries(verdict.scores))
+      line(`    ${String(score).padStart(2)}/10  ${dimension}`);
+    for (const violation of verdict.violations.slice(0, 5))
+      line(`    ! ${violation.slice(0, 140)}`);
+    for (const fix of verdict.top_fixes)
+      line(`    fix: ${fix.slice(0, 130)}`);
+  } else if (content.judge_error) {
+    err(`  judge did not run: ${content.judge_error}`);
+  }
+  printPart("compliance", content.compliance);
+  printPart("craft", content.craft);
+  if (image)
+    printPart("image", image);
+}
+function registerEvals(program, cli) {
+  const evals = program.command("evals").description("Score finished articles against the deterministic quality checks");
+  evals.command("run").description("Score one or more articles. Free: no model is called.").argument("[ID...]", "Article ids. Omit with --all.", articleIds).option("--all", "Score every shipped article").option("--company <name>", "Only this company's articles (with --all)").option("--no-images", "Skip the per image fetch").option("--judge", "Also run the model judge. Costs a model call per article.").option("--store", "Keep the result on article.qa_report (the default)").option("--no-store", "Score without keeping the result").option("--threshold <score>", "Exit 1 if any article scores below this", decimal, DEFAULT_THRESHOLD).option("--limit <limit>", "Page size for --all", integer, 200).option("--json", "Emit the full report instead of a summary").action(async (ids, options) => {
+    const articles = ids ?? [];
+    if (options.all && articles.length > 0)
+      throw new Error("pass article ids or --all, not both");
+    if (!options.all && articles.length === 0)
+      throw new Error("pass at least one article id, or --all");
+    if (options.company && !options.all)
+      throw new Error("--company only applies with --all");
+    const client = cli.client();
+    err(`scoring against ${cli.baseUrl()}`);
+    if (options.all) {
+      const params = { limit: options.limit, images: options.images ? "true" : "false", company_name: options.company };
+      const res = await client.get("content-writing/articles/qa-audit", params);
+      if (options.json)
+        out(res);
+      else
+        printAudit(res);
+      exitOn(res.articles, options.threshold);
+      return;
+    }
+    const rows = [];
+    try {
+      for (const articleId of articles) {
+        const res = await client.post(`content-writing/article/${articleId}/qa`, undefined, {
+          model_checks: options.judge ? "true" : "false",
+          store: options.store === false ? "false" : "true"
+        });
+        rows.push({ article_id: articleId, score: res.score, report: res.report });
+        if (!options.json)
+          printReport(articleId, res);
+      }
+    } finally {
+      cli.billed(rows.filter((row) => row.report.content.judge).length);
+    }
+    if (options.json)
+      out(rows);
+    exitOn(rows, options.threshold);
+  });
+}
+
+// src/commands/gbp.ts
+import { basename as basename3 } from "node:path";
+var isTerminal2 = (post) => post.status === "done" || post.status === "failed";
+function writeBody2(options) {
+  const facts = either(options.facts, options.factsFile, "--facts or --facts-file");
+  const body = { company_profile_id: options.profileId };
+  if (options.topic)
+    body.topic = options.topic;
+  if (options.articleId !== undefined)
+    body.article_id = options.articleId;
+  if (options.location)
+    body.location = options.location;
+  if (facts)
+    body.facts = facts;
+  if (options.guidelines)
+    body.guidelines = options.guidelines;
+  if (options.image)
+    body.image_mode = options.image;
+  if (options.imageUrl)
+    body.image_url = options.imageUrl;
+  if (options.imageGuideline)
+    body.image_guideline = options.imageGuideline;
+  if (options.regenerate)
+    body.regenerate = true;
+  return body;
+}
+async function postsCsv(options) {
+  if (Boolean(options.csv) === Boolean(options.jobs))
+    throw new Error("pass exactly one of --csv or --jobs");
+  if (options.csv)
+    return { csv: readText(options.csv), filename: options.csv.endsWith(".csv") ? basename3(options.csv) : "gbp.csv" };
+  return { csv: await gbpJobsToCsv(parseJobs(readJobs(options.jobs), batchGbpJob)).text(), filename: "gbp.csv" };
+}
+function batchParams2(options) {
+  const facts = either(options.facts, options.factsFile, "--facts or --facts-file");
+  const params = {};
+  if (options.location)
+    params.location = options.location;
+  if (facts)
+    params.facts = facts;
+  if (options.guidelines)
+    params.guidelines = options.guidelines;
+  if (options.image)
+    params.image_mode = options.image;
+  if (options.imageGuideline)
+    params.image_guideline = options.imageGuideline;
+  return params;
+}
+function updateBody2(options) {
+  const content = either(options.content, options.contentFile, "--content or --content-file");
+  const body = {};
+  if (content)
+    body.content = content;
+  if (options.imageUrl)
+    body.image_url = options.imageUrl;
+  if (options.topic)
+    body.topic = options.topic;
+  if (options.status)
+    body.status = wireGbpStatus(options.status);
+  if (Object.keys(body).length === 0)
+    throw new Error("nothing to update");
+  return body;
+}
+function registerGbp(program, cli) {
+  const gbp = program.command("gbp").description("Manage Google Business Profile posts");
+  gbp.command("write").description("Queue one GBP post (async, spends an LLM call and, unless --image none, an image credit)").requiredOption("--profile-id <id>", "Company profile id", integer).option("--topic <topic>", "What the post is about. Required unless --article-id is given").option("--article-id <id>", "Repurpose this finished article instead of writing from a topic", integer).option("--location <location>", "Service area to frame the post around").option("--facts <text>", "The only specifics the post may state about this company").option("--facts-file <path>", "Read the facts from a file").option("--guidelines <text>", "A one off instruction for this post").option("--image <mode>", "none | supplied | article | generate. Defaults to article when repurposing and generate otherwise").option("--image-url <url>", "The picture to use. Upload one with `ve-dynamite upload`, or take one from `ve-dynamite gbp image-options`").option("--image-guideline <text>", "Style guidance, for a generated image only").option("--regenerate", "Overwrite the post this article already has").action(async (options) => {
+    const res = await cli.client().post("gbp-posts/", writeBody2(options));
+    cli.billed(1);
+    err(`Poll with ${cli.follow(`gbp watch ${res.gbp_post_id}`, `gbp get ${res.gbp_post_id}`)}`);
+    out(res);
+  });
+  gbp.command("batch").description("Queue a list of GBP posts (async, spends real money PER POST)").option("--csv <path>", "CSV file of posts (columns: company_profile_id, topic, article_id, location, facts, guidelines, image_mode, image_url, image_guideline, regenerate)").option("--jobs <path>", "JSON file with an array of post objects").option("--location <location>", "Batch wide service area").option("--facts <text>", "Batch wide brand facts").option("--facts-file <path>", "Read the batch wide facts from a file").option("--guidelines <text>", "Batch wide writing instruction").option("--image <mode>", "Batch wide image mode: none | supplied | article | generate").option("--image-guideline <text>", "Batch wide image style guidance").action(async (options) => {
+    const { csv, filename } = await postsCsv(options);
+    const params = batchParams2(options);
+    const res = await cli.client().postForm("gbp-posts/batch", new Blob([csv], { type: "text/csv" }), filename, params);
+    cli.billed(res.total);
+    err(`Queued ${res.total} GBP posts, each spends real money. Poll with \`ve-dynamite gbp list\``);
+    out(res);
+  });
+  gbp.command("get").description("Show one GBP post").argument("<ID>", "GBP post id", integer).action(async (postId) => out(await cli.client().get(`gbp-posts/${postId}`)));
+  gbp.command("list").description("List GBP posts, newest first").option("--page <page>", "Page number", integer, 1).option("--limit <limit>", "Page size (max 100)", integer, 10).option("--company <name>", "Filter by exact company name").option("--status <status>", "Filter by status: pending, done, failed").option("--source <source>", "Filter by where the post came from: article or topic").action(async (options) => {
+    const filter = { status: wireGbpStatus(options.status), source: wireGbpSource(options.source) };
+    out(await cli.client().get("gbp-posts/", { page: options.page, limit: options.limit, company_name: options.company, ...filter }));
+  });
+  if (!cli.mount) {
+    gbp.command("watch").description("Poll a GBP post until it is written (done or failed)").argument("<ID>", "GBP post id", integer).option("--interval <seconds>", "Seconds between polls", decimal, 5).option("--timeout <seconds>", "Give up after this many seconds", decimal).action(async (postId, options) => {
+      const client = cli.client();
+      const post = await watchLoop({
+        interval: options.interval,
+        timeout: options.timeout,
+        poll: () => client.get(`gbp-posts/${postId}`),
+        progress: (item) => `[${isoNow()}] status=${item.status} image=${item.image_url ? "yes" : "no"}`,
+        done: isTerminal2,
+        timedOut: (item) => `timed out after ${fmtNum(options.timeout)}s, GBP post ${postId} still ${item.status}`
+      });
+      out(post);
+      if (post.status === "failed")
+        throw new Exit(1);
+    });
+  }
+  gbp.command("image-options").description("Images this client already has, any of which can be passed to --image-url").requiredOption("--profile-id <id>", "Company profile id", integer).action(async (options) => out(await cli.client().get("gbp-posts/image-options", { company_profile_id: options.profileId })));
+  gbp.command("update").description("Edit a written GBP post by hand before it goes live").argument("<ID>", "GBP post id", integer).option("--content <text>", "Replace the post text").option("--content-file <path>", "Read the replacement text from a file").option("--image-url <url>", "Replace the image").option("--topic <topic>", "Correct the recorded topic").option("--status <status>", "Set the status: pending, done, failed").action(async (postId, options) => out(await cli.client().put(`gbp-posts/${postId}`, updateBody2(options))));
+  gbp.command("regenerate").description("Write an existing GBP post again, on the request it already carries").argument("<ID>", "GBP post id", integer).action(async (postId) => {
+    const res = await cli.client().post(`gbp-posts/${postId}/regenerate`);
+    cli.billed(1);
+    err(`Poll with ${cli.follow(`gbp watch ${postId}`, `gbp get ${postId}`)}`);
+    out(res);
+  });
+  gbp.command("delete").description("Delete a GBP post permanently").argument("<ID>", "GBP post id", integer).option("--yes", "Confirm the deletion").action(async (postId, options) => {
+    if (!options.yes)
+      throw new Error("deleting a GBP post is permanent, re-run with --yes to confirm");
+    out(await cli.client().delete(`gbp-posts/${postId}`));
+  });
+}
+
+// src/commands/images.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename4 } from "node:path";
+var FILE_TYPES = ["image", "csv"];
+var MAX_CACHED_JOBS = 50;
+function loadJobCache() {
+  try {
+    return JSON.parse(readFileSync3(imageJobsPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function cacheJob(key, job) {
+  const cache = loadJobCache();
+  cache[key] = job;
+  const keys = Object.keys(cache);
+  for (const stale of keys.slice(0, Math.max(0, keys.length - MAX_CACHED_JOBS)))
+    delete cache[stale];
+  mkdirSync2(configDir(), { recursive: true, mode: 448 });
+  writeFileSync3(imageJobsPath(), JSON.stringify(cache, null, 2));
+}
+function keepJob(key, job) {
+  try {
+    cacheJob(key, job);
+  } catch (error) {
+    err(`could not keep the job in the local cache (${error instanceof Error ? error.message : String(error)}), the server will not show it again`);
+  }
+}
+async function fetchStatus(client, articleId, jobId, cached = true) {
+  const key = `${articleId}:${jobId}`;
+  const hit = cached ? loadJobCache()[key] : undefined;
+  if (hit) {
+    err("served from local cache, the server forgets jobs after the first terminal read");
+    return hit;
+  }
+  const job = await client.get(`content-writing/article/${articleId}/edit-feat-image/status/${jobId}`);
+  if (cached && job.status !== "pending")
+    keepJob(key, job);
+  return job;
+}
+function registerImages(program, cli) {
+  const images = program.command("images").description("Manage featured image edit jobs");
+  images.command("edit").description("Start a featured image edit job (async, costs real money)").argument("<ARTICLE-ID>", "Article id", integer).requiredOption("--image-url <url>", "URL of the image to edit").requiredOption("--instruction <text>", "Edit instruction").action(async (articleId, options) => {
+    const res = await cli.client().post(`content-writing/article/${articleId}/edit-feat-image`, { image_url: options.imageUrl, instruction: options.instruction });
+    cli.billed(1);
+    err(`Edit job submitted (costs real money). Poll with ${cli.follow(`images watch ${articleId} ${res.job_id}`, `images status ${articleId} ${res.job_id}`)}, the job expires after 1h`);
+    out(res);
+  });
+  images.command("status").description(cli.mount ? "Check an edit job. The server forgets a finished job after the first read that shows it, so keep what this prints" : "Check an edit job (terminal results are cached locally so re-polls never 404)").argument("<ARTICLE-ID>", "Article id", integer).argument("<JOB-ID>", "Edit job id").action(async (articleId, jobId) => {
+    const job = await fetchStatus(cli.client(), articleId, jobId, !cli.mount);
+    if (cli.mount && job.status !== "pending")
+      err("This was the only read of the finished job, the server has now forgotten it, so keep this output");
+    out(job);
+  });
+  if (!cli.mount) {
+    images.command("watch").description("Poll an edit job until it is done or failed").argument("<ARTICLE-ID>", "Article id", integer).argument("<JOB-ID>", "Edit job id").option("--interval <seconds>", "Seconds between polls", decimal, 3).option("--timeout <seconds>", "Give up after this many seconds", decimal).action(async (articleId, jobId, options) => {
+      const client = cli.client();
+      const job = await watchLoop({
+        interval: options.interval,
+        timeout: options.timeout,
+        poll: () => fetchStatus(client, articleId, jobId),
+        progress: (item) => `[${isoNow()}] status=${item.status}`,
+        done: (item) => item.status !== "pending",
+        timedOut: () => `timed out after ${fmtNum(options.timeout)}s, job ${jobId} still pending`
+      });
+      out(job);
+      if (job.status === "failed")
+        throw new Exit(1);
+    });
+  }
+  images.command("commit").description("Persist an edited image as the article's featured image (arbitrary URLs go through `articles update --feat-image`)").argument("<ARTICLE-ID>", "Article id", integer).requiredOption("--image-url <url>", "Image URL from a done edit job in the last 24h").action(async (articleId, options) => {
+    out(await cli.client().post(`content-writing/article/${articleId}/commit-feat-image`, { image_url: options.imageUrl }));
+  });
+}
+function registerUpload(program, cli) {
+  program.command("upload").description("Upload a file to the CDN").argument("<FILE>", "The file to upload").requiredOption("--type <type>", "File type: image or csv").action(async (file, options) => {
+    if (!FILE_TYPES.includes(options.type))
+      throw new Error(`invalid type '${options.type}', valid values: ${FILE_TYPES.join(", ")}`);
+    const content = readBytes(file);
+    if (!basename4(file).includes("."))
+      throw new Error("file needs an extension, the CDN key is derived from it");
+    out(await cli.client().postForm("upload/", new Blob([content]), basename4(file), { file_type: options.type }));
+  });
+}
+
+// src/commands/landing-pages.ts
+import { basename as basename5 } from "node:path";
+import { Option } from "commander";
+var isTerminal3 = (page) => page.status === "success" || page.status === "failed";
+var evalOf = (page) => ("eval_status" in page ? page.eval_status : null) ?? "null";
+var progress = (page) => `[${isoNow()}] status=${page.status} eval=${evalOf(page)}`;
+var criteriaOf = (page) => ("eval_report" in page ? page.eval_report?.reader_criteria : null) ?? {};
+function followPage(client, lpId) {
+  return watchLoop({
+    interval: 10,
+    timeout: 900,
+    poll: () => client.get(`landing-pages/${lpId}`),
+    progress,
+    done: isTerminal3,
+    timedOut: (page) => `timed out, landing page ${lpId} still ${page.status}`
+  });
+}
+async function writeBody3(client, options) {
+  const guide = either(options.writingGuide, options.writingGuideFile, "--writing-guide or --writing-guide-file");
+  const brief = either(options.brief, options.briefFile, "--brief or --brief-file");
+  const body = { company_profile_id: options.profileId, keyword: options.keyword, deliverable: wireDeliverable(options.deliverable) };
+  if (brief)
+    body.page_brief = brief;
+  if (options.ctaLabel)
+    body.cta_label = options.ctaLabel;
+  if (options.ctaUrl)
+    body.cta_url = options.ctaUrl;
+  if (options.secondaryKeywords) {
+    const keywords = splitCsv(options.secondaryKeywords);
+    if (keywords.length > 2)
+      throw new Error(`secondary keywords max out at 2, got ${keywords.length}`);
+    body.secondary_keywords = keywords;
+  }
+  const intent = { who: options.intentWho, want: options.intentWant, achieve: options.intentAchieve };
+  if (Object.values(intent).some(Boolean)) {
+    if (!Object.values(intent).every(Boolean))
+      throw new Error("pass all three of --intent-who, --intent-want, --intent-achieve or none");
+    body.intent = intent;
+  }
+  if (options.brandFacts)
+    body.brand_facts = options.brandFacts;
+  if (guide)
+    body.writing_guide = guide;
+  if (options.imageUrls)
+    body.image_urls = splitCsv(options.imageUrls);
+  body.generate_images = options.images !== false;
+  if (options.allowedTerms)
+    body.allowed_terms = splitCsv(options.allowedTerms);
+  if (options.goldenUrl)
+    body.golden_url = options.goldenUrl;
+  if (options.socialProof)
+    body.social_proof = { text: options.socialProof, rating: options.socialProofRating ?? null };
+  else if (options.socialProofRating !== undefined)
+    throw new Error("--social-proof-rating needs --social-proof: a rating with no claim beside it is meaningless");
+  if (options.designZip && options.designZipUrl)
+    throw new Error("pass either --design-zip or --design-zip-url, not both");
+  if (options.designZip) {
+    const zip = new Blob([readBytes(options.designZip)], { type: "application/zip" });
+    const stored = await client.postForm("landing-pages/design-zips", zip, basename5(options.designZip));
+    body.design_zip_key = stored.design_zip_key;
+    body.design_zip_name = stored.design_zip_name;
+  } else if (options.designZipUrl) {
+    body.design_zip_url = options.designZipUrl;
+  }
+  return body;
+}
+function updateBody3(options) {
+  const payload = {};
+  if (options.slug)
+    payload.slug = options.slug;
+  if (options.titleTag)
+    payload.title_tag = options.titleTag;
+  if (options.metaDescription)
+    payload.meta_description = options.metaDescription;
+  if (options.h1)
+    payload.h1 = options.h1;
+  if (options.ctaLabel)
+    payload.cta_label = options.ctaLabel;
+  if (options.ctaUrl)
+    payload.cta_url = options.ctaUrl;
+  if (options.copyFile)
+    payload.copy_payload = JSON.parse(readText(options.copyFile));
+  if (Object.keys(payload).length === 0) {
+    throw new Error("nothing to update, pass at least one of --slug, --title-tag, --meta-description, --h1, --cta-label, --cta-url, --copy-file");
+  }
+  return payload;
+}
+function auditWatch(client, path, params, options, still) {
+  return watchLoop({
+    interval: options.interval,
+    timeout: options.timeout,
+    poll: () => client.get(path, params),
+    progress: (audit) => `[${isoNow()}] pages still ${still}: ${audit.landing_pages.length}`,
+    done: (audit) => audit.landing_pages.length === 0,
+    timedOut: (audit) => `timed out after ${fmtNum(options.timeout)}s, ${audit.landing_pages.length} page(s) still ${still}`
+  });
+}
+function writeText(text, output, lpId) {
+  if (!output) {
+    write(text);
+    return;
+  }
+  writeFile(output, text);
+  err(`exported landing page ${lpId} to ${output}`);
+}
+function registerLandingPages(program, cli) {
+  const landing = program.command("landing-pages").description("Manage BOFU SEO landing pages");
+  landing.command("write").description("Queue a landing page for generation (async, costs real money per page)").requiredOption("--profile-id <id>", "Company profile id", integer).requiredOption("--keyword <keyword>", "The purchase intent keyword this page targets").option("--brief <text>", "What this page should do, in your own words. The angle, a section it must carry, a client correction that outranks their live site").option("--brief-file <path>", "Read the page brief from a file").option("--deliverable <deliverable>", "copy (a copy deck, the default) | page (also build and host the web page)", "copy").option("--cta-label <label>", "Call to action button label. Left out, the engine writes one from the keyword and the ICP").option("--cta-url <url>", "Call to action destination URL").option("--secondary-keywords <keywords>", "Comma separated secondary keywords (max 2)").option("--intent-who <text>", "Who is searching this keyword (skips the intent LLM step when all three intent flags are set)").option("--intent-want <text>", "What the searcher wants").option("--intent-achieve <text>", "What the searcher is trying to achieve").option("--brand-facts <text>", "Verified brand facts the writer may state").option("--writing-guide <text>", "Brand writing guide (source of truth over generic style rules)").option("--writing-guide-file <path>", "Read the writing guide from a file").option("--image-urls <urls>", "Comma separated image URLs, taking the slots in order. Each is rehosted to the CDN. Remaining slots are filled from the client's design system and their own site").option("--images", "Has no effect: the Worker never generates a landing page image. Kept so older scripts still run").option("--no-images", "Has no effect, see --images").option("--design-zip <path>", "The client's design system zip, for this page only. Stored privately, then the page renders in it. The profile's own design system is used when this is left out").option("--design-zip-url <url>", "An https link the worker downloads the design system zip from").option("--allowed-terms <terms>", "Comma separated banned-list exceptions for this page").option("--golden-url <url>", "URL of a golden reference page for the judge").option("--social-proof <text>", "A real proof line beside the hero CTA, e.g. 'trusted by 400 contractors'").option("--social-proof-rating <rating>", "A real average rating, 1 to 5. Stars render only when this is given", between(1, 5)).addOption(new Option("--page-type <type>", "Has no effect: the Worker chooses the layout. Kept so older scripts still run").hideHelp()).action(async (options) => {
+    if (options.pageType)
+      err("--page-type has no effect, the Worker chooses the layout");
+    const client = cli.client();
+    const res = await client.post("landing-pages/", await writeBody3(client, options));
+    cli.billed(1);
+    err(`Generation is asynchronous and spends real money (LLM, SERP). Poll with ${cli.follow(`landing-pages watch ${res.landing_page_id}`, `landing-pages get ${res.landing_page_id}`)}`);
+    out(res);
+  });
+  landing.command("research").description("Show the SERP research a page's FAQs were chosen from").argument("<ID>", "Landing page id", integer).option("--json", "Emit the raw pool instead of the summary").action(async (lpId, options) => {
+    const page = await cli.client().get(`landing-pages/${lpId}`);
+    const pool = "research_pool" in page ? page.research_pool : null;
+    if (!pool || Object.keys(pool).length === 0) {
+      err(`Landing page ${lpId} carries no research (generated before research was stored, or the SERP pull failed)`);
+      return;
+    }
+    if (options.json) {
+      out(pool);
+      return;
+    }
+    const spend = pool.spend ?? {};
+    err(`keyword: ${pool.keyword}  ·  ${pool.questions?.length ?? 0} questions from ${pool.seeds?.length ?? 0} seed searches  ·  pulled ${pool.fetched_at}`);
+    err(`spend: ${spend.calls ?? 0} billed, ${spend.cached ?? 0} cached, ${spend.skipped ?? 0} skipped, ${spend.failed ?? 0} failed${pool.degraded ? "  (DEGRADED)" : ""}`);
+    for (const question of pool.questions ?? []) {
+      const freq = question.freq ?? 1;
+      line(`  ${freq > 1 ? `x${freq}` : "  "}  ${question.q}`);
+    }
+  });
+  landing.command("get").description("Show one landing page (slim {landing_page_id, status} shape until it completes)").argument("<ID>", "Landing page id", integer).action(async (lpId) => out(await cli.client().get(`landing-pages/${lpId}`)));
+  landing.command("list").description("List landing pages, newest first").option("--page <page>", "Page number", integer, 1).option("--limit <limit>", "Page size (max 100)", integer, 10).option("--company <name>", "Filter by exact company name").option("--status <status>", "Filter by status: pending, success, failed").action(async (options) => {
+    const status = wireLandingStatus(options.status);
+    out(await cli.client().get("landing-pages/", { page: options.page, limit: options.limit, company_name: options.company, status }));
+  });
+  if (!cli.mount) {
+    landing.command("watch").description("Poll a landing page until generation is terminal (success or failed)").argument("<ID>", "Landing page id", integer).option("--interval <seconds>", "Seconds between polls", decimal, 10).option("--timeout <seconds>", "Give up after this many seconds", decimal).action(async (lpId, options) => {
+      const client = cli.client();
+      const page = await watchLoop({
+        interval: options.interval,
+        timeout: options.timeout,
+        poll: () => client.get(`landing-pages/${lpId}`),
+        progress,
+        done: isTerminal3,
+        timedOut: (item) => `timed out after ${fmtNum(options.timeout)}s, landing page ${lpId} still ${item.status}`
+      });
+      out(page);
+      if (page.status === "failed")
+        throw new Exit(1);
+    });
+  }
+  landing.command("update").description("Update copy fields and re-render the HTML in place (409 while still generating)").argument("<ID>", "Landing page id", integer).option("--slug <slug>", "New slug").option("--title-tag <text>", "New title tag").option("--meta-description <text>", "New meta description").option("--h1 <text>", "New H1").option("--cta-label <label>", "New CTA label").option("--cta-url <url>", "New CTA URL").option("--copy-file <path>", "Replace the copy deck from a JSON file (the shape returned by export --copy)").action(async (lpId, options) => out(await cli.client().put(`landing-pages/${lpId}`, updateBody3(options))));
+  landing.command("audit").description("List completed pages whose deliverable still fails the image gate or carries placeholder markers").option("--checks <checks>", "Comma separated subset of: images, placeholders", "images,placeholders").option("--limit <limit>", "How many completed pages to scan", integer, 100).action(async (options) => out(await cli.client().get("landing-pages/audit", { checks: options.checks, limit: options.limit })));
+  const fixPlaceholders = landing.command("fix-placeholders").description("Strip unresolved placeholder markers from completed pages and re-render them (deterministic, no LLM, no spend)").option("--dry-run", "Only list the pages carrying placeholder markers, change nothing");
+  if (!cli.mount) {
+    fixPlaceholders.option("--watch", "After fixing, poll the audit until it comes back clean").option("--interval <seconds>", "Seconds between audit polls with --watch", decimal, 15).option("--timeout <seconds>", "Give up polling after this many seconds with --watch", decimal, 300);
+  }
+  fixPlaceholders.action(async (options) => {
+    const client = cli.client();
+    const params = { checks: "placeholders", limit: 100 };
+    const audit = await client.get("landing-pages/audit", params);
+    if (audit.landing_pages.length === 0) {
+      err("All completed landing pages are free of placeholder markers. Nothing to fix.");
+      out(audit);
+      return;
+    }
+    err(`${audit.landing_pages.length} landing page(s) carry unresolved placeholder markers:`);
+    for (const item of audit.landing_pages)
+      err(`  #${item.landing_page_id} [${item.company_name}] ${item.keyword} (${item.placeholder_failures.length} marker(s))`);
+    if (options.dryRun) {
+      out(audit);
+      return;
+    }
+    const fixed = [];
+    for (const item of audit.landing_pages) {
+      const res = await client.post(`landing-pages/${item.landing_page_id}/fix-placeholders`);
+      fixed.push(res);
+      err(`cleaned #${item.landing_page_id}: ${res.removed?.length ?? 0} unit(s) rewritten or dropped`);
+    }
+    if (!options.watch) {
+      out({ fixed });
+      return;
+    }
+    out(await auditWatch(client, "landing-pages/audit", params, options, "carrying markers"));
+  });
+  landing.command("rebrand").description("Re-render completed pages in their company's current brand (deterministic, no LLM, no spend)").argument("[ID]", "One landing page. Omit and pass --company to do a whole company", integer).option("--company <name>", "Rebrand every completed page for this exact company name").option("--limit <limit>", "Page size when listing a company's pages", integer, 100).option("--dry-run", "List what would be re-rendered, change nothing").action(async (lpId, options) => {
+    if (lpId === undefined && !options.company) {
+      err("Pass a landing page ID or --company.");
+      throw new Exit(1);
+    }
+    const client = cli.client();
+    let targets;
+    if (lpId !== undefined) {
+      targets = [{ landing_page_id: lpId, keyword: "", company_name: options.company ?? "" }];
+    } else {
+      const listing = await client.get("landing-pages/", { page: 1, limit: options.limit, company_name: options.company, status: "success" });
+      targets = listing.landing_pages.filter((page) => page.status === "success").map((page) => ({ landing_page_id: page.landing_page_id, keyword: page.keyword ?? "", company_name: options.company }));
+      if (targets.length === 0) {
+        err(`No completed landing pages found for '${options.company}'.`);
+        throw new Exit(1);
+      }
+      err(`${targets.length} completed page(s) for ${options.company}:`);
+      for (const item of targets)
+        err(`  #${item.landing_page_id} ${item.keyword}`);
+    }
+    if (options.dryRun) {
+      out({ would_rebrand: targets });
+      return;
+    }
+    const rebranded = [];
+    for (const item of targets) {
+      const res = await client.post(`landing-pages/${item.landing_page_id}/rebrand`);
+      rebranded.push(res);
+      err(`#${item.landing_page_id}: ${res.msg}`);
+    }
+    out({ rebranded });
+  });
+  const fixImages = landing.command("fix-images").description("Find completed pages whose images fail the CDN gate and queue real image regeneration for each (spends real money per page)").option("--dry-run", "Only list the pages with placeholder or non CDN images, queue nothing");
+  if (!cli.mount) {
+    fixImages.option("--watch", "After queueing, poll the audit until it comes back clean").option("--interval <seconds>", "Seconds between audit polls with --watch", decimal, 30).option("--timeout <seconds>", "Give up polling after this many seconds with --watch", decimal, 900);
+  }
+  fixImages.action(async (options) => {
+    const client = cli.client();
+    const params = { limit: 100 };
+    const audit = await client.get("landing-pages/image-audit", params);
+    if (audit.landing_pages.length === 0) {
+      err("All completed landing pages pass the image gate. Nothing to fix.");
+      out(audit);
+      return;
+    }
+    err(`${audit.landing_pages.length} landing page(s) contain placeholder or non CDN images:`);
+    for (const item of audit.landing_pages)
+      err(`  #${item.landing_page_id} [${item.company_name}] ${item.keyword} (${item.image_failures.length} failure(s))`);
+    if (options.dryRun) {
+      out(audit);
+      return;
+    }
+    const queued = [];
+    try {
+      for (const item of audit.landing_pages) {
+        queued.push(await client.post(`landing-pages/${item.landing_page_id}/regenerate-images`));
+        err(`queued image regeneration for #${item.landing_page_id}`);
+      }
+    } finally {
+      cli.billed(queued.length);
+    }
+    if (!options.watch) {
+      out({ queued });
+      return;
+    }
+    out(await auditWatch(client, "landing-pages/image-audit", params, options, "failing the image gate"));
+  });
+  landing.command("delete").description("Delete a landing page permanently").argument("<ID>", "Landing page id", integer).option("--yes", "Confirm the deletion").action(async (lpId, options) => {
+    if (!options.yes)
+      throw new Error("deleting a landing page is permanent, re-run with --yes to confirm");
+    out(await cli.client().delete(`landing-pages/${lpId}`));
+  });
+  landing.command("export").description("Export a completed landing page as a copy deck, as HTML, or as its JSON copy deck").argument("<ID>", "Landing page id", integer).option("--deck", "Export the copy deck as markdown, the shape that goes into the Google Doc").option("--html", "Export the rendered standalone HTML with CDN image URLs (page deliverable only; refused while the page still has placeholder images or placeholder markers in the copy)").option("--copy", "Export the structured copy deck as JSON").option("--allow-placeholders", "Export even when the page still contains placeholder images or unresolved placeholder markers").option("--inline", "Inline every image as a base64 data URI for a fully self contained file").option("-o, --output <path>", "Write to a file instead of stdout").action(async (lpId, options) => {
+    if ([options.deck, options.html, options.copy].filter(Boolean).length !== 1)
+      throw new Error("pass exactly one of --deck, --html or --copy");
+    const client = cli.client();
+    if (options.deck || options.html) {
+      const text = await client.getText(`landing-pages/${lpId}/export`, {
+        format: options.deck ? "deck_md" : "html",
+        allow_placeholders: options.allowPlaceholders ? "true" : undefined,
+        inline: options.inline ? "true" : undefined
+      });
+      writeText(text, options.output, lpId);
+      return;
+    }
+    const page = await client.get(`landing-pages/${lpId}`);
+    if (page.status !== "success" || !("copy_payload" in page))
+      throw new Error(`landing page ${lpId} is still ${page.status}, nothing to export yet`);
+    writeText(JSON.stringify(page.copy_payload, null, 2), options.output, lpId);
+  });
+  const reiterate = landing.command("reiterate").summary("Check a page against what a buyer needs to see, and fix what a source can carry").description(`Check a page against what a buyer needs to see, and fix what a source can carry
+
+` + "The second half of the SOP. Ask in a SEPARATE chat, as the customer who typed this keyword and who knows nothing about this company, " + `what would have to be on the page for them to believe it. Pass that answer here and it wins over a generated one.
+
+` + "Anything the checklist asks for that no source supports is not written around: it lands in missing_facts as something to get from the client.").argument("<ID>", "Landing page id", integer).option("--criteria <text>", "What a buyer told you they need to see, in their words").option("--criteria-file <path>", "Read that answer from a file").option("--rescore", "Also pay the reviewer to score the page again afterwards");
+  if (!cli.mount)
+    reiterate.option("--watch", "Follow until the page is saved");
+  reiterate.action(async (lpId, options) => {
+    const text = either(options.criteria, options.criteriaFile, "--criteria or --criteria-file");
+    const body = { rescore: Boolean(options.rescore) };
+    if (text)
+      body.criteria_text = text;
+    const client = cli.client();
+    const res = await client.post(`landing-pages/${lpId}/re-iterate`, body);
+    cli.billed(1);
+    err(`Using ${res.criteria_source} criteria. This costs a couple of model calls and one writer pass.`);
+    if (!options.watch) {
+      out(res);
+      return;
+    }
+    const final = await followPage(client, lpId);
+    const report = criteriaOf(final);
+    if (report.total)
+      err(`${report.met ?? 0} of ${report.total} criteria met`);
+    if (report.research?.added?.length)
+      err(`  found ${report.research.added.length} new source(s) for the writer to cite`);
+    for (const gap of report.unmet_unsupported ?? [])
+      err(`  needs the client: ${gap}`);
+    out(final);
+  });
+  landing.command("criteria").summary("The buyer's checklist for a page, and setting a line aside").description(`The buyer's checklist for a page, and setting a line aside
+
+` + "With no option, prints every line with its status. A set aside line stops counting: it leaves the score, the writer's brief, the client asks and the pass decision. " + "It never leaves the list. Free, synchronous, no model.").argument("<ID>", "Landing page id", integer).option("--set-aside <criterion>", "Set this line aside as not needed (r1, r2, ...)").option("--restore <criterion>", "Bring a set aside line back").option("--reason <text>", "Why it is not needed, shown beside the line", "").action(async (lpId, options) => {
+    if (options.setAside && options.restore)
+      throw new Error("pass either --set-aside or --restore, not both");
+    const client = cli.client();
+    const criterion = options.setAside ?? options.restore;
+    if (criterion) {
+      const res = await client.patch(`landing-pages/${lpId}/criteria/${encodeURIComponent(criterion)}`, { dismissed: Boolean(options.setAside), reason: options.reason || null });
+      err(`${res.msg}. Now ${res.met} of ${res.total}, page ${res.eval_status}.`);
+      out(res);
+      return;
+    }
+    const report = criteriaOf(await client.get(`landing-pages/${lpId}`));
+    if (!report.criteria?.length)
+      throw new Error(`landing page ${lpId} has no buyer checklist yet`);
+    const verdicts = new Map((report.coverage ?? []).map((verdict) => [verdict.id, verdict]));
+    const aside = new Set(report.dismissed_ids ?? []);
+    err(`${report.met ?? 0} of ${report.total ?? 0} met, ${aside.size} set aside`);
+    for (const item of report.criteria) {
+      const mark = aside.has(item.id) ? "set aside" : verdicts.get(item.id)?.status || "missing";
+      const flag = item.deal_breaker && mark !== "met" && mark !== "set aside" ? " (they would leave without this)" : "";
+      err(`  [${item.id}] ${mark}: ${item.need}${flag}`);
+    }
+    out(report);
+  });
+  landing.command("versions").description("Every take on this keyword, oldest first").argument("<ID>", "Landing page id", integer).action(async (lpId) => out(await cli.client().get(`landing-pages/${lpId}/versions`)));
+  const newVersion = landing.command("new-version").summary("Write another version of a page, inheriting everything the first run was given").description(`Write another version of a page, inheriting everything the first run was given
+
+` + "Costs what a normal run costs, because it is one. Send only what should change.").argument("<ID>", "Landing page id", integer).option("--brief <text>", "A different angle. Everything else is inherited").option("--brief-file <path>", "Read the brief from a file").option("--keyword <keyword>", "A different search phrase").option("--criteria-file <path>", "A buyer's checklist to build to from the start");
+  if (!cli.mount)
+    newVersion.option("--watch", "Follow until the new version is saved");
+  newVersion.action(async (lpId, options) => {
+    const brief = either(options.brief, options.briefFile, "--brief or --brief-file");
+    const body = {};
+    if (brief)
+      body.page_brief = brief;
+    if (options.keyword)
+      body.keyword = options.keyword;
+    if (options.criteriaFile)
+      body.reader_criteria = readText(options.criteriaFile);
+    const client = cli.client();
+    const res = await client.post(`landing-pages/${lpId}/versions`, body);
+    cli.billed(1);
+    err(`Version ${res.version} queued as landing page ${res.landing_page_id}. This spends real money.`);
+    out(options.watch ? await followPage(client, res.landing_page_id) : res);
+  });
+  landing.command("deck").summary("The copy deck as markdown, in the house Google Doc template").description(`The copy deck as markdown, in the house Google Doc template
+
+` + "The same document `export --deck` builds, so what you paste and what you download are the same thing. " + "Paste it into Drive as text/markdown and it becomes a Google Doc.").argument("<ID>", "Landing page id", integer).option("-o, --output <path>", "Write it to a file instead of stdout").action(async (lpId, options) => {
+    const text = await cli.client().getText(`landing-pages/${lpId}/deck`);
+    if (!options.output) {
+      line(text);
+      return;
+    }
+    writeFile(options.output, text);
+    err(`Wrote ${options.output}`);
+  });
+}
+
+// src/commands/profiles.ts
+import { basename as basename6, extname } from "node:path";
+var stripScheme = (url) => url.replace(/^https?:\/\//i, "");
+var flagOf = (field) => `--${field.replaceAll("_", "-")}`;
+var optionKeyOf = (field) => field.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+var sectionLabel = (field) => `${field.charAt(0).toUpperCase()}${field.slice(1).replaceAll("_", " ")} section`;
+async function findProfile(client, profileId) {
+  const profile = (await client.get("company-profile/")).find((item) => item.id === profileId);
+  if (!profile)
+    throw new Error(`profile ${profileId} not found, run \`ve-dynamite profiles list\``);
+  return profile;
+}
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function parseIcp(icp) {
+  let sections;
+  try {
+    sections = JSON.parse(icp);
+  } catch {
+    return null;
+  }
+  if (sections === null || typeof sections !== "object" || Array.isArray(sections))
+    return null;
+  return Object.fromEntries(Object.entries(sections).map(([key, value]) => [key, typeof value === "string" ? parseJson(value) : value]));
+}
+function profileBody(options) {
+  const body = {};
+  if (options.name)
+    body.name = options.name;
+  if (options.website)
+    body.website_url = stripScheme(options.website);
+  if (options.sitemap)
+    body.sitemap_url = stripScheme(options.sitemap);
+  if (options.writingGuide)
+    body.writing_guide = options.writingGuide;
+  return body;
+}
+function registerProfiles(program, cli) {
+  const profiles = program.command("profiles").description("Manage company profiles");
+  profiles.command("create").description("Create a company profile (also starts async ICP generation, which costs money)").requiredOption("--name <name>", "Company name").requiredOption("--website <host>", "Company website, bare host like example.com (scheme is stripped)").option("--sitemap <host>", "Sitemap URL, bare host form").option("--writing-guide <text>", "Writing style guide").action(async (options) => {
+    const res = await cli.client().post("company-profile/create", profileBody(options));
+    cli.billed(1);
+    err("ICP generation started in the background, check progress with `ve-dynamite icp show <id>`");
+    out(res);
+  });
+  profiles.command("list").description("List all company profiles").action(async () => out(await cli.client().get("company-profile/")));
+  profiles.command("get").description("Show one company profile").argument("<ID>", "Company profile id", integer).action(async (profileId) => out(await findProfile(cli.client(), profileId)));
+  profiles.command("update").description("Update profile fields (only the flags you pass are changed)").argument("<ID>", "Company profile id", integer).option("--name <name>", "New company name").option("--website <host>", "New website, bare host form (scheme is stripped)").option("--sitemap <host>", "New sitemap URL").option("--writing-guide <text>", "New writing style guide").action(async (profileId, options) => {
+    const body = profileBody(options);
+    if (Object.keys(body).length === 0)
+      throw new Error("nothing to update, pass at least one of --name, --website, --sitemap, --writing-guide");
+    out(await cli.client().put(`company-profile/${profileId}`, body));
+  });
+  profiles.command("delete").description("Delete a profile and everything under it (articles, ICP, categories)").argument("<ID>", "Company profile id", integer).option("--yes", "Confirm the deletion").action(async (profileId, options) => {
+    if (!options.yes)
+      throw new Error("deleting a profile also deletes its articles, re-run with --yes to confirm");
+    out(await cli.client().delete(`company-profile/${profileId}`));
+  });
+  const icp = program.command("icp").description("Manage a profile's ICP (ideal customer profile)");
+  icp.command("show").description("Show the ICP, or its generation status when not ready").argument("<PROFILE-ID>", "Company profile id", integer).action(async (profileId) => {
+    const profile = await findProfile(cli.client(), profileId);
+    const parsed = parseIcp(profile.icp);
+    out(parsed && Object.keys(parsed).length > 0 ? parsed : { status: profile.icp });
+  });
+  documentOutput(icp.command("export").description("Download a profile's ICP as a document (docx imports straight into Google Docs)").argument("<PROFILE-ID>", "Company profile id", integer).option("--format <format>", "docx (opens in Google Docs) or md", "docx"), cli).action(async (profileId, options) => {
+    const target = await downloadDocument(cli, `company-profile/${profileId}/icp/export`, options.format, options.output, `company-${profileId}-icp`);
+    err(`exported the ICP for profile ${profileId} to ${target}`);
+  });
+  icp.command("regenerate").description("Regenerate the ICP from the website (async, costs money)").argument("<PROFILE-ID>", "Company profile id", integer).action(async (profileId) => {
+    const res = await cli.client().post(`company-profile/${profileId}/regenerate-icp`);
+    cli.billed(1);
+    err("ICP regeneration started in the background, check progress with `ve-dynamite icp show <id>`");
+    out(res);
+  });
+  const updateIcp = icp.command("update").description("Edit ICP sections directly (only the flags you pass are changed)").argument("<PROFILE-ID>", "Company profile id", integer);
+  for (const section of ICP_SECTIONS)
+    updateIcp.option(`${flagOf(section)} <text>`, sectionLabel(section));
+  updateIcp.action(async (profileId, options) => {
+    const body = Object.fromEntries(ICP_SECTIONS.flatMap((section) => options[optionKeyOf(section)] === undefined ? [] : [[section, options[optionKeyOf(section)]]]));
+    if (Object.keys(body).length === 0)
+      throw new Error(`nothing to update, pass at least one of ${ICP_SECTIONS.map(flagOf).join(", ")}`);
+    out(await cli.client().put(`company-profile/${profileId}/icp`, body));
+  });
+  const categories = program.command("categories").description("Manage a profile's article categories");
+  categories.command("list").description("List categories with article counts").argument("<PROFILE-ID>", "Company profile id", integer).action(async (profileId) => out(await cli.client().get(`company-profile/${profileId}/categories`)));
+  categories.command("add").description("Add one or more categories (no commas in names)").argument("<PROFILE-ID>", "Company profile id", integer).argument("<NAMES...>", "Category names").action(async (profileId, names) => out(await cli.client().post(`company-profile/${profileId}/categories`, { categories: names })));
+  const design = program.command("design-system").description("The client's own design system: the colours, type and photography every page for them renders in");
+  design.command("show").description("Show the stored design system: its tokens and every image with the alt written for it").argument("<PROFILE-ID>", "Company profile id", integer).action(async (profileId) => out(await cli.client().get(`company-profile/${profileId}/design-system`)));
+  design.command("set").description("Upload a design system zip and read it (private storage, one mapping call, one vision call per image)").argument("<PROFILE-ID>", "Company profile id", integer).argument("<ZIP>", "The design system zip the client's designer exported").action(async (profileId, zipPath) => {
+    if (extname(zipPath).toLowerCase() !== ".zip")
+      throw new Error("a design system is uploaded as a zip archive");
+    const zip = new Blob([readBytes(zipPath)], { type: "application/zip" });
+    err("Reading the zip: publishing its fonts and images, mapping its tokens and describing each image. This takes a moment and spends a little.");
+    const res = await cli.client().postForm(`company-profile/${profileId}/design-system`, zip, basename6(zipPath));
+    cli.billed(1);
+    out(res);
+  });
+  design.command("rescan").description("Re-read the stored zip, for when the token mapping or an image description was wrong").argument("<PROFILE-ID>", "Company profile id", integer).action(async (profileId) => {
+    const res = await cli.client().post(`company-profile/${profileId}/design-system/rescan`);
+    cli.billed(1);
+    out(res);
+  });
+  design.command("clear").description("Remove the design system. Later pages fall back to the brand kit scraped from the client's site").argument("<PROFILE-ID>", "Company profile id", integer).action(async (profileId) => out(await cli.client().delete(`company-profile/${profileId}/design-system`)));
+}
+
+// src/commands/revisions.ts
+import { Option as Option2 } from "commander";
+var REJECT_HELP = [
+  "Reject one part of a finished article because a writer called it bad, and have it made again. Asynchronous and spends real money: the writer model, plus fal for an image or the renderer for a video.",
+  "--index is required for a section or an image, optional for the FAQ and ignored otherwise. `ve-dynamite articles parts <id>` lists the indexes.",
+  "For a section, --target picks what to remake: section (the default, the whole section), heading (only the ## line, the text under it stays) or passage (only --text, which must be copied character for character from the article's body markdown, appear once in that section and hold whole links and images).",
+  "For the intro, leave --target out to remake all of it, or use passage with --text copied the same way from the intro.",
+  "For the FAQ, leave --index out to remake all of it. With an item's index, --target picks answer (the default, the question stays), question (only the question) or passage (--text copied from that item's answer in the FAQ HTML, holding whole tags).",
+  "--reason is the writer's own words about what is wrong. It briefs the rebuild, so pass it verbatim. The article is not changed: the replacement waits beside the refused part until a verdict."
+].join(`
+
+`);
+var VERDICT_HELP = [
+  "Record the writer's verdict on a ready revision: better, same or worse.",
+  "Pass only what the writer said: the verdict is the record of what a person calls bad. better puts the replacement into the article, unless the article changed since the rejection (applied comes back false). same and worse keep the original. One verdict per revision; to try again, reject the part again."
+].join(`
+
+`);
+function registerArticleRevisions(articles, cli) {
+  articles.command("parts").description("List the parts of a finished article a writer can reject, with the indexes reject takes").argument("<ID>", "Article id", integer).action(async (articleId) => out(await cli.client().get(`content-writing/article/${articleId}/parts`)));
+  articles.command("reject").summary("Reject one part of a finished article and have it remade (async, spends real money)").description(REJECT_HELP).argument("<ID>", "Article id", integer).addOption(new Option2("--part <part>", "The part the writer called bad").choices(REVISION_PARTS).makeOptionMandatory()).option("--index <n>", "Which section, image or FAQ item, counting from 0", integer).addOption(new Option2("--target <target>", "What to remake inside a section, the intro or an FAQ item").choices(REVISION_TARGETS)).option("--text <passage>", "With --target passage: the passage, copied character for character").option("--text-file <path>", "Read the passage from a file").option("--reason <text>", "The writer's own words about what is wrong").option("--reason-file <path>", "Read the reason from a file").action(async (articleId, options) => {
+    const text = either(options.text, options.textFile, "--text or --text-file");
+    const reason = either(options.reason, options.reasonFile, "--reason or --reason-file");
+    const body = { part: options.part };
+    if (options.index !== undefined)
+      body.index = options.index;
+    if (options.target)
+      body.target = options.target;
+    if (text)
+      body.text = text;
+    if (reason)
+      body.reason = reason;
+    const revision = await cli.client().post(`content-writing/article/${articleId}/revisions`, body);
+    cli.billed(1);
+    err(`The ${options.part} is being remade, which spends real money. The article stays as it is until a verdict. ` + `Poll with ${cli.follow(`revisions watch ${articleId} ${revision.revision_id}`, `revisions get ${articleId} ${revision.revision_id}`)}`);
+    out(revision);
+  });
+  articles.command("revisions").description("Every revision of one article, newest first").argument("<ID>", "Article id", integer).action(async (articleId) => out(await cli.client().get(`content-writing/article/${articleId}/revisions`)));
+}
+function registerRevisions(program, cli) {
+  const revisions = program.command("revisions").description("Parts of articles writers rejected, the replacements and the verdicts");
+  revisions.command("list").summary("List every revision you can see, newest first").description("Every revision you can see, newest first: what writers rejected and whether the replacement was better. An admin sees every account's").addOption(new Option2("--part <part>", "Only this part").choices(REVISION_PARTS)).addOption(new Option2("--target <target>", "Only this target").choices(REVISION_TARGETS)).addOption(new Option2("--status <status>", "Only this status").choices(REVISION_STATUSES)).addOption(new Option2("--verdict <verdict>", "Only this verdict").choices(REVISION_VERDICTS)).option("--profile-id <id>", "Only revisions of this company profile's articles", integer).option("--page <page>", "Page number", integer, 1).option("--limit <limit>", "Page size (max 100)", integer, 20).action(async (options) => {
+    const { page, limit, part, target, status, verdict } = options;
+    out(await cli.client().get("content-writing/revisions", { page, limit, part, target, status, verdict, company_profile_id: options.profileId }));
+  });
+  revisions.command("get").summary("Show one revision: both versions, their scores and the verdict").description("One revision: the refused part, the replacement once it is ready, the article's score with each, both score reports and the verdict").argument("<ARTICLE-ID>", "Article id", integer).argument("<REVISION-ID>", "Revision id", integer).action(async (articleId, revisionId) => out(await cli.client().get(`content-writing/article/${articleId}/revisions/${revisionId}`)));
+  if (!cli.mount) {
+    revisions.command("watch").description("Poll a revision until the replacement is ready or the remake failed").argument("<ARTICLE-ID>", "Article id", integer).argument("<REVISION-ID>", "Revision id", integer).option("--interval <seconds>", "Seconds between polls", decimal, 10).option("--timeout <seconds>", "Give up after this many seconds", decimal).action(async (articleId, revisionId, options) => {
+      const client = cli.client();
+      const revision = await watchLoop({
+        interval: options.interval,
+        timeout: options.timeout,
+        poll: () => client.get(`content-writing/article/${articleId}/revisions/${revisionId}`),
+        progress: (item) => `[${isoNow()}] status=${item.status}`,
+        done: (item) => item.status !== "pending",
+        timedOut: (item) => `timed out after ${fmtNum(options.timeout)}s, revision ${revisionId} still ${item.status}`
+      });
+      out(revision);
+      if (revision.status === "failed")
+        throw new Exit(1);
+    });
+  }
+  revisions.command("verdict").summary("Record the writer's verdict on a ready revision: better, same or worse").description(VERDICT_HELP).argument("<ARTICLE-ID>", "Article id", integer).argument("<REVISION-ID>", "Revision id", integer).addOption(new Option2("--verdict <verdict>", "The writer's verdict").choices(REVISION_VERDICTS).makeOptionMandatory()).option("--note <text>", "The writer's note on the verdict").option("--note-file <path>", "Read the note from a file").action(async (articleId, revisionId, options) => {
+    const note = either(options.note, options.noteFile, "--note or --note-file");
+    const res = await cli.client().post(`content-writing/article/${articleId}/revisions/${revisionId}/verdict`, { verdict: options.verdict, note: note ?? null });
+    err(res.msg);
+    out(res);
+  });
+}
+
+// src/commands/tokens.ts
+function registerTokens(program, cli) {
+  const tokens = program.command("tokens").description("Manage long lived API tokens for MCP and CI usage");
+  tokens.command("create").description("Create a long lived API token (the raw token is shown once, store it now)").requiredOption("--name <name>", "Token label, e.g. claude-mcp").option("--expires-days <days>", "Days until the token expires (omit for a token that never expires)", integer).action(async (options) => {
+    const body = { name: options.name };
+    if (options.expiresDays !== undefined)
+      body.expires_in_days = options.expiresDays;
+    const res = await cli.client().post("api-tokens/", body);
+    err(cli.mount ? "✓ Token created. Its token field is the only time it is shown, store it now" : `✓ Token created. This is the only time it is shown, store it now:
+
+  ${res.token}
+`);
+    out(res);
+  });
+  tokens.command("list").description("List your API tokens (masked, includes revoked ones)").action(async () => out(await cli.client().get("api-tokens/")));
+  tokens.command("revoke").description("Revoke an API token by id").argument("<ID>", "Token id", integer).action(async (tokenId) => out(await cli.client().delete(`api-tokens/${tokenId}`)));
+  if (cli.mount)
+    return;
+  tokens.command("use").description("Store a ved_ API token as the local credential (replaces the stored login)").argument("<TOKEN>", "The ved_ token").action(async (token) => {
+    if (!isPat(token))
+      throw new Error("not an API token, expected a ved_ prefix; for a password login run `ve-dynamite login`");
+    const me = await signedIn(new ApiClient(cli.baseUrl(), token), "token rejected by the API, it may be revoked or expired");
+    saveCredentials({ authToken: token, email: me.email, username: me.username, profile: me.profile, expiresAt: null });
+    err(`✓ API token for ${me.username} stored, it will be used for all commands until you run \`login\` or \`logout\``);
+  });
+}
+
+// src/commands/users.ts
+import { Option as Option3 } from "commander";
+function registerUsers(program, cli) {
+  const users = program.command("users").description("Every account in the system and its role (admins only)");
+  users.command("list").description("List accounts, newest first, with their roles").addOption(new Option3("--role <role>", "Only accounts with this role").choices(USER_ROLES)).option("--page <page>", "Page number", integer, 1).option("--limit <limit>", "Page size (max 100)", integer, 20).action(async (options) => {
+    out(await cli.client().get("users/", { page: options.page, limit: options.limit, role: options.role }));
+  });
+  users.command("set-role").description("Make another account an admin or a normal user. Nobody can change their own role, so an admin always remains").argument("<USER-ID>", "Account id", integer).addOption(new Option3("--role <role>", "The new role").choices(USER_ROLES).makeOptionMandatory()).action(async (userId, options) => {
+    const res = await cli.client().patch(`users/${userId}/role`, { role: options.role });
+    err(res.msg);
+    out(res);
+  });
+}
+
+// src/context.ts
+function cliFor(program, { mount = false, reportCost }) {
+  const flags = () => program.opts();
+  const cli = {
+    mount,
+    baseUrl: () => flags().url || defaultApiUrl(),
+    token: () => resolveToken(flags().token, !mount),
+    client: () => new ApiClient(cli.baseUrl(), cli.token().token),
+    follow: (watch, get) => `\`ve-dynamite ${mount ? get : watch}\``,
+    billed: (units) => {
+      if (units > 0)
+        reportCost?.({ provider: "contentdynamite", units });
+    }
+  };
+  return cli;
+}
+
+// src/program.ts
+function buildProgram(options = {}) {
+  const program = new Command("ve-dynamite").description("Content Dynamite — content pipeline CLI").version(VERSION, "-V, --version", "Print the version and exit").option("--token <token>", "Access token override (or set VE_DYNAMITE_TOKEN env)").addOption(new Option4("--pretty", "Has no effect: output is always indented JSON. Kept so older scripts still run").hideHelp());
+  if (!options.mount)
+    program.option("--url <url>", "API base URL (or set VE_DYNAMITE_API_URL env)");
+  program.exitOverride().configureOutput({ writeOut: (text) => io.stdout(text), writeErr: (text) => io.stderr(text) }).showHelpAfterError("(add --help for additional information)");
+  const cli = cliFor(program, options);
+  registerAuth(program, cli);
+  registerTokens(program, cli);
+  registerUsers(program, cli);
+  registerProfiles(program, cli);
+  registerArticleRevisions(registerArticles(program, cli), cli);
+  registerRevisions(program, cli);
+  registerBatches(program, cli);
+  registerGbp(program, cli);
+  registerLandingPages(program, cli);
+  registerEvals(program, cli);
+  registerImages(program, cli);
+  registerUpload(program, cli);
+  return program;
+}
+async function run(argv, options = {}) {
+  try {
+    await buildProgram(options).parseAsync(argv, { from: "user" });
+    return 0;
+  } catch (error) {
+    if (error instanceof CommanderError2)
+      return error.exitCode;
+    err(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+
+export { VERSION, buildProgram, run };