@koda-sl/baker-cli 0.524.0 → 0.526.0

package/dist/chunk-KG7FPYM2.js

@@ -0,0 +1,64 @@
+import {
+  ApiError
+} from "./chunk-B4UVJCJ4.js";
+import {
+  writeJson
+} from "./chunk-FSGJSREN.js";
+
+// src/commands/media-sources/shared.ts
+function driveRefusalFix(input, code) {
+  if (!/drive\.google\.com/i.test(input) || code !== "BAD_REQUEST") return void 0;
+  return `A Google Drive folder is never added by link \u2014 don't retry. Call request_connection with platform "google-drive" and choose "media-folder": the card lets the user pick the folder in the chat (only the Baker team can for now; anyone else is told the team will set it up). A connected result carries the new source's mediaSourceKey; if it is declined, carry on with the rest of the task.`;
+}
+function reportError(err, input) {
+  if (err instanceof ApiError) {
+    const fix = input ? driveRefusalFix(input, err.code) : void 0;
+    writeJson({ ok: false, error: { code: err.code, message: err.message, ...fix ? { fix } : {} } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+function halfState(half) {
+  if (!half) return null;
+  return {
+    status: half.syncStatus === "fetching" || half.syncStatus === "processing" ? "importing" : half.syncStatus,
+    stored: half.storedCount ?? 0,
+    ...half.pendingItems ? { pending: half.pendingItems } : {},
+    ...half.failedItems ? { failed: half.failedItems } : {},
+    ...half.lastSyncedAt ? { lastSyncedAt: new Date(half.lastSyncedAt).toISOString() } : {},
+    ...half.errorMessage ? { error: half.errorMessage } : {}
+  };
+}
+function whoLine(who) {
+  return [
+    who.kind === "person" ? "person" : "page",
+    who.role,
+    who.own ? "own" : "not own",
+    who.privateProfile ? "private profile \u2014 add posts by link" : void 0
+  ].filter(Boolean).join(" \xB7 ");
+}
+function compactSource(source) {
+  return {
+    key: source.key,
+    platform: source.platform,
+    label: source.label,
+    url: source.profileUrl,
+    ...source.who ? { who: whoLine(source.who) } : {},
+    autoSync: source.refreshInterval,
+    images: halfState(source.images),
+    videos: halfState(source.videos)
+  };
+}
+function isImporting(source) {
+  return [source.images, source.videos].some(
+    (half) => half?.syncStatus === "fetching" || half?.syncStatus === "processing"
+  );
+}
+
+export {
+  reportError,
+  compactSource,
+  isImporting
+};
+//# sourceMappingURL=chunk-KG7FPYM2.js.map

package/dist/chunk-KRQ2AXFW.js

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

package/dist/chunk-L5IYVZM2.js

@@ -0,0 +1,39 @@
+import {
+  ApiError
+} from "./chunk-B4UVJCJ4.js";
+import {
+  writeJson
+} from "./chunk-FSGJSREN.js";
+
+// src/commands/posts/shared.ts
+function reportError(err) {
+  if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+function validationError(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function nextStepHints(post) {
+  if (post.platform !== "linkedin") return [];
+  if (post.usable === "usable") {
+    return [`Boost it: \`baker ads linkedin creatives create --format tla --post ${post.id} --campaign <ad set>\`.`];
+  }
+  if (post.usable === "needs_approval") {
+    return [
+      `It can run as a Thought Leader ad once its author approves it (Campaign Manager \u2192 Thought leader ad \u2192 find the post \u2192 request permission; they can turn on auto-approval for the page). Stage it now with \`baker ads linkedin creatives create --format tla --post ${post.id} --campaign <ad set>\` \u2014 LinkedIn refuses it at publish until they have. If the user says the author already approved it, record it with \`baker posts approved ${post.id} --account-id <ad account>\` and Baker stops reminding them for that ad account.`
+    ];
+  }
+  return [];
+}
+
+export {
+  reportError,
+  validationError,
+  nextStepHints
+};
+//# sourceMappingURL=chunk-L5IYVZM2.js.map

package/dist/chunk-LHQ6GXNF.js

@@ -0,0 +1,46 @@
+import {
+  RENDER_REVIEW_MODEL,
+  askAboutImages,
+  buildRulesReviewPrompt,
+  classifyRuleFindings,
+  reviewedRules,
+  rulesSystem
+} from "./chunk-SDQLZYQG.js";
+
+// src/engine/nodes/local/lib/confirm-blocking.ts
+var cutByFrame = (f) => f.kind?.defect === "cut";
+async function confirmBlocking(findings, stills, formats, ask) {
+  const claims = findings.filter((f) => f.severity === "blocking" && !cutByFrame(f));
+  if (claims.length === 0 || stills.length === 0) return [...findings];
+  const prompt = [
+    `These are the finished sizes of one ad, in order: ${formats.map((f, i) => `Image ${i + 1} is the ${f}`).join("; ")}.`,
+    "A reviewer reported each claim below. Look again at the size each one names (and, for a claim comparing sizes, at the others) and answer true only when the defect is plainly there for someone looking at it on a phone.",
+    "Answer false when the thing is not there, when it is an ordinary part of the scene (a second house, a neighbour's roof, a reflection), or when the sizes it compares show the same thing.",
+    ...claims.map((c, i) => `${i + 1}. ${c.what}`),
+    `Reply with only this JSON: {"answers":[true|false, ...]}, one answer per claim, in order.`
+  ].join("\n");
+  const answer = await ask([...stills], prompt).catch(() => null);
+  const answers = answer?.answers;
+  if (!Array.isArray(answers) || answers.length !== claims.length) return [...findings];
+  const unconfirmed = new Set(claims.filter((_, i) => answers[i] === false));
+  return findings.map((f) => unconfirmed.has(f) ? { ...f, severity: "warning" } : f);
+}
+
+// src/engine/nodes/local/lib/rules-review.ts
+var RULES_REVIEW_TIMEOUT_MS = 12e4;
+async function reviewAgainstRules(opts) {
+  const rules = reviewedRules(opts.rules);
+  if (rules.length === 0 || opts.stills.length === 0) return [];
+  const system = rulesSystem(rules);
+  const ask = (images, prompt) => askAboutImages(RENDER_REVIEW_MODEL, images, prompt, opts.onSpend, RULES_REVIEW_TIMEOUT_MS, void 0, system);
+  const answer = await ask([...opts.stills], buildRulesReviewPrompt({ formats: opts.formats, rules }));
+  if (answer === null) return null;
+  return await confirmBlocking(classifyRuleFindings(answer, rules), opts.stills, opts.formats, ask);
+}
+
+export {
+  cutByFrame,
+  confirmBlocking,
+  reviewAgainstRules
+};
+//# sourceMappingURL=chunk-LHQ6GXNF.js.map

package/dist/chunk-LS2KEAYJ.js

@@ -0,0 +1,66 @@
+import {
+  applyFieldMask,
+  compactWinningAd,
+  fullWinningAd,
+  winningAdNormalizer,
+  writeJson
+} from "./chunk-FSGJSREN.js";
+
+// src/commands/winning-ads/adRows.ts
+var EVERY_SIGNAL = {
+  dna: {
+    visual: "-",
+    container: "-",
+    mechanism: "-",
+    audience_temperature: "-",
+    funnel_stage: "-",
+    advertiser_size: "-",
+    presumes_brand_knowledge: true,
+    brand_knowledge_reason: "-"
+  },
+  baker_uses: { companies: 1, ours: true, approved: 1, rejected: 1 },
+  source: "followed",
+  stage: "-",
+  survived_test: true,
+  partnership: { partner_name: "-" }
+};
+var COMPACT_FIELDS = new Set(Object.keys(compactWinningAd(EVERY_SIGNAL)));
+var ALL_FIELDS = Object.keys(fullWinningAd(EVERY_SIGNAL));
+function adFields(requested, full) {
+  if (!requested) return { fields: void 0, full };
+  const fields = requested.map((f) => f.trim()).filter(Boolean);
+  const invalid = fields.filter((f) => !ALL_FIELDS.includes(f));
+  if (invalid.length > 0) return { invalid, valid: ALL_FIELDS };
+  return { fields, full: full || fields.some((f) => !COMPACT_FIELDS.has(f)) };
+}
+function adFieldPlan(fields, full) {
+  const plan = adFields(fields ? String(fields).split(",") : void 0, Boolean(full));
+  if (!("invalid" in plan)) return plan;
+  writeJson({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message: `Unknown --fields: ${plan.invalid.join(", ")}`,
+      fix: {
+        action: "retry_with_valid_values",
+        explanation: "Pass only fields an ad row carries.",
+        flag: "--fields",
+        invalidValues: plan.invalid,
+        validValues: plan.valid
+      }
+    }
+  });
+  process.exit(1);
+}
+function adRows(raw, plan) {
+  return raw.map((r) => {
+    const row = winningAdNormalizer(r, plan.full);
+    return plan.fields ? applyFieldMask(row, plan.fields) : row;
+  });
+}
+
+export {
+  adFieldPlan,
+  adRows
+};
+//# sourceMappingURL=chunk-LS2KEAYJ.js.map

package/dist/chunk-LURM3KKS.js

@@ -0,0 +1,94 @@
+import {
+  ApiError
+} from "./chunk-B4UVJCJ4.js";
+import {
+  writeJson
+} from "./chunk-FSGJSREN.js";
+
+// src/commands/landing/inspiration/shared.ts
+var INSPIRATION_HINTS = {
+  adapt: "Reference only. Re-express this in the client's BRAND.md palette, type and imagery register. Reusing a headline, subhead or CTA verbatim is a Tier 0 message-match failure (references/gotchas.md).",
+  structureNotCopy: "Take the structural decision, not the furniture: what the eye hits first, the grid ratio, what was deliberately left out. Your copy must come from the client's own offer."
+};
+function favoritesScopeHints(health, resultCount) {
+  if (!health) return [];
+  const hints = [];
+  if (health.savedPages === 0) {
+    hints.push(
+      "This company hasn't saved any reference pages yet, so there is no taste profile to search \u2014 an empty result here says nothing about the library. Search the whole shared library with --scope all, or save a page the client admires with `baker landing inspiration add <url>`."
+    );
+    return hints;
+  }
+  if (health.failedPages > 0) {
+    const retryable = health.failedExamples.filter((example) => example.retryable).map((example) => example.url);
+    const permanent = health.failedExamples.filter((example) => !example.retryable).map((example) => example.url);
+    hints.push(
+      `${health.failedPages} of this company's ${health.savedPages} saved pages could not be read, so they hold no sections \u2014 only ${health.usablePages} are usable, which is why this result is thin. Search the whole library with --scope all.`
+    );
+    if (retryable.length > 0) {
+      hints.push(
+        `Worth another go: ${retryable.join(", ")} \u2014 run \`baker landing inspiration add <url>\` on one of them to study it again.`
+      );
+    }
+    if (permanent.length > 0) {
+      hints.push(`Not worth retrying \u2014 these sites refuse automated readers: ${permanent.join(", ")}.`);
+    }
+  }
+  if (health.studyingPages > 0) {
+    hints.push(
+      `${health.studyingPages} saved ${health.studyingPages === 1 ? "page is" : "pages are"} still being studied and will be searchable in a few minutes. Carry on; do not wait on them.`
+    );
+  }
+  if (resultCount === 0 && health.failedPages === 0 && health.studyingPages === 0) {
+    hints.push(
+      `Nothing in this company's ${health.usablePages} readable saved pages matches. The saved set is healthy, so this is the query, not the library \u2014 loosen the filters or search everything with --scope all.`
+    );
+  }
+  return hints;
+}
+function fidelityHint(fidelity) {
+  if (fidelity == null) return null;
+  if (fidelity >= 0.9) return null;
+  if (fidelity >= 0.75) {
+    return `Reproduction fidelity ${fidelity.toFixed(2)} \u2014 the markup is close but not exact. Trust the screenshot over the code.`;
+  }
+  return `Reproduction fidelity ${fidelity.toFixed(2)} \u2014 this section is scroll- or JS-driven and the extracted markup does NOT render like the original. Use the screenshot and the notes; treat the code as a hint only.`;
+}
+var STALE_COPY_AFTER_MS = 30 * 24 * 60 * 60 * 1e3;
+function staleCopyHint(studiedAt, filedUrl, now = Date.now()) {
+  if (!studiedAt || now - studiedAt < STALE_COPY_AFTER_MS) return null;
+  const date = new Date(studiedAt).toLocaleDateString("en-US", { month: "short", day: "numeric", timeZone: "UTC" });
+  return `This copy of the page was read on ${date}. If the user says the live page looks different, run: baker landing inspiration add ${filedUrl} --refresh`;
+}
+function reportError(error) {
+  if (error instanceof ApiError) {
+    writeJson({ ok: false, error: { code: error.code, message: error.message } });
+  } else {
+    writeJson({
+      ok: false,
+      error: { code: "UNKNOWN", message: error instanceof Error ? error.message : String(error) }
+    });
+  }
+  process.exit(1);
+}
+function splitList(value) {
+  if (!value) return void 0;
+  const parts = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+function parseNumber(value) {
+  if (value === void 0 || value === "") return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+
+export {
+  INSPIRATION_HINTS,
+  favoritesScopeHints,
+  fidelityHint,
+  staleCopyHint,
+  reportError,
+  splitList,
+  parseNumber
+};
+//# sourceMappingURL=chunk-LURM3KKS.js.map

package/dist/chunk-MHH7SGLS.js

@@ -0,0 +1,106 @@
+import {
+  apiGet
+} from "./chunk-B4UVJCJ4.js";
+
+// src/commands/testimonials/emptyCorpusHints.ts
+function resolveEmptyReason({
+  resultCount,
+  activeFilters,
+  sourceCount
+}) {
+  if (resultCount > 0) {
+    return null;
+  }
+  if (activeFilters.length > 0) {
+    return "filtered_out";
+  }
+  return sourceCount === 0 ? "no_corpus_connected" : "corpus_empty";
+}
+var NO_CORPUS_EXIT = "Testimonials are ingested from the client's public review pages \u2014 an agent cannot write one \u2014 so no rewording will find quotes. If the user named the client's own review page (Google Maps, Trustpilot, Yelp, Tripadvisor, G2, Capterra, Amazon, App Store, Google Play), add it with `baker testimonials sources add <link>` \u2014 its reviews arrive over the next minutes, not in this turn. Stop searching and source proof another way: a result or case study the client already published, a named-customer logo (`baker images logo`), or a founder claim attributed as a claim. Otherwise ship without a testimonial block and file the gap: `baker actions create --name \"Collect customer quotes for <page>\" --priority medium --tags <slug>`. Never invent, paraphrase-into-existence, or pad with unrelated praise.";
+function emptyReasonDetail(reason, sourceCount, activeFilters) {
+  if (reason === "filtered_out") {
+    return `No rows matched, and ${activeFilters.join(", ")} narrowed this read. The corpus was not checked \u2014 drop every filter to see whether the library itself is empty.`;
+  }
+  if (reason === "no_corpus_connected") {
+    return "This company has no review source connected \u2014 checked against its source list, not inferred from the empty result.";
+  }
+  return `${sourceCount} review source${sourceCount === 1 ? " is" : "s are"} connected but hold no testimonials yet \u2014 the source is there, the rows are not. Ingestion may still be running.`;
+}
+function morePagesHint(resultCount, cursor) {
+  const found = resultCount === 0 ? "This page held no matches" : `This page held ${resultCount}`;
+  return `${found}, and the library continues past it \u2014 so this is one page, not the client's whole set. Do not report it as the corpus and do not conclude anything is missing from it. Read the next page with \`baker testimonials list --cursor ${cursor}\` (same filters), or go straight at the rows you want with \`baker testimonials search <query>\`.`;
+}
+function endOfWalkHint(command) {
+  const noun = command === "search" ? "results" : "rows";
+  return `That was the end of the library \u2014 no more ${noun} past the page before this one. Nothing here says the corpus is empty (the earlier pages held it), so answer from what those pages returned rather than re-reading.`;
+}
+async function measureEmptyCorpus({
+  command,
+  resultCount,
+  activeFilters,
+  nextCursor = null,
+  continued = false
+}) {
+  if (nextCursor) {
+    return { hints: [morePagesHint(resultCount, nextCursor)] };
+  }
+  if (resultCount > 0) {
+    return { hints: [] };
+  }
+  if (continued) {
+    return { hints: [endOfWalkHint(command)] };
+  }
+  if (activeFilters.length > 0) {
+    const reason2 = "filtered_out";
+    return {
+      hints: emptyCorpusHints({ command, reason: reason2, sourceCount: 0, activeFilters }),
+      empty: { reason: reason2, detail: emptyReasonDetail(reason2, 0, activeFilters) }
+    };
+  }
+  let sourceCount;
+  try {
+    const sources = await apiGet("/api/testimonials/sources");
+    sourceCount = Array.isArray(sources) ? sources.length : 0;
+  } catch {
+    return {
+      hints: [
+        "No rows, and the check for connected review sources failed \u2014 so this is NOT evidence that the client has no reviews. Do not record an absence you could not verify. Re-run once; if it fails again, say the library could not be read rather than that it is empty."
+      ]
+    };
+  }
+  const reason = resolveEmptyReason({ resultCount, activeFilters, sourceCount });
+  if (reason === null) {
+    return { hints: [] };
+  }
+  return {
+    hints: emptyCorpusHints({ command, reason, sourceCount, activeFilters }),
+    empty: { reason, detail: emptyReasonDetail(reason, sourceCount, activeFilters) }
+  };
+}
+function emptyCorpusHints({
+  command,
+  reason,
+  sourceCount,
+  activeFilters
+}) {
+  if (reason === null) {
+    return [];
+  }
+  if (reason === "filtered_out") {
+    return [
+      `No rows \u2014 ${activeFilters.join(", ")} narrowed this. Drop every filter and re-run once before touching the query; a filter combination and an empty library look identical from here.`
+    ];
+  }
+  const lead = command === "search" ? "No hits" : "No rows";
+  if (reason === "no_corpus_connected") {
+    return [`${lead}, and this company's source list is empty: there is no review corpus to search. ${NO_CORPUS_EXIT}`];
+  }
+  return [
+    `${lead}. ${sourceCount} review source${sourceCount === 1 ? " is" : "s are"} connected but no testimonials have landed yet \u2014 so this is a timing or ingestion gap, not a missing connection, and re-querying will not change it. Ingestion may still be running: say so rather than reporting the client has no reviews. ${NO_CORPUS_EXIT}`
+  ];
+}
+
+export {
+  measureEmptyCorpus
+};
+//# sourceMappingURL=chunk-MHH7SGLS.js.map