@ainyc/canonry 4.84.0 → 4.86.0

package/dist/{chunk-BNF3HXBW.js → chunk-23HGQV22.js}

@@ -1832,6 +1832,210 @@ import { z as z18 } from "zod";
 
 // ../contracts/src/discovery.ts
 import { z as z17 } from "zod";
+
+// ../contracts/src/embeddings.ts
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || b.length === 0) {
+    throw new Error("cosineSimilarity: vectors must be non-empty");
+  }
+  if (a.length !== b.length) {
+    throw new Error(`cosineSimilarity: vector length mismatch (${a.length} vs ${b.length})`);
+  }
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  if (magA === 0 || magB === 0) return 0;
+  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+function clusterByCosine(items, vectors, threshold) {
+  if (threshold < 0 || threshold > 1) {
+    throw new Error(`clusterByCosine: threshold must be in [0, 1], got ${threshold}`);
+  }
+  if (items.length !== vectors.length) {
+    throw new Error(`clusterByCosine: items/vectors length mismatch (${items.length} vs ${vectors.length})`);
+  }
+  if (items.length === 0) return [];
+  const parent = items.map((_, i) => i);
+  const find = (x) => {
+    let root = x;
+    while (parent[root] !== root) root = parent[root];
+    let cur = x;
+    while (parent[cur] !== root) {
+      const next = parent[cur];
+      parent[cur] = root;
+      cur = next;
+    }
+    return root;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  for (let i = 0; i < items.length; i++) {
+    for (let j = i + 1; j < items.length; j++) {
+      if (cosineSimilarity(vectors[i], vectors[j]) >= threshold) {
+        union(i, j);
+      }
+    }
+  }
+  const byRoot = /* @__PURE__ */ new Map();
+  for (let i = 0; i < items.length; i++) {
+    const root = find(i);
+    const existing = byRoot.get(root);
+    if (existing) existing.push(i);
+    else byRoot.set(root, [i]);
+  }
+  return Array.from(byRoot.values()).map((indices) => indices.map((idx) => items[idx]));
+}
+function pickClusterRepresentative(cluster) {
+  if (cluster.length === 0) throw new Error("pickClusterRepresentative: cluster is empty");
+  let best = cluster[0];
+  for (let i = 1; i < cluster.length; i++) {
+    if (cluster[i].length < best.length) best = cluster[i];
+  }
+  return best;
+}
+
+// ../contracts/src/url-normalize.ts
+var STRIP_KEYS = /* @__PURE__ */ new Set([
+  // Click identifiers
+  "fbclid",
+  "gclid",
+  "msclkid",
+  "ttclid",
+  "li_fat_id",
+  "igshid",
+  "yclid",
+  "dclid",
+  "gbraid",
+  "wbraid",
+  "bingid",
+  // Mailchimp
+  "mc_cid",
+  "mc_eid",
+  // Google Analytics linkers
+  "_ga",
+  "_gl",
+  // Google Tag Manager debug
+  "gtm_latency",
+  "gtm_debug",
+  // WordPress internal noise
+  "preview",
+  "preview_id",
+  "preview_nonce",
+  "_thumbnail_id",
+  // Common cache-busters/versioning
+  "v",
+  "ver",
+  "version"
+]);
+function shouldStrip(key) {
+  if (STRIP_KEYS.has(key)) return true;
+  if (key.startsWith("utm_")) return true;
+  return false;
+}
+function parseQuery(query) {
+  if (query === "") return [];
+  return query.split("&").map((pair) => {
+    const eq = pair.indexOf("=");
+    if (eq === -1) return { key: pair, value: null };
+    return { key: pair.slice(0, eq), value: pair.slice(eq + 1) };
+  });
+}
+function encodeQuery(pairs) {
+  return pairs.map((p) => p.value === null ? p.key : `${p.key}=${p.value}`).join("&");
+}
+function collapseRootIndex(path) {
+  if (path === "/index.html" || path === "/index.php") return "/";
+  return path;
+}
+function dropTrailingSlash(path) {
+  if (path.length > 1 && path.endsWith("/")) {
+    return path.replace(/\/+$/, "");
+  }
+  return path;
+}
+function absolutizeProjectUrl(url, canonicalDomain) {
+  if (!url) return "";
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  if (trimmed.startsWith("//")) return `https:${trimmed}`;
+  const host = canonicalDomain.trim().replace(/^https?:\/\//i, "").replace(/\/+$/, "");
+  if (!host) return trimmed;
+  if (trimmed.startsWith("/")) return `https://${host}${trimmed}`;
+  return `https://${host}/${trimmed}`;
+}
+function hostOf(value) {
+  if (value == null) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  try {
+    const url = trimmed.includes("://") ? new URL(trimmed) : new URL(`https://${trimmed}`);
+    return url.hostname.replace(/^www\./, "").toLowerCase();
+  } catch {
+    return null;
+  }
+}
+function normalizeUrlPath(input) {
+  if (input == null) return null;
+  let trimmed = input.trim();
+  if (trimmed === "") return null;
+  trimmed = trimmed.replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
+  if (trimmed === "" || trimmed === "/") return "/";
+  if (trimmed === "(not set)") return null;
+  trimmed = trimmed.replace(/([a-z0-9])[).]+$/i, "$1");
+  if (trimmed.startsWith("/)") || trimmed.startsWith("/ ")) {
+    trimmed = "/";
+  }
+  if (trimmed.includes(" ")) {
+    trimmed = trimmed.split(" ")[0];
+  }
+  if (trimmed === "" || trimmed === "/") return "/";
+  let pathPart;
+  let queryPart;
+  if (/^https?:\/\//i.test(trimmed)) {
+    let url;
+    try {
+      url = new URL(trimmed);
+    } catch {
+      return null;
+    }
+    pathPart = url.pathname || "/";
+    queryPart = url.search.startsWith("?") ? url.search.slice(1) : url.search;
+  } else {
+    let raw = trimmed;
+    const hashIdx = raw.indexOf("#");
+    if (hashIdx !== -1) raw = raw.slice(0, hashIdx);
+    const qIdx = raw.indexOf("?");
+    if (qIdx === -1) {
+      pathPart = raw;
+      queryPart = "";
+    } else {
+      pathPart = raw.slice(0, qIdx);
+      queryPart = raw.slice(qIdx + 1);
+    }
+  }
+  if (pathPart === "") pathPart = "/";
+  pathPart = collapseRootIndex(pathPart);
+  pathPart = dropTrailingSlash(pathPart);
+  const pairs = parseQuery(queryPart).filter((p) => !shouldStrip(p.key));
+  pairs.sort((a, b) => {
+    if (a.key < b.key) return -1;
+    if (a.key > b.key) return 1;
+    return 0;
+  });
+  if (pairs.length === 0) return pathPart;
+  return `${pathPart}?${encodeQuery(pairs)}`;
+}
+
+// ../contracts/src/discovery.ts
 var discoveryBucketSchema = z17.enum(["cited", "aspirational", "wasted-surface"]);
 var DiscoveryBuckets = discoveryBucketSchema.enum;
 var DEFAULT_DISCOVERY_PROMOTE_BUCKETS = [
@@ -1963,6 +2167,231 @@ var queryProvenanceSchema = z17.union([
   z17.literal("cli"),
   z17.string().regex(/^discovery:.+$/)
 ]);
+var DISCOVERY_HARVEST_MAX_WORDS = 12;
+var DISCOVERY_HARVEST_MIN_CHARS = 3;
+var DISCOVERY_HARVEST_NOVELTY_THRESHOLD = DISCOVERY_DEFAULT_DEDUP_THRESHOLD;
+var DISCOVERY_HARVEST_MIN_ANCHOR_TERMS = 1;
+var DISCOVERY_HARVEST_PHONE_DIGITS = 7;
+var HARVEST_SIGNIFICANT_TOKEN_MIN = 4;
+var HARVEST_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "near",
+  "best",
+  "top",
+  "your",
+  "you",
+  "are",
+  "how",
+  "what",
+  "does",
+  "this",
+  "that",
+  "from",
+  "into",
+  "about",
+  "who",
+  "why"
+]);
+var HARVEST_NAV_MARKERS = [
+  "address",
+  "directions",
+  "hours",
+  "login",
+  "log in",
+  "sign in",
+  "signin",
+  "phone number",
+  "zip code",
+  "postal code",
+  "email address"
+];
+var discoveryHarvestCandidateSchema = z17.object({
+  query: z17.string().min(1),
+  probeHits: z17.number().int().positive()
+});
+var discoveryHarvestStatsSchema = z17.object({
+  /** Distinct candidates extracted before gating. */
+  rawCandidates: z17.number().int().nonnegative(),
+  /** Candidates that passed every gate. */
+  admitted: z17.number().int().nonnegative(),
+  /** Per-reason rejection tally (each rejected candidate counted exactly once,
+   *  at the first gate it failed). Lexical-gate order: belowFloor → length →
+   *  navigational → duplicate (EXACT already-tracked) → offAnchor; then
+   *  `semanticDuplicate` for candidates dropped by the cosine novelty pass.
+   *  Invariant: `admitted + Σ(rejected) === rawCandidates`. */
+  rejected: z17.object({
+    belowFloor: z17.number().int().nonnegative(),
+    length: z17.number().int().nonnegative(),
+    navigational: z17.number().int().nonnegative(),
+    /** Dropped by the cheap exact-match check against the tracked basket. */
+    duplicate: z17.number().int().nonnegative(),
+    offAnchor: z17.number().int().nonnegative(),
+    /** Dropped by the embedding cosine novelty pass (a paraphrase / synonym /
+     *  stem variant of a tracked query that exact match can't see). 0 when the
+     *  semantic pass did not run — see `semanticNoveltyApplied`. */
+    semanticDuplicate: z17.number().int().nonnegative()
+  })
+});
+var discoveryHarvestDtoSchema = z17.object({
+  sessionId: z17.string(),
+  projectId: z17.string(),
+  /** The provider whose probes were harvested (the session's seed provider).
+   *  Discovery is Gemini-only today; carried so a future multi-provider
+   *  discovery can attribute candidates. */
+  provider: z17.string(),
+  status: discoverySessionStatusSchema,
+  /** Recurrence floor applied: a candidate must have appeared in ≥ this many
+   *  distinct probes to be admitted. */
+  minProbeHits: z17.number().int().positive(),
+  /** Whether the subject-anchor filter actually ran (requested AND the corpus
+   *  had ≥ `DISCOVERY_HARVEST_MIN_ANCHOR_TERMS` significant terms). */
+  anchorApplied: z17.boolean(),
+  /** Whether the embedding cosine novelty pass ran. False when embeddings were
+   *  unavailable (no Gemini key / no tracked queries / no candidates), in which
+   *  case novelty fell back to the cheap exact-match check only. */
+  semanticNoveltyApplied: z17.boolean(),
+  candidates: z17.array(discoveryHarvestCandidateSchema),
+  stats: discoveryHarvestStatsSchema
+});
+function normalizeHarvestQuery(query) {
+  return query.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function harvestTokens(query) {
+  return normalizeHarvestQuery(query).split(/[^a-z0-9]+/).filter(Boolean);
+}
+function significantHarvestTokens(query) {
+  return harvestTokens(query).filter(
+    (t) => t.length >= HARVEST_SIGNIFICANT_TOKEN_MIN && !HARVEST_STOPWORDS.has(t)
+  );
+}
+function longestDigitRun(query) {
+  let max = 0;
+  let run = 0;
+  for (const ch of query) {
+    if (ch >= "0" && ch <= "9") {
+      run++;
+      if (run > max) max = run;
+    } else {
+      run = 0;
+    }
+  }
+  return max;
+}
+function isNavigationalHarvestQuery(query) {
+  const norm = normalizeHarvestQuery(query);
+  if (longestDigitRun(norm) >= DISCOVERY_HARVEST_PHONE_DIGITS) return true;
+  const tokens = new Set(harvestTokens(norm));
+  for (const marker of HARVEST_NAV_MARKERS) {
+    if (marker.includes(" ")) {
+      const re = new RegExp(`(?<![a-z0-9])${marker.replace(/ /g, "\\s+")}(?![a-z0-9])`);
+      if (re.test(norm)) return true;
+    } else if (tokens.has(marker)) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildHarvestAnchorTerms(corpus, domains = []) {
+  const set = /* @__PURE__ */ new Set();
+  for (const text of corpus) {
+    for (const token of significantHarvestTokens(text)) set.add(token);
+  }
+  for (const domain of domains) {
+    const host = hostOf(domain);
+    if (!host) continue;
+    const label = host.replace(/\.[a-z0-9]+$/, "");
+    for (const token of significantHarvestTokens(label)) set.add(token);
+  }
+  return [...set];
+}
+function gateHarvestedSearchQueries(input) {
+  const minProbeHits = Math.max(1, Math.floor(input.minProbeHits ?? 1));
+  const anchorTermSet = new Set(input.anchorTerms ?? []);
+  const applyAnchor = (input.applyAnchor ?? true) && anchorTermSet.size >= DISCOVERY_HARVEST_MIN_ANCHOR_TERMS;
+  const trackedNorm = new Set(
+    input.trackedQueries.map(normalizeHarvestQuery).filter(Boolean)
+  );
+  const stats = {
+    rawCandidates: input.candidates.length,
+    admitted: 0,
+    rejected: { belowFloor: 0, length: 0, navigational: 0, duplicate: 0, offAnchor: 0, semanticDuplicate: 0 }
+  };
+  const admitted = [];
+  for (const candidate of input.candidates) {
+    if (candidate.probeHits < minProbeHits) {
+      stats.rejected.belowFloor++;
+      continue;
+    }
+    const norm = normalizeHarvestQuery(candidate.query);
+    const words = norm ? norm.split(" ").length : 0;
+    if (norm.length < DISCOVERY_HARVEST_MIN_CHARS || words > DISCOVERY_HARVEST_MAX_WORDS) {
+      stats.rejected.length++;
+      continue;
+    }
+    if (isNavigationalHarvestQuery(norm)) {
+      stats.rejected.navigational++;
+      continue;
+    }
+    if (trackedNorm.has(norm)) {
+      stats.rejected.duplicate++;
+      continue;
+    }
+    if (applyAnchor) {
+      const sig = significantHarvestTokens(norm);
+      if (!sig.some((t) => anchorTermSet.has(t))) {
+        stats.rejected.offAnchor++;
+        continue;
+      }
+    }
+    admitted.push({ query: norm, probeHits: candidate.probeHits });
+    stats.admitted++;
+  }
+  admitted.sort((a, b) => b.probeHits - a.probeHits || a.query.localeCompare(b.query));
+  return { admitted, anchorApplied: applyAnchor, stats };
+}
+function applyHarvestSemanticNovelty(input) {
+  const { result, candidateVectors, trackedVectors } = input;
+  const threshold = input.threshold ?? DISCOVERY_HARVEST_NOVELTY_THRESHOLD;
+  if (candidateVectors.length !== result.admitted.length || trackedVectors.length === 0) {
+    return result;
+  }
+  const admitted = [];
+  let semanticDuplicate = 0;
+  for (let i = 0; i < result.admitted.length; i++) {
+    const vec = candidateVectors[i];
+    const isDup = trackedVectors.some((t) => cosineSimilarity(vec, t) >= threshold);
+    if (isDup) semanticDuplicate++;
+    else admitted.push(result.admitted[i]);
+  }
+  return {
+    admitted,
+    anchorApplied: result.anchorApplied,
+    stats: {
+      ...result.stats,
+      admitted: admitted.length,
+      rejected: { ...result.stats.rejected, semanticDuplicate }
+    }
+  };
+}
+function aggregateHarvestedQueries(probes) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const probe of probes) {
+    const seenInProbe = /* @__PURE__ */ new Set();
+    for (const raw of probe.searchQueries) {
+      if (typeof raw !== "string") continue;
+      const norm = normalizeHarvestQuery(raw);
+      if (!norm || seenInProbe.has(norm)) continue;
+      seenInProbe.add(norm);
+      const existing = counts.get(norm);
+      if (existing) existing.probeHits++;
+      else counts.set(norm, { query: norm, probeHits: 1 });
+    }
+  }
+  return [...counts.values()];
+}
 
 // ../contracts/src/surface-class.ts
 var surfaceClassSchema = z18.enum([
@@ -2142,30 +2571,101 @@ function windowCutoff(window) {
   return d.toISOString();
 }
 
-// ../contracts/src/ga.ts
+// ../contracts/src/visibility-stats.ts
 import { z as z20 } from "zod";
-var ga4ConnectionDtoSchema = z20.object({
-  id: z20.string(),
-  projectId: z20.string(),
-  propertyId: z20.string(),
-  clientEmail: z20.string(),
-  connected: z20.boolean(),
-  createdAt: z20.string(),
-  updatedAt: z20.string()
-});
-var ga4TrafficSnapshotDtoSchema = z20.object({
-  date: z20.string(),
-  landingPage: z20.string(),
-  sessions: z20.number(),
-  organicSessions: z20.number(),
-  users: z20.number()
-});
-var ga4SourceDimensionSchema = z20.enum(["session", "first_user", "manual_utm"]);
-var ga4AiReferralDtoSchema = z20.object({
-  source: z20.string(),
-  medium: z20.string(),
-  sessions: z20.number(),
-  users: z20.number(),
+var visibilityStatsCountsSchema = z20.object({
+  /** Total (query × provider) snapshots observed in the window. Denominator for `citedRate`. */
+  total: z20.number().int(),
+  /**
+   * Snapshots where `answerMentioned !== null` — the sample size (`n`) for the
+   * mention proportion. Tri-state `null` ("not checked") is excluded.
+   */
+  checked: z20.number().int(),
+  /** Snapshots where `answerMentioned === true` (brand named in the answer text). */
+  mentioned: z20.number().int(),
+  /** Snapshots where `citationState === 'cited'` (domain in the grounding / source list). */
+  cited: z20.number().int(),
+  /** `mentioned / checked`, rounded to 4 dp; `null` when `checked === 0` (rate undefined over no samples). */
+  mentionRate: z20.number().nullable(),
+  /** `cited / total`, rounded to 4 dp; `null` when `total === 0`. */
+  citedRate: z20.number().nullable()
+});
+var visibilityStatsProviderEntrySchema = visibilityStatsCountsSchema.extend({
+  provider: z20.string(),
+  /** Earliest snapshot `createdAt` (ISO 8601) contributing to these counts. */
+  firstObserved: z20.string(),
+  /** Latest snapshot `createdAt` (ISO 8601) contributing to these counts. */
+  lastObserved: z20.string()
+});
+var visibilityStatsQueryEntrySchema = visibilityStatsCountsSchema.extend({
+  /** The tracked query's id. */
+  queryId: z20.string().nullable(),
+  /** The query text. */
+  query: z20.string(),
+  firstObserved: z20.string(),
+  lastObserved: z20.string(),
+  /**
+   * Per-provider breakdown — present only when `groupBy=provider`. Each
+   * entry's counts sum to this query's pooled counts.
+   */
+  providers: z20.array(visibilityStatsProviderEntrySchema).optional()
+});
+var visibilityStatsWindowSchema = z20.object({
+  /** Inclusive lower bound on `runs.createdAt` (ISO 8601; a date-only value is that UTC day's start), or `null` for unbounded. Echoes the raw value the caller passed. */
+  since: z20.string().nullable(),
+  /** Inclusive upper bound on `runs.createdAt` (ISO 8601; a date-only value covers the whole UTC day), or `null` for unbounded. Echoes the raw value the caller passed. */
+  until: z20.string().nullable(),
+  /** When set, the aggregation used the most recent N answer-visibility runs instead of a date window. */
+  lastRuns: z20.number().int().nullable(),
+  /** Number of (completed / partial, non-probe) answer-visibility runs included. */
+  runCount: z20.number().int()
+});
+var visibilityStatsGroupBySchema = z20.enum(["provider"]);
+var visibilityStatsDtoSchema = z20.object({
+  project: z20.string(),
+  /**
+   * `'provider'` when a per-provider breakdown was requested; OMITTED otherwise
+   * (absent = no breakdown). Optional rather than nullable so the generated SDK
+   * types it `groupBy?: 'provider'` — hey-api drops `null` on a single-value
+   * nullable enum, which would mistype the no-breakdown (common) case.
+   */
+  groupBy: visibilityStatsGroupBySchema.optional(),
+  window: visibilityStatsWindowSchema,
+  /** Pooled counts across every tracked query in the window. */
+  totals: visibilityStatsCountsSchema,
+  /**
+   * Pooled per-provider counts across every tracked query — present only when
+   * `groupBy=provider`. Each entry's counts sum to `totals`.
+   */
+  byProvider: z20.array(visibilityStatsProviderEntrySchema).optional(),
+  /** Per-query stats, sorted by query text. Only queries with ≥1 snapshot in the window appear. */
+  queries: z20.array(visibilityStatsQueryEntrySchema)
+});
+
+// ../contracts/src/ga.ts
+import { z as z21 } from "zod";
+var ga4ConnectionDtoSchema = z21.object({
+  id: z21.string(),
+  projectId: z21.string(),
+  propertyId: z21.string(),
+  clientEmail: z21.string(),
+  connected: z21.boolean(),
+  createdAt: z21.string(),
+  updatedAt: z21.string()
+});
+var ga4TrafficSnapshotDtoSchema = z21.object({
+  date: z21.string(),
+  landingPage: z21.string(),
+  sessions: z21.number(),
+  organicSessions: z21.number(),
+  users: z21.number()
+});
+var ga4SourceDimensionSchema = z21.enum(["session", "first_user", "manual_utm"]);
+var ga4AiReferralDtoSchema = z21.object({
+  source: z21.string(),
+  medium: z21.string(),
+  sessions: z21.number(),
+  users: z21.number(),
   /**
    * The winning attribution dimension for this (source, medium) tuple — the
    * one with the highest session count. GA4 emits one row per dimension
@@ -2175,144 +2675,144 @@ var ga4AiReferralDtoSchema = z20.object({
    */
   sourceDimension: ga4SourceDimensionSchema
 });
-var ga4AiReferralLandingPageDtoSchema = z20.object({
-  source: z20.string(),
-  medium: z20.string(),
+var ga4AiReferralLandingPageDtoSchema = z21.object({
+  source: z21.string(),
+  medium: z21.string(),
   /**
    * The winning attribution dimension for this (source, medium, landingPage)
    * tuple — the one with the highest session count.
    */
   sourceDimension: ga4SourceDimensionSchema,
-  landingPage: z20.string(),
-  sessions: z20.number(),
-  users: z20.number()
-});
-var ga4SocialReferralDtoSchema = z20.object({
-  source: z20.string(),
-  medium: z20.string(),
-  sessions: z20.number(),
-  users: z20.number(),
+  landingPage: z21.string(),
+  sessions: z21.number(),
+  users: z21.number()
+});
+var ga4SocialReferralDtoSchema = z21.object({
+  source: z21.string(),
+  medium: z21.string(),
+  sessions: z21.number(),
+  users: z21.number(),
   /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: z20.string()
+  channelGroup: z21.string()
 });
-var ga4ChannelBucketDtoSchema = z20.object({
-  sessions: z20.number(),
-  sharePct: z20.number(),
-  sharePctDisplay: z20.string()
+var ga4ChannelBucketDtoSchema = z21.object({
+  sessions: z21.number(),
+  sharePct: z21.number(),
+  sharePctDisplay: z21.string()
 });
-var ga4ChannelBreakdownDtoSchema = z20.object({
+var ga4ChannelBreakdownDtoSchema = z21.object({
   organic: ga4ChannelBucketDtoSchema,
   social: ga4ChannelBucketDtoSchema,
   direct: ga4ChannelBucketDtoSchema,
   ai: ga4ChannelBucketDtoSchema,
   other: ga4ChannelBucketDtoSchema
 });
-var ga4TrafficSummaryDtoSchema = z20.object({
-  totalSessions: z20.number(),
-  totalOrganicSessions: z20.number(),
+var ga4TrafficSummaryDtoSchema = z21.object({
+  totalSessions: z21.number(),
+  totalOrganicSessions: z21.number(),
   /** Direct-channel sessions (sessions with no source — bookmarks, typed URLs, AI-driven traffic with stripped referrer). 0 for legacy rows from before the column was added. */
-  totalDirectSessions: z20.number(),
-  totalUsers: z20.number(),
-  topPages: z20.array(z20.object({
-    landingPage: z20.string(),
-    sessions: z20.number(),
-    organicSessions: z20.number(),
+  totalDirectSessions: z21.number(),
+  totalUsers: z21.number(),
+  topPages: z21.array(z21.object({
+    landingPage: z21.string(),
+    sessions: z21.number(),
+    organicSessions: z21.number(),
     /** Per-page Direct-channel sessions. 0 for legacy rows. */
-    directSessions: z20.number(),
-    users: z20.number()
+    directSessions: z21.number(),
+    users: z21.number()
   })),
-  aiReferrals: z20.array(ga4AiReferralDtoSchema),
-  aiReferralLandingPages: z20.array(ga4AiReferralLandingPageDtoSchema),
+  aiReferrals: z21.array(ga4AiReferralDtoSchema),
+  aiReferralLandingPages: z21.array(ga4AiReferralLandingPageDtoSchema),
   /** Deduped AI session total: MAX(sessions) per date+source+medium across attribution dimensions, then summed. Cross-cutting: can overlap with Direct/Organic/Social via firstUserSource. */
-  aiSessionsDeduped: z20.number(),
+  aiSessionsDeduped: z21.number(),
   /** Deduped AI user total: MAX(users) per date+source+medium across attribution dimensions, then summed. */
-  aiUsersDeduped: z20.number(),
+  aiUsersDeduped: z21.number(),
   /** AI sessions whose CURRENT sessionSource matched an AI engine. Can overlap with raw Organic/Social/Direct totals; `channelBreakdown` removes those overlaps for display. */
-  aiSessionsBySession: z20.number(),
+  aiSessionsBySession: z21.number(),
   /** AI users whose CURRENT sessionSource matched an AI engine. Can overlap with raw Organic/Social/Direct totals. */
-  aiUsersBySession: z20.number(),
-  socialReferrals: z20.array(ga4SocialReferralDtoSchema),
+  aiUsersBySession: z21.number(),
+  socialReferrals: z21.array(ga4SocialReferralDtoSchema),
   /** Total social sessions (session-scoped, no cross-dimension dedup needed). */
-  socialSessions: z20.number(),
+  socialSessions: z21.number(),
   /** Total social users (session-scoped, no cross-dimension dedup needed). */
-  socialUsers: z20.number(),
+  socialUsers: z21.number(),
   /** Five disjoint buckets used for the channel breakdown. Known AI session-source matches are removed from their native GA4 bucket before shares are computed. */
   channelBreakdown: ga4ChannelBreakdownDtoSchema,
   /** Organic sessions as a percentage of total sessions (0–100, rounded). */
-  organicSharePct: z20.number(),
+  organicSharePct: z21.number(),
   /** Deduped AI sessions as a percentage of total sessions (0–100, rounded). Cross-cutting: can overlap with Direct/Organic/Social. */
-  aiSharePct: z20.number(),
+  aiSharePct: z21.number(),
   /** Session-source-only AI sessions as a percentage of total sessions (0–100, rounded). Can overlap with raw Organic/Social/Direct totals. */
-  aiSharePctBySession: z20.number(),
+  aiSharePctBySession: z21.number(),
   /** Direct-channel sessions as a percentage of total sessions (0–100, rounded). */
-  directSharePct: z20.number(),
+  directSharePct: z21.number(),
   /** Social sessions as a percentage of total sessions (0–100, rounded). */
-  socialSharePct: z20.number(),
+  socialSharePct: z21.number(),
   /** Display string for organicSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  organicSharePctDisplay: z20.string(),
+  organicSharePctDisplay: z21.string(),
   /** Display string for aiSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  aiSharePctDisplay: z20.string(),
+  aiSharePctDisplay: z21.string(),
   /** Display string for aiSharePctBySession: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  aiSharePctBySessionDisplay: z20.string(),
+  aiSharePctBySessionDisplay: z21.string(),
   /** Display string for directSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  directSharePctDisplay: z20.string(),
+  directSharePctDisplay: z21.string(),
   /** Display string for socialSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  socialSharePctDisplay: z20.string(),
+  socialSharePctDisplay: z21.string(),
   /** Sessions not covered by Organic, Social, Direct, or AI (session) channels — e.g. Referral, Email, Paid Search, Display. Always non-negative; clamped to 0 when the four disjoint channels sum above total (rounding edge). */
-  otherSessions: z20.number(),
+  otherSessions: z21.number(),
   /** Other sessions as a percentage of total sessions (0–100, rounded). */
-  otherSharePct: z20.number(),
+  otherSharePct: z21.number(),
   /** Display string for otherSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  otherSharePctDisplay: z20.string(),
-  lastSyncedAt: z20.string().nullable()
-});
-var ga4StatusDtoSchema = z20.object({
-  connected: z20.boolean(),
-  propertyId: z20.string().nullable(),
-  clientEmail: z20.string().nullable(),
-  authMethod: z20.enum(["service-account", "oauth"]).nullable(),
-  lastSyncedAt: z20.string().nullable(),
-  createdAt: z20.string().nullable().optional(),
-  updatedAt: z20.string().nullable().optional()
-});
-var ga4SyncResponseDtoSchema = z20.object({
-  synced: z20.boolean(),
-  rowCount: z20.number().int().nonnegative(),
-  aiReferralCount: z20.number().int().nonnegative(),
-  socialReferralCount: z20.number().int().nonnegative(),
-  days: z20.number().int().nonnegative(),
-  syncedAt: z20.string(),
+  otherSharePctDisplay: z21.string(),
+  lastSyncedAt: z21.string().nullable()
+});
+var ga4StatusDtoSchema = z21.object({
+  connected: z21.boolean(),
+  propertyId: z21.string().nullable(),
+  clientEmail: z21.string().nullable(),
+  authMethod: z21.enum(["service-account", "oauth"]).nullable(),
+  lastSyncedAt: z21.string().nullable(),
+  createdAt: z21.string().nullable().optional(),
+  updatedAt: z21.string().nullable().optional()
+});
+var ga4SyncResponseDtoSchema = z21.object({
+  synced: z21.boolean(),
+  rowCount: z21.number().int().nonnegative(),
+  aiReferralCount: z21.number().int().nonnegative(),
+  socialReferralCount: z21.number().int().nonnegative(),
+  days: z21.number().int().nonnegative(),
+  syncedAt: z21.string(),
   /**
    * Components that were written this run. Present when `only` is set.
    * Always includes `traffic` and `summary` (the share denominator) plus
    * the requested channel breakdown — `ai` and/or `social`.
    */
-  syncedComponents: z20.array(z20.string()).optional()
-});
-var ga4AiReferralHistoryEntrySchema = z20.object({
-  date: z20.string(),
-  source: z20.string(),
-  medium: z20.string(),
-  landingPage: z20.string(),
-  sessions: z20.number(),
-  users: z20.number(),
+  syncedComponents: z21.array(z21.string()).optional()
+});
+var ga4AiReferralHistoryEntrySchema = z21.object({
+  date: z21.string(),
+  source: z21.string(),
+  medium: z21.string(),
+  landingPage: z21.string(),
+  sessions: z21.number(),
+  users: z21.number(),
   /** Which GA4 dimension this row came from: session (sessionSource), first_user (firstUserSource), or manual_utm (utm_source parameter) */
   sourceDimension: ga4SourceDimensionSchema
 });
-var ga4SocialReferralHistoryEntrySchema = z20.object({
-  date: z20.string(),
-  source: z20.string(),
-  medium: z20.string(),
-  sessions: z20.number(),
-  users: z20.number(),
+var ga4SocialReferralHistoryEntrySchema = z21.object({
+  date: z21.string(),
+  source: z21.string(),
+  medium: z21.string(),
+  sessions: z21.number(),
+  users: z21.number(),
   /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: z20.string()
+  channelGroup: z21.string()
 });
-var ga4SessionHistoryEntrySchema = z20.object({
-  date: z20.string(),
-  sessions: z20.number(),
-  organicSessions: z20.number(),
-  users: z20.number()
+var ga4SessionHistoryEntrySchema = z21.object({
+  date: z21.string(),
+  sessions: z21.number(),
+  organicSessions: z21.number(),
+  users: z21.number()
 });
 
 // ../contracts/src/answer-visibility.ts
@@ -2480,50 +2980,50 @@ function escapeRegExp(value) {
 }
 
 // ../contracts/src/agent.ts
-import { z as z21 } from "zod";
-var agentProviderIdSchema = z21.enum(["claude", "openai", "gemini", "zai"]);
-var agentProviderOptionDtoSchema = z21.object({
+import { z as z22 } from "zod";
+var agentProviderIdSchema = z22.enum(["claude", "openai", "gemini", "zai"]);
+var agentProviderOptionDtoSchema = z22.object({
   /** Stable identifier — what clients pass back as `provider` on the prompt endpoint. */
   id: agentProviderIdSchema,
   /** Human-readable label for UI pickers, e.g. "Anthropic (Claude)". */
-  label: z21.string(),
+  label: z22.string(),
   /** Default model if the caller doesn't pick one. */
-  defaultModel: z21.string(),
+  defaultModel: z22.string(),
   /** Whether a usable API key was found (config.yaml or provider env var). */
-  configured: z21.boolean(),
+  configured: z22.boolean(),
   /**
    * Where the key resolved from, if any. `null` when `configured === false`.
    * Surfaced so the UI can nudge users toward their preferred source of truth.
    */
-  keySource: z21.enum(["config", "env"]).nullable()
+  keySource: z22.enum(["config", "env"]).nullable()
 });
-var agentProvidersResponseDtoSchema = z21.object({
+var agentProvidersResponseDtoSchema = z22.object({
   /**
    * Every provider Aero knows about. `configured === false` entries are
    * included so the UI can render them disabled with an onboarding hint.
    */
-  providers: z21.array(agentProviderOptionDtoSchema).default([]),
+  providers: z22.array(agentProviderOptionDtoSchema).default([]),
   /**
    * Provider Aero auto-picks when no explicit override is passed. Null if
    * nothing is configured (install never exchanged a key).
    */
   defaultProvider: agentProviderIdSchema.nullable()
 });
-var memorySourceSchema = z21.enum(["aero", "user", "compaction"]);
+var memorySourceSchema = z22.enum(["aero", "user", "compaction"]);
 var MemorySources = memorySourceSchema.enum;
 var AGENT_MEMORY_VALUE_MAX_BYTES = 2 * 1024;
 var AGENT_MEMORY_KEY_MAX_LENGTH = 128;
-var agentMemoryUpsertRequestSchema = z21.object({
-  key: z21.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH),
-  value: z21.string().min(1)
+var agentMemoryUpsertRequestSchema = z22.object({
+  key: z22.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH),
+  value: z22.string().min(1)
 });
-var agentMemoryDeleteRequestSchema = z21.object({
-  key: z21.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH)
+var agentMemoryDeleteRequestSchema = z22.object({
+  key: z22.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH)
 });
 
 // ../contracts/src/backlinks.ts
-import { z as z22 } from "zod";
-var backlinkSourceSchema = z22.enum(["commoncrawl", "bing-webmaster"]);
+import { z as z23 } from "zod";
+var backlinkSourceSchema = z23.enum(["commoncrawl", "bing-webmaster"]);
 var BacklinkSources = backlinkSourceSchema.enum;
 function computeBacklinkSummaryMetrics(rows) {
   if (rows.length === 0) {
@@ -2539,148 +3039,148 @@ function computeBacklinkSummaryMetrics(rows) {
     top10HostsShare: share.toFixed(6)
   };
 }
-var ccReleaseSyncStatusSchema = z22.enum(["queued", "downloading", "querying", "ready", "failed"]);
+var ccReleaseSyncStatusSchema = z23.enum(["queued", "downloading", "querying", "ready", "failed"]);
 var CcReleaseSyncStatuses = ccReleaseSyncStatusSchema.enum;
-var ccReleaseSyncDtoSchema = z22.object({
-  id: z22.string(),
-  release: z22.string(),
+var ccReleaseSyncDtoSchema = z23.object({
+  id: z23.string(),
+  release: z23.string(),
   status: ccReleaseSyncStatusSchema,
-  phaseDetail: z22.string().nullable().optional(),
-  vertexPath: z22.string().nullable().optional(),
-  edgesPath: z22.string().nullable().optional(),
-  vertexSha256: z22.string().nullable().optional(),
-  edgesSha256: z22.string().nullable().optional(),
-  vertexBytes: z22.number().int().nullable().optional(),
-  edgesBytes: z22.number().int().nullable().optional(),
-  projectsProcessed: z22.number().int().nullable().optional(),
-  domainsDiscovered: z22.number().int().nullable().optional(),
-  downloadStartedAt: z22.string().nullable().optional(),
-  downloadFinishedAt: z22.string().nullable().optional(),
-  queryStartedAt: z22.string().nullable().optional(),
-  queryFinishedAt: z22.string().nullable().optional(),
-  error: z22.string().nullable().optional(),
-  createdAt: z22.string(),
-  updatedAt: z22.string()
-});
-var backlinkDomainDtoSchema = z22.object({
-  linkingDomain: z22.string(),
+  phaseDetail: z23.string().nullable().optional(),
+  vertexPath: z23.string().nullable().optional(),
+  edgesPath: z23.string().nullable().optional(),
+  vertexSha256: z23.string().nullable().optional(),
+  edgesSha256: z23.string().nullable().optional(),
+  vertexBytes: z23.number().int().nullable().optional(),
+  edgesBytes: z23.number().int().nullable().optional(),
+  projectsProcessed: z23.number().int().nullable().optional(),
+  domainsDiscovered: z23.number().int().nullable().optional(),
+  downloadStartedAt: z23.string().nullable().optional(),
+  downloadFinishedAt: z23.string().nullable().optional(),
+  queryStartedAt: z23.string().nullable().optional(),
+  queryFinishedAt: z23.string().nullable().optional(),
+  error: z23.string().nullable().optional(),
+  createdAt: z23.string(),
+  updatedAt: z23.string()
+});
+var backlinkDomainDtoSchema = z23.object({
+  linkingDomain: z23.string(),
   // For Common Crawl this is the count of distinct hosts within the linking
   // domain; for Bing Webmaster it is the count of distinct linking pages (URLs)
   // from that linking host. Read alongside `source` — the unit differs per source.
-  numHosts: z22.number().int(),
+  numHosts: z23.number().int(),
   source: backlinkSourceSchema
 });
-var backlinkSummaryDtoSchema = z22.object({
-  projectId: z22.string(),
+var backlinkSummaryDtoSchema = z23.object({
+  projectId: z23.string(),
   // Window identifier. Common Crawl uses the release slug
   // (`cc-main-YYYY-<mon>-<mon>-<mon>`); Bing Webmaster uses a synthetic
   // per-sync-day window (`bing-YYYY-MM-DD`).
-  release: z22.string(),
-  targetDomain: z22.string(),
-  totalLinkingDomains: z22.number().int(),
-  totalHosts: z22.number().int(),
-  top10HostsShare: z22.string(),
-  queriedAt: z22.string(),
+  release: z23.string(),
+  targetDomain: z23.string(),
+  totalLinkingDomains: z23.number().int(),
+  totalHosts: z23.number().int(),
+  top10HostsShare: z23.string(),
+  queriedAt: z23.string(),
   source: backlinkSourceSchema,
   // Populated when the response is filtered (e.g. ?excludeCrawlers=1).
   // Counts the rows omitted from totalLinkingDomains/totalHosts so callers
   // can show "N hidden" hints without re-deriving them.
-  excludedLinkingDomains: z22.number().int().optional(),
-  excludedHosts: z22.number().int().optional()
+  excludedLinkingDomains: z23.number().int().optional(),
+  excludedHosts: z23.number().int().optional()
 });
-var backlinkListResponseSchema = z22.object({
+var backlinkListResponseSchema = z23.object({
   // The source this response was filtered to (defaults to commoncrawl when the
   // caller omits `?source`).
   source: backlinkSourceSchema,
   summary: backlinkSummaryDtoSchema.nullable(),
-  total: z22.number().int(),
-  rows: z22.array(backlinkDomainDtoSchema)
-});
-var backlinkHistoryEntrySchema = z22.object({
-  release: z22.string(),
-  totalLinkingDomains: z22.number().int(),
-  totalHosts: z22.number().int(),
-  top10HostsShare: z22.string(),
-  queriedAt: z22.string(),
+  total: z23.number().int(),
+  rows: z23.array(backlinkDomainDtoSchema)
+});
+var backlinkHistoryEntrySchema = z23.object({
+  release: z23.string(),
+  totalLinkingDomains: z23.number().int(),
+  totalHosts: z23.number().int(),
+  top10HostsShare: z23.string(),
+  queriedAt: z23.string(),
   source: backlinkSourceSchema
 });
-var backlinkSourceAvailabilityDtoSchema = z22.object({
+var backlinkSourceAvailabilityDtoSchema = z23.object({
   source: backlinkSourceSchema,
   /**
    * The source is set up for this project:
    *  - commoncrawl: `autoExtractBacklinks` enabled AND a `ready` release sync exists.
    *  - bing-webmaster: a Bing Webmaster connection exists for the project domain.
    */
-  connected: z22.boolean(),
+  connected: z23.boolean(),
   /** Backlink rows exist for this project + source. */
-  hasData: z22.boolean(),
+  hasData: z23.boolean(),
   /** Latest window id with data for this source, null when none. */
-  latestRelease: z22.string().nullable(),
+  latestRelease: z23.string().nullable(),
   /**
    * Linking-domain count in the latest window. Excludes crawler/proxy hosts only
    * when the request sets `?excludeCrawlers=1` (default off, matching the summary
    * and domains endpoints); the dashboard passes it so the switcher pill matches
    * the metric card.
    */
-  totalLinkingDomains: z22.number().int(),
+  totalLinkingDomains: z23.number().int(),
   /** Freshness: `queriedAt` of the latest summary for this source, null when none. */
-  lastSyncedAt: z22.string().nullable()
+  lastSyncedAt: z23.string().nullable()
 });
-var backlinkSourcesResponseSchema = z22.object({
-  projectId: z22.string(),
-  targetDomain: z22.string(),
+var backlinkSourcesResponseSchema = z23.object({
+  projectId: z23.string(),
+  targetDomain: z23.string(),
   /** Availability for every known source, in a stable order. */
-  sources: z22.array(backlinkSourceAvailabilityDtoSchema),
-  anyConnected: z22.boolean(),
-  anyData: z22.boolean()
-});
-var backlinksInstallStatusDtoSchema = z22.object({
-  duckdbInstalled: z22.boolean(),
-  duckdbVersion: z22.string().nullable().optional(),
-  duckdbSpec: z22.string(),
-  pluginDir: z22.string()
-});
-var backlinksInstallResultDtoSchema = z22.object({
-  installed: z22.boolean(),
-  version: z22.string(),
-  path: z22.string(),
-  alreadyPresent: z22.boolean()
-});
-var ccAvailableReleaseSchema = z22.object({
-  release: z22.string(),
-  vertexUrl: z22.string(),
-  edgesUrl: z22.string(),
-  vertexBytes: z22.number().int().nullable(),
-  edgesBytes: z22.number().int().nullable(),
-  lastModified: z22.string().nullable()
-});
-var ccCachedReleaseSchema = z22.object({
-  release: z22.string(),
+  sources: z23.array(backlinkSourceAvailabilityDtoSchema),
+  anyConnected: z23.boolean(),
+  anyData: z23.boolean()
+});
+var backlinksInstallStatusDtoSchema = z23.object({
+  duckdbInstalled: z23.boolean(),
+  duckdbVersion: z23.string().nullable().optional(),
+  duckdbSpec: z23.string(),
+  pluginDir: z23.string()
+});
+var backlinksInstallResultDtoSchema = z23.object({
+  installed: z23.boolean(),
+  version: z23.string(),
+  path: z23.string(),
+  alreadyPresent: z23.boolean()
+});
+var ccAvailableReleaseSchema = z23.object({
+  release: z23.string(),
+  vertexUrl: z23.string(),
+  edgesUrl: z23.string(),
+  vertexBytes: z23.number().int().nullable(),
+  edgesBytes: z23.number().int().nullable(),
+  lastModified: z23.string().nullable()
+});
+var ccCachedReleaseSchema = z23.object({
+  release: z23.string(),
   syncStatus: ccReleaseSyncStatusSchema.nullable(),
-  bytes: z22.number().int(),
-  lastUsedAt: z22.string().nullable()
+  bytes: z23.number().int(),
+  lastUsedAt: z23.string().nullable()
 });
 
 // ../contracts/src/composites.ts
-import { z as z23 } from "zod";
-var searchHitKindSchema = z23.enum(["snapshot", "insight"]);
-var projectSearchSnapshotHitSchema = z23.object({
-  kind: z23.literal("snapshot"),
-  id: z23.string(),
-  runId: z23.string(),
-  query: z23.string(),
-  provider: z23.string(),
-  model: z23.string().nullable(),
+import { z as z24 } from "zod";
+var searchHitKindSchema = z24.enum(["snapshot", "insight"]);
+var projectSearchSnapshotHitSchema = z24.object({
+  kind: z24.literal("snapshot"),
+  id: z24.string(),
+  runId: z24.string(),
+  query: z24.string(),
+  provider: z24.string(),
+  model: z24.string().nullable(),
   citationState: citationStateSchema,
-  matchedField: z23.enum(["answerText", "citedDomains", "searchQueries", "query"]),
-  snippet: z23.string(),
-  createdAt: z23.string()
-});
-var projectSearchInsightHitSchema = z23.object({
-  kind: z23.literal("insight"),
-  id: z23.string(),
-  runId: z23.string().nullable(),
-  type: z23.enum([
+  matchedField: z24.enum(["answerText", "citedDomains", "searchQueries", "query"]),
+  snippet: z24.string(),
+  createdAt: z24.string()
+});
+var projectSearchInsightHitSchema = z24.object({
+  kind: z24.literal("insight"),
+  id: z24.string(),
+  runId: z24.string().nullable(),
+  type: z24.enum([
     "regression",
     "gain",
     "opportunity",
@@ -2696,29 +3196,29 @@ var projectSearchInsightHitSchema = z23.object({
     "gbp-metric-drop",
     "gbp-keyword-drop"
   ]),
-  severity: z23.enum(["critical", "high", "medium", "low"]),
-  title: z23.string(),
-  query: z23.string(),
-  provider: z23.string(),
-  matchedField: z23.enum(["title", "query", "recommendation", "cause"]),
-  snippet: z23.string(),
-  dismissed: z23.boolean(),
-  createdAt: z23.string()
-});
-var projectSearchHitSchema = z23.discriminatedUnion("kind", [
+  severity: z24.enum(["critical", "high", "medium", "low"]),
+  title: z24.string(),
+  query: z24.string(),
+  provider: z24.string(),
+  matchedField: z24.enum(["title", "query", "recommendation", "cause"]),
+  snippet: z24.string(),
+  dismissed: z24.boolean(),
+  createdAt: z24.string()
+});
+var projectSearchHitSchema = z24.discriminatedUnion("kind", [
   projectSearchSnapshotHitSchema,
   projectSearchInsightHitSchema
 ]);
-var projectSearchResponseSchema = z23.object({
-  query: z23.string(),
-  totalHits: z23.number().int().nonnegative(),
-  truncated: z23.boolean(),
-  hits: z23.array(projectSearchHitSchema)
+var projectSearchResponseSchema = z24.object({
+  query: z24.string(),
+  totalHits: z24.number().int().nonnegative(),
+  truncated: z24.boolean(),
+  hits: z24.array(projectSearchHitSchema)
 });
 
 // ../contracts/src/content.ts
-import { z as z24 } from "zod";
-var contentActionSchema = z24.enum(["create", "expand", "refresh", "add-schema"]);
+import { z as z25 } from "zod";
+var contentActionSchema = z25.enum(["create", "expand", "refresh", "add-schema"]);
 var ContentActions = contentActionSchema.enum;
 function contentActionLabel(action) {
   switch (action) {
@@ -2732,9 +3232,9 @@ function contentActionLabel(action) {
       return "Add schema";
   }
 }
-var demandSourceSchema = z24.enum(["gsc", "competitor-evidence", "both"]);
+var demandSourceSchema = z25.enum(["gsc", "competitor-evidence", "both"]);
 var DemandSources = demandSourceSchema.enum;
-var actionConfidenceSchema = z24.enum(["high", "medium", "low"]);
+var actionConfidenceSchema = z25.enum(["high", "medium", "low"]);
 var ActionConfidences = actionConfidenceSchema.enum;
 function actionConfidenceLabel(confidence) {
   switch (confidence) {
@@ -2746,7 +3246,7 @@ function actionConfidenceLabel(confidence) {
       return "Low";
   }
 }
-var pageTypeSchema = z24.enum([
+var pageTypeSchema = z25.enum([
   "blog-post",
   "comparison",
   "listicle",
@@ -2755,7 +3255,7 @@ var pageTypeSchema = z24.enum([
   "glossary"
 ]);
 var PageTypes = pageTypeSchema.enum;
-var contentActionStateSchema = z24.enum([
+var contentActionStateSchema = z25.enum([
   "proposed",
   "briefed",
   "payload-generated",
@@ -2765,7 +3265,7 @@ var contentActionStateSchema = z24.enum([
   "dismissed"
 ]);
 var ContentActionStates = contentActionStateSchema.enum;
-var winnabilityClassSchema = z24.enum(["ownable", "ceded"]);
+var winnabilityClassSchema = z25.enum(["ownable", "ceded"]);
 var WinnabilityClasses = winnabilityClassSchema.enum;
 function winnabilityClassLabel(winnabilityClass) {
   switch (winnabilityClass) {
@@ -2800,40 +3300,40 @@ function deriveWinnabilityClass(citedSurfaceDomains, surfaceClasses, threshold =
     winnability
   };
 }
-var ourBestPageSchema = z24.object({
-  url: z24.string(),
-  gscImpressions: z24.number().nonnegative(),
-  gscClicks: z24.number().nonnegative(),
+var ourBestPageSchema = z25.object({
+  url: z25.string(),
+  gscImpressions: z25.number().nonnegative(),
+  gscClicks: z25.number().nonnegative(),
   // Null when the page came from the inventory fallback (no GSC ranking data).
-  gscAvgPosition: z24.number().nonnegative().nullable(),
-  organicSessions: z24.number().nonnegative()
+  gscAvgPosition: z25.number().nonnegative().nullable(),
+  organicSessions: z25.number().nonnegative()
 });
-var winningCompetitorSchema = z24.object({
-  domain: z24.string(),
-  url: z24.string(),
-  title: z24.string(),
-  citationCount: z24.number().int().nonnegative()
+var winningCompetitorSchema = z25.object({
+  domain: z25.string(),
+  url: z25.string(),
+  title: z25.string(),
+  citationCount: z25.number().int().nonnegative()
 });
-var scoreBreakdownSchema = z24.object({
-  demand: z24.number(),
-  competitor: z24.number(),
-  absence: z24.number(),
-  gapSeverity: z24.number()
+var scoreBreakdownSchema = z25.object({
+  demand: z25.number(),
+  competitor: z25.number(),
+  absence: z25.number(),
+  gapSeverity: z25.number()
 });
-var existingActionRefSchema = z24.object({
-  actionId: z24.string(),
+var existingActionRefSchema = z25.object({
+  actionId: z25.string(),
   state: contentActionStateSchema,
-  lastUpdated: z24.string()
+  lastUpdated: z25.string()
 });
-var contentTargetRowDtoSchema = z24.object({
-  targetRef: z24.string(),
-  query: z24.string(),
+var contentTargetRowDtoSchema = z25.object({
+  targetRef: z25.string(),
+  query: z25.string(),
   action: contentActionSchema,
   ourBestPage: ourBestPageSchema.nullable(),
   winningCompetitor: winningCompetitorSchema.nullable(),
-  score: z24.number(),
+  score: z25.number(),
   scoreBreakdown: scoreBreakdownSchema,
-  drivers: z24.array(z24.string()),
+  drivers: z25.array(z25.string()),
   demandSource: demandSourceSchema,
   actionConfidence: actionConfidenceSchema,
   existingAction: existingActionRefSchema.nullable(),
@@ -2848,134 +3348,134 @@ var contentTargetRowDtoSchema = z24.object({
    * `[0, 1]`. `null` when the gate failed open (no classification coverage for
    * the cited surface) — distinct from a computed `1.0`.
    */
-  winnability: z24.number().min(0).max(1).nullable()
-});
-var contentTargetsResponseDtoSchema = z24.object({
-  targets: z24.array(contentTargetRowDtoSchema),
-  contextMetrics: z24.object({
-    totalAiReferralSessions: z24.number().int().nonnegative(),
-    latestRunId: z24.string(),
-    runTimestamp: z24.string()
+  winnability: z25.number().min(0).max(1).nullable()
+});
+var contentTargetsResponseDtoSchema = z25.object({
+  targets: z25.array(contentTargetRowDtoSchema),
+  contextMetrics: z25.object({
+    totalAiReferralSessions: z25.number().int().nonnegative(),
+    latestRunId: z25.string(),
+    runTimestamp: z25.string()
   })
 });
-var contentTargetDismissalDtoSchema = z24.object({
-  targetRef: z24.string(),
-  addressedUrl: z24.string().nullable(),
-  note: z24.string().nullable(),
-  dismissedAt: z24.string()
+var contentTargetDismissalDtoSchema = z25.object({
+  targetRef: z25.string(),
+  addressedUrl: z25.string().nullable(),
+  note: z25.string().nullable(),
+  dismissedAt: z25.string()
 });
-var contentTargetDismissalsResponseDtoSchema = z24.object({
-  dismissals: z24.array(contentTargetDismissalDtoSchema)
+var contentTargetDismissalsResponseDtoSchema = z25.object({
+  dismissals: z25.array(contentTargetDismissalDtoSchema)
 });
-var contentTargetDismissRequestSchema = z24.object({
-  targetRef: z24.string().min(1),
+var contentTargetDismissRequestSchema = z25.object({
+  targetRef: z25.string().min(1),
   /** URL of the page the user wrote that addresses this recommendation. Stored verbatim for the audit trail; not currently used to suppress the slug-token matcher. */
-  addressedUrl: z24.string().url().optional(),
+  addressedUrl: z25.string().url().optional(),
   /** Free-form note (e.g. "covered in our Q1 content sprint"). 500 char cap is the API surface limit; the DB column is unbounded. */
-  note: z24.string().max(500).optional()
+  note: z25.string().max(500).optional()
 });
-var recommendationExplanationDtoSchema = z24.object({
-  targetRef: z24.string(),
+var recommendationExplanationDtoSchema = z25.object({
+  targetRef: z25.string(),
   /** Version of the prompt template used. Bumping the version invalidates the cache forward without touching the table. */
-  promptVersion: z24.string(),
+  promptVersion: z25.string(),
   /** Provider that produced the explanation (e.g. "claude", "gemini"). */
-  provider: z24.string(),
+  provider: z25.string(),
   /** Model id within that provider (e.g. "claude-sonnet-4-6"). */
-  model: z24.string(),
+  model: z25.string(),
   /** Markdown-formatted rationale + recommended next steps. */
-  responseText: z24.string(),
+  responseText: z25.string(),
   /** Estimated cost in millicents (1/100 of a cent). 0 when unknown. */
-  costMillicents: z24.number().int().nonnegative(),
-  generatedAt: z24.string()
+  costMillicents: z25.number().int().nonnegative(),
+  generatedAt: z25.string()
 });
-var recommendationExplainRequestSchema = z24.object({
+var recommendationExplainRequestSchema = z25.object({
   /**
    * Optional provider override (e.g. "claude" to force Claude even if
    * the project's default is Gemini). Falls through to project default
    * → auto-detect when omitted.
    */
-  provider: z24.string().optional(),
+  provider: z25.string().optional(),
   /**
    * Optional model override within the chosen provider. Falls through to
    * the `analyze`-tier default model when omitted.
    */
-  model: z24.string().optional(),
+  model: z25.string().optional(),
   /**
    * Force a fresh LLM call even if a cached explanation exists for the
    * current prompt version. Use sparingly — defeats the cache.
    */
-  forceRefresh: z24.boolean().optional()
+  forceRefresh: z25.boolean().optional()
 });
-var contentBriefDtoSchema = z24.object({
+var contentBriefDtoSchema = z25.object({
   /** The query the brief is for (echoed from the recommendation). */
-  targetQuery: z24.string().trim().min(1),
+  targetQuery: z25.string().trim().min(1),
   /** Always `ownable` in practice — the gate rejects `ceded` before synthesis. */
   winnabilityClass: winnabilityClassSchema,
   /** The differentiated content angle to take. */
-  angle: z24.string().trim().min(1),
+  angle: z25.string().trim().min(1),
   /** Why this query is winnable, citing the cited-surface signal. */
-  whyWinnable: z24.string().trim().min(1),
+  whyWinnable: z25.string().trim().min(1),
   /** The schema.org type or markup to add or extend. */
-  schemaHookup: z24.string().trim().min(1),
+  schemaHookup: z25.string().trim().min(1),
   /** Why the cited surface is controllable (the ownable-vs-ceded reasoning). */
-  controllableSurfaceRationale: z24.string().trim().min(1)
+  controllableSurfaceRationale: z25.string().trim().min(1)
 });
-var recommendationBriefDtoSchema = z24.object({
-  targetRef: z24.string(),
+var recommendationBriefDtoSchema = z25.object({
+  targetRef: z25.string(),
   /** Version of the brief prompt template; bumping invalidates the cache forward. */
-  promptVersion: z24.string(),
-  provider: z24.string(),
-  model: z24.string(),
+  promptVersion: z25.string(),
+  provider: z25.string(),
+  model: z25.string(),
   brief: contentBriefDtoSchema,
   /** Estimated cost in millicents (1/100 of a cent). 0 when unknown. */
-  costMillicents: z24.number().int().nonnegative(),
-  generatedAt: z24.string()
+  costMillicents: z25.number().int().nonnegative(),
+  generatedAt: z25.string()
 });
-var domainClassificationDtoSchema = z24.object({
-  domain: z24.string(),
+var domainClassificationDtoSchema = z25.object({
+  domain: z25.string(),
   competitorType: discoveryCompetitorTypeSchema,
-  hits: z24.number().int().nonnegative(),
-  updatedAt: z24.string()
-});
-var domainClassificationsResponseDtoSchema = z24.object({
-  classifications: z24.array(domainClassificationDtoSchema)
+  hits: z25.number().int().nonnegative(),
+  updatedAt: z25.string()
 });
-var contentGroundingSourceSchema = z24.object({
-  uri: z24.string(),
-  title: z24.string(),
-  domain: z24.string(),
-  isOurDomain: z24.boolean(),
-  isCompetitor: z24.boolean(),
-  citationCount: z24.number().int().nonnegative(),
-  providers: z24.array(providerNameSchema)
-});
-var contentSourceRowDtoSchema = z24.object({
-  query: z24.string(),
-  groundingSources: z24.array(contentGroundingSourceSchema)
+var domainClassificationsResponseDtoSchema = z25.object({
+  classifications: z25.array(domainClassificationDtoSchema)
 });
-var contentSourcesResponseDtoSchema = z24.object({
-  sources: z24.array(contentSourceRowDtoSchema),
-  latestRunId: z24.string()
-});
-var contentGapRowDtoSchema = z24.object({
-  query: z24.string(),
-  competitorDomains: z24.array(z24.string()),
-  competitorCount: z24.number().int().nonnegative(),
-  missRate: z24.number().min(0).max(1),
-  lastSeenInRunId: z24.string()
-});
-var contentGapsResponseDtoSchema = z24.object({
-  gaps: z24.array(contentGapRowDtoSchema),
-  latestRunId: z24.string()
+var contentGroundingSourceSchema = z25.object({
+  uri: z25.string(),
+  title: z25.string(),
+  domain: z25.string(),
+  isOurDomain: z25.boolean(),
+  isCompetitor: z25.boolean(),
+  citationCount: z25.number().int().nonnegative(),
+  providers: z25.array(providerNameSchema)
+});
+var contentSourceRowDtoSchema = z25.object({
+  query: z25.string(),
+  groundingSources: z25.array(contentGroundingSourceSchema)
+});
+var contentSourcesResponseDtoSchema = z25.object({
+  sources: z25.array(contentSourceRowDtoSchema),
+  latestRunId: z25.string()
+});
+var contentGapRowDtoSchema = z25.object({
+  query: z25.string(),
+  competitorDomains: z25.array(z25.string()),
+  competitorCount: z25.number().int().nonnegative(),
+  missRate: z25.number().min(0).max(1),
+  lastSeenInRunId: z25.string()
+});
+var contentGapsResponseDtoSchema = z25.object({
+  gaps: z25.array(contentGapRowDtoSchema),
+  latestRunId: z25.string()
 });
 
 // ../contracts/src/doctor.ts
-import { z as z25 } from "zod";
-var checkStatusSchema = z25.enum(["ok", "warn", "fail", "skipped"]);
+import { z as z26 } from "zod";
+var checkStatusSchema = z26.enum(["ok", "warn", "fail", "skipped"]);
 var CheckStatuses = checkStatusSchema.enum;
-var checkScopeSchema = z25.enum(["global", "project"]);
+var checkScopeSchema = z26.enum(["global", "project"]);
 var CheckScopes = checkScopeSchema.enum;
-var checkCategorySchema = z25.enum([
+var checkCategorySchema = z26.enum([
   "auth",
   "config",
   "providers",
@@ -2986,31 +3486,31 @@ var checkCategorySchema = z25.enum([
   "agent"
 ]);
 var CheckCategories = checkCategorySchema.enum;
-var checkResultSchema = z25.object({
-  id: z25.string(),
+var checkResultSchema = z26.object({
+  id: z26.string(),
   category: checkCategorySchema,
   scope: checkScopeSchema,
-  title: z25.string(),
+  title: z26.string(),
   status: checkStatusSchema,
-  code: z25.string().describe('Stable machine-readable code (e.g. "google.token.refresh-failed"). Use this for filtering and remediation logic.'),
-  summary: z25.string(),
-  remediation: z25.string().nullable().optional().describe('Operator-facing next step. Null when status is "ok" or no specific remediation applies.'),
-  details: z25.record(z25.string(), z25.unknown()).optional().describe("Structured context \u2014 principal email, redirect URI, missing scopes, etc. Stable per check id."),
-  durationMs: z25.number().int().nonnegative().describe("How long the check took to execute.")
+  code: z26.string().describe('Stable machine-readable code (e.g. "google.token.refresh-failed"). Use this for filtering and remediation logic.'),
+  summary: z26.string(),
+  remediation: z26.string().nullable().optional().describe('Operator-facing next step. Null when status is "ok" or no specific remediation applies.'),
+  details: z26.record(z26.string(), z26.unknown()).optional().describe("Structured context \u2014 principal email, redirect URI, missing scopes, etc. Stable per check id."),
+  durationMs: z26.number().int().nonnegative().describe("How long the check took to execute.")
 });
-var doctorReportSchema = z25.object({
+var doctorReportSchema = z26.object({
   scope: checkScopeSchema,
-  project: z25.string().nullable().describe('Project name when scope is "project", null otherwise.'),
-  generatedAt: z25.string().describe("ISO-8601 timestamp when this doctor run started."),
-  durationMs: z25.number().int().nonnegative(),
-  summary: z25.object({
-    total: z25.number().int().nonnegative(),
-    ok: z25.number().int().nonnegative(),
-    warn: z25.number().int().nonnegative(),
-    fail: z25.number().int().nonnegative(),
-    skipped: z25.number().int().nonnegative()
+  project: z26.string().nullable().describe('Project name when scope is "project", null otherwise.'),
+  generatedAt: z26.string().describe("ISO-8601 timestamp when this doctor run started."),
+  durationMs: z26.number().int().nonnegative(),
+  summary: z26.object({
+    total: z26.number().int().nonnegative(),
+    ok: z26.number().int().nonnegative(),
+    warn: z26.number().int().nonnegative(),
+    fail: z26.number().int().nonnegative(),
+    skipped: z26.number().int().nonnegative()
   }),
-  checks: z25.array(checkResultSchema)
+  checks: z26.array(checkResultSchema)
 });
 function summarizeCheckResults(results) {
   const summary = { total: results.length, ok: 0, warn: 0, fail: 0, skipped: 0 };
@@ -3033,186 +3533,53 @@ function summarizeCheckResults(results) {
   return summary;
 }
 
-// ../contracts/src/url-normalize.ts
-var STRIP_KEYS = /* @__PURE__ */ new Set([
-  // Click identifiers
-  "fbclid",
-  "gclid",
-  "msclkid",
-  "ttclid",
-  "li_fat_id",
-  "igshid",
-  "yclid",
-  "dclid",
-  "gbraid",
-  "wbraid",
-  "bingid",
-  // Mailchimp
-  "mc_cid",
-  "mc_eid",
-  // Google Analytics linkers
-  "_ga",
-  "_gl",
-  // Google Tag Manager debug
-  "gtm_latency",
-  "gtm_debug",
-  // WordPress internal noise
-  "preview",
-  "preview_id",
-  "preview_nonce",
-  "_thumbnail_id",
-  // Common cache-busters/versioning
-  "v",
-  "ver",
-  "version"
-]);
-function shouldStrip(key) {
-  if (STRIP_KEYS.has(key)) return true;
-  if (key.startsWith("utm_")) return true;
-  return false;
-}
-function parseQuery(query) {
-  if (query === "") return [];
-  return query.split("&").map((pair) => {
-    const eq = pair.indexOf("=");
-    if (eq === -1) return { key: pair, value: null };
-    return { key: pair.slice(0, eq), value: pair.slice(eq + 1) };
-  });
-}
-function encodeQuery(pairs) {
-  return pairs.map((p) => p.value === null ? p.key : `${p.key}=${p.value}`).join("&");
-}
-function collapseRootIndex(path) {
-  if (path === "/index.html" || path === "/index.php") return "/";
-  return path;
-}
-function dropTrailingSlash(path) {
-  if (path.length > 1 && path.endsWith("/")) {
-    return path.replace(/\/+$/, "");
-  }
-  return path;
-}
-function absolutizeProjectUrl(url, canonicalDomain) {
-  if (!url) return "";
-  const trimmed = url.trim();
-  if (!trimmed) return "";
-  if (/^https?:\/\//i.test(trimmed)) return trimmed;
-  if (trimmed.startsWith("//")) return `https:${trimmed}`;
-  const host = canonicalDomain.trim().replace(/^https?:\/\//i, "").replace(/\/+$/, "");
-  if (!host) return trimmed;
-  if (trimmed.startsWith("/")) return `https://${host}${trimmed}`;
-  return `https://${host}/${trimmed}`;
-}
-function hostOf(value) {
-  if (value == null) return null;
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  try {
-    const url = trimmed.includes("://") ? new URL(trimmed) : new URL(`https://${trimmed}`);
-    return url.hostname.replace(/^www\./, "").toLowerCase();
-  } catch {
-    return null;
-  }
-}
-function normalizeUrlPath(input) {
-  if (input == null) return null;
-  let trimmed = input.trim();
-  if (trimmed === "") return null;
-  trimmed = trimmed.replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
-  if (trimmed === "" || trimmed === "/") return "/";
-  if (trimmed === "(not set)") return null;
-  trimmed = trimmed.replace(/([a-z0-9])[).]+$/i, "$1");
-  if (trimmed.startsWith("/)") || trimmed.startsWith("/ ")) {
-    trimmed = "/";
-  }
-  if (trimmed.includes(" ")) {
-    trimmed = trimmed.split(" ")[0];
-  }
-  if (trimmed === "" || trimmed === "/") return "/";
-  let pathPart;
-  let queryPart;
-  if (/^https?:\/\//i.test(trimmed)) {
-    let url;
-    try {
-      url = new URL(trimmed);
-    } catch {
-      return null;
-    }
-    pathPart = url.pathname || "/";
-    queryPart = url.search.startsWith("?") ? url.search.slice(1) : url.search;
-  } else {
-    let raw = trimmed;
-    const hashIdx = raw.indexOf("#");
-    if (hashIdx !== -1) raw = raw.slice(0, hashIdx);
-    const qIdx = raw.indexOf("?");
-    if (qIdx === -1) {
-      pathPart = raw;
-      queryPart = "";
-    } else {
-      pathPart = raw.slice(0, qIdx);
-      queryPart = raw.slice(qIdx + 1);
-    }
-  }
-  if (pathPart === "") pathPart = "/";
-  pathPart = collapseRootIndex(pathPart);
-  pathPart = dropTrailingSlash(pathPart);
-  const pairs = parseQuery(queryPart).filter((p) => !shouldStrip(p.key));
-  pairs.sort((a, b) => {
-    if (a.key < b.key) return -1;
-    if (a.key > b.key) return 1;
-    return 0;
-  });
-  if (pairs.length === 0) return pathPart;
-  return `${pathPart}?${encodeQuery(pairs)}`;
-}
-
 // ../contracts/src/citations.ts
-import { z as z26 } from "zod";
-var citationCoverageProviderSchema = z26.object({
-  provider: z26.string(),
+import { z as z27 } from "zod";
+var citationCoverageProviderSchema = z27.object({
+  provider: z27.string(),
   citationState: citationStateSchema,
-  cited: z26.boolean(),
-  mentioned: z26.boolean(),
-  runId: z26.string(),
-  runCreatedAt: z26.string()
-});
-var citationCoverageRowSchema = z26.object({
-  queryId: z26.string(),
-  query: z26.string(),
-  providers: z26.array(citationCoverageProviderSchema),
-  citedCount: z26.number().int().nonnegative(),
-  mentionedCount: z26.number().int().nonnegative(),
-  totalProviders: z26.number().int().nonnegative()
-});
-var competitorGapRowSchema = z26.object({
-  queryId: z26.string(),
-  query: z26.string(),
-  provider: z26.string(),
-  citingCompetitors: z26.array(z26.string()),
-  runId: z26.string(),
-  runCreatedAt: z26.string()
-});
-var citationVisibilitySummarySchema = z26.object({
-  providersConfigured: z26.number().int().nonnegative(),
-  providersCiting: z26.number().int().nonnegative(),
-  providersMentioning: z26.number().int().nonnegative(),
-  totalQueries: z26.number().int().nonnegative(),
+  cited: z27.boolean(),
+  mentioned: z27.boolean(),
+  runId: z27.string(),
+  runCreatedAt: z27.string()
+});
+var citationCoverageRowSchema = z27.object({
+  queryId: z27.string(),
+  query: z27.string(),
+  providers: z27.array(citationCoverageProviderSchema),
+  citedCount: z27.number().int().nonnegative(),
+  mentionedCount: z27.number().int().nonnegative(),
+  totalProviders: z27.number().int().nonnegative()
+});
+var competitorGapRowSchema = z27.object({
+  queryId: z27.string(),
+  query: z27.string(),
+  provider: z27.string(),
+  citingCompetitors: z27.array(z27.string()),
+  runId: z27.string(),
+  runCreatedAt: z27.string()
+});
+var citationVisibilitySummarySchema = z27.object({
+  providersConfigured: z27.number().int().nonnegative(),
+  providersCiting: z27.number().int().nonnegative(),
+  providersMentioning: z27.number().int().nonnegative(),
+  totalQueries: z27.number().int().nonnegative(),
   // Cross-tab buckets — each tracked query with at least one snapshot lands
   // in exactly one of these. Queries with zero snapshots are not counted in
   // any bucket; (sum of buckets) ≤ totalQueries.
-  queriesCitedAndMentioned: z26.number().int().nonnegative(),
-  queriesCitedOnly: z26.number().int().nonnegative(),
-  queriesMentionedOnly: z26.number().int().nonnegative(),
-  queriesInvisible: z26.number().int().nonnegative(),
-  latestRunId: z26.string().nullable(),
-  latestRunAt: z26.string().nullable()
-});
-var citationVisibilityResponseSchema = z26.object({
+  queriesCitedAndMentioned: z27.number().int().nonnegative(),
+  queriesCitedOnly: z27.number().int().nonnegative(),
+  queriesMentionedOnly: z27.number().int().nonnegative(),
+  queriesInvisible: z27.number().int().nonnegative(),
+  latestRunId: z27.string().nullable(),
+  latestRunAt: z27.string().nullable()
+});
+var citationVisibilityResponseSchema = z27.object({
   summary: citationVisibilitySummarySchema,
-  byQuery: z26.array(citationCoverageRowSchema),
-  competitorGaps: z26.array(competitorGapRowSchema),
-  status: z26.enum(["ready", "no-data"]),
-  reason: z26.enum(["no-runs-yet", "no-queries"]).optional()
+  byQuery: z27.array(citationCoverageRowSchema),
+  competitorGaps: z27.array(competitorGapRowSchema),
+  status: z27.enum(["ready", "no-data"]),
+  reason: z27.enum(["no-runs-yet", "no-queries"]).optional()
 });
 function emptyCitationVisibility(reason) {
   return {
@@ -3239,46 +3606,46 @@ function citationStateToCited(state) {
 }
 
 // ../contracts/src/report.ts
-import { z as z27 } from "zod";
-var providerLocationTreatmentSchema = z27.enum([
+import { z as z28 } from "zod";
+var providerLocationTreatmentSchema = z28.enum([
   "prompt",
   "request-param",
   "browser-geo",
   "ignored"
 ]);
-var reportMetaLocationSchema = z27.object({
+var reportMetaLocationSchema = z28.object({
   /** Human-readable label as configured on the project (e.g. "michigan"). */
-  label: z27.string(),
+  label: z28.string(),
   /** Resolved city/region/country from the project's `LocationContext`. */
-  city: z27.string(),
-  region: z27.string(),
-  country: z27.string(),
+  city: z28.string(),
+  region: z28.string(),
+  country: z28.string(),
   /**
    * Other locations configured on the project that did NOT power this report.
    * When non-empty, callers should make clear that the report is location-scoped:
    * a separate sweep is needed to see how AI engines respond from each one.
    */
-  otherConfiguredLabels: z27.array(z27.string())
+  otherConfiguredLabels: z28.array(z28.string())
 });
-var reportProviderLocationHandlingSchema = z27.object({
+var reportProviderLocationHandlingSchema = z28.object({
   /** Provider name (matches `query_snapshots.provider`). */
-  provider: z27.string(),
+  provider: z28.string(),
   /** How this provider applied the configured location during this run. */
   treatment: providerLocationTreatmentSchema,
   /** One-sentence explanation suitable for the report. */
-  description: z27.string()
+  description: z28.string()
 });
-var reportMetaSchema = z27.object({
+var reportMetaSchema = z28.object({
   /** ISO timestamp the report was generated (server clock). */
-  generatedAt: z27.string(),
+  generatedAt: z28.string(),
   /** Project the report covers. */
-  project: z27.object({
-    id: z27.string(),
-    name: z27.string(),
-    displayName: z27.string(),
-    canonicalDomain: z27.string(),
-    country: z27.string(),
-    language: z27.string()
+  project: z28.object({
+    id: z28.string(),
+    name: z28.string(),
+    displayName: z28.string(),
+    canonicalDomain: z28.string(),
+    country: z28.string(),
+    language: z28.string()
   }),
   /**
    * The location that powered the latest visibility run, when one was set.
@@ -3293,24 +3660,24 @@ var reportMetaSchema = z27.object({
    * each provider's answer — some providers append it to the prompt, some
    * pass it as a structured request field, and some (CDP) ignore it.
    */
-  providerLocationHandling: z27.array(reportProviderLocationHandlingSchema),
+  providerLocationHandling: z28.array(reportProviderLocationHandlingSchema),
   /** Earliest data point referenced by the report (ISO date). */
-  periodStart: z27.string().nullable(),
+  periodStart: z28.string().nullable(),
   /** Latest data point referenced by the report (ISO date). */
-  periodEnd: z27.string().nullable()
+  periodEnd: z28.string().nullable()
 });
-var reportExecutiveSummarySchema = z27.object({
+var reportExecutiveSummarySchema = z28.object({
   /**
    * 0..100 — share of tracked queries that were cited by at least one
    * provider in the latest run. "Cited" means the project's domain appeared
    * in the source list / grounding the AI used to answer. Computed per-query
    * (not per-(query × provider)) so the rate is invariant to provider count.
    */
-  citationRate: z27.number(),
+  citationRate: z28.number(),
   /** Numerator of `citationRate` — distinct tracked queries cited by ≥1 provider in the latest run. */
-  citedQueryCount: z27.number(),
+  citedQueryCount: z28.number(),
   /** Denominator of `citationRate` — total tracked queries. */
-  totalQueryCount: z27.number(),
+  totalQueryCount: z28.number(),
   /**
    * 0..100 — share of tracked queries where the project's brand or domain
    * appeared in at least one provider's answer text in the latest run.
@@ -3318,68 +3685,68 @@ var reportExecutiveSummarySchema = z27.object({
    * the prose without citing your domain in its sources, and vice versa.
    * Same per-query denominator as `citationRate` for consistency.
    */
-  mentionRate: z27.number(),
+  mentionRate: z28.number(),
   /** Numerator of `mentionRate` — distinct tracked queries mentioned in ≥1 provider's answer text. */
-  mentionedQueryCount: z27.number(),
+  mentionedQueryCount: z28.number(),
   /** Compared to the previous run: 'up' | 'down' | 'flat' | 'unknown' (no prior run). */
-  trend: z27.enum(["up", "down", "flat", "unknown"]),
+  trend: z28.enum(["up", "down", "flat", "unknown"]),
   /** Total tracked queries. */
-  queryCount: z27.number(),
+  queryCount: z28.number(),
   /** Total tracked competitors. */
-  competitorCount: z27.number(),
+  competitorCount: z28.number(),
   /** Number of providers in the latest run. */
-  providerCount: z27.number(),
+  providerCount: z28.number(),
   /** GSC totals across the most-recent sync window. Null when GSC is not connected. */
-  gsc: z27.object({
-    clicks: z27.number(),
-    impressions: z27.number(),
-    ctr: z27.number(),
-    avgPosition: z27.number(),
-    periodStart: z27.string(),
-    periodEnd: z27.string()
+  gsc: z28.object({
+    clicks: z28.number(),
+    impressions: z28.number(),
+    ctr: z28.number(),
+    avgPosition: z28.number(),
+    periodStart: z28.string(),
+    periodEnd: z28.string()
   }).nullable(),
   /** GA4 totals across the most-recent sync period. Null when GA4 is not connected. */
-  ga: z27.object({
-    sessions: z27.number(),
-    users: z27.number(),
-    periodStart: z27.string(),
-    periodEnd: z27.string()
+  ga: z28.object({
+    sessions: z28.number(),
+    users: z28.number(),
+    periodStart: z28.string(),
+    periodEnd: z28.string()
   }).nullable(),
   /** Top 3-5 findings, each rendered as a single-sentence narrative. */
-  findings: z27.array(z27.object({
-    title: z27.string(),
-    detail: z27.string(),
-    tone: z27.enum(["positive", "caution", "negative", "neutral"])
+  findings: z28.array(z28.object({
+    title: z28.string(),
+    detail: z28.string(),
+    tone: z28.enum(["positive", "caution", "negative", "neutral"])
   }))
 });
-var citationCellSchema = z27.object({
-  citationState: z27.enum(["cited", "not-cited", "pending"]),
-  answerMentioned: z27.boolean().nullable(),
-  model: z27.string().nullable()
+var citationCellSchema = z28.object({
+  citationState: z28.enum(["cited", "not-cited", "pending"]),
+  answerMentioned: z28.boolean().nullable(),
+  model: z28.string().nullable()
 });
-var citationScorecardSchema = z27.object({
-  queries: z27.array(z27.string()),
-  providers: z27.array(z27.string()),
+var citationScorecardSchema = z28.object({
+  queries: z28.array(z28.string()),
+  providers: z28.array(z28.string()),
   /** matrix[queryIndex][providerIndex] — null when no snapshot exists for the pair. */
-  matrix: z27.array(z27.array(citationCellSchema.nullable())),
+  matrix: z28.array(z28.array(citationCellSchema.nullable())),
   /** Per-provider citation rate (0..100). */
-  providerRates: z27.array(z27.object({
-    provider: z27.string(),
-    citedCount: z27.number(),
-    totalCount: z27.number(),
-    citationRate: z27.number()
+  providerRates: z28.array(z28.object({
+    provider: z28.string(),
+    citedCount: z28.number(),
+    totalCount: z28.number(),
+    citationRate: z28.number()
   }))
 });
-var competitorRowSchema = z27.object({
-  domain: z27.string(),
+var competitorRowSchema = z28.object({
+  domain: z28.string(),
   /** Number of (query × provider) pairs that cited this competitor. */
-  citationCount: z27.number(),
+  citationCount: z28.number(),
   /** Out-of count for the same denominator. */
-  totalCount: z27.number(),
+  totalCount: z28.number(),
   /** 'High' | 'Moderate' | 'Low' | 'None' — from buildPortfolioProject pressure logic. */
-  pressureLabel: z27.enum(["High", "Moderate", "Low", "None"]),
+  pressureLabel: z28.enum(["High", "Moderate", "Low", "None"]),
   /** Distinct queries on which this competitor was cited. */
-  citedQueries: z27.array(z27.string()),
+  citedQueries: z28.array(z28.string()),
   /**
    * Citation share 0..100. Numerator = this competitor's `citationCount`.
    * Denominator = sum of `citationCount` across all competitors plus the
@@ -3387,30 +3754,30 @@ var competitorRowSchema = z27.object({
    * slots in the snapshot. Distinct from the project-level Mention Share
    * gauge — that one is brand-in-answer-text, this one is domain-in-source-list.
    */
-  sharePct: z27.number(),
+  sharePct: z28.number(),
   /**
    * URLs from the latest run's grounding sources whose host matches this
    * competitor's domain, with the queries each URL was cited for. Empty
    * when no grounding-source data is available (e.g. no `rawResponse` JSON
    * stored for the snapshots).
    */
-  theirCitedPages: z27.array(z27.object({ url: z27.string(), citedFor: z27.array(z27.string()) }))
+  theirCitedPages: z28.array(z28.object({ url: z28.string(), citedFor: z28.array(z28.string()) }))
 });
-var competitorLandscapeSchema = z27.object({
+var competitorLandscapeSchema = z28.object({
   /** Project's own citation count (for the bar chart comparing project vs competitors). */
-  projectCitationCount: z27.number(),
-  competitors: z27.array(competitorRowSchema)
+  projectCitationCount: z28.number(),
+  competitors: z28.array(competitorRowSchema)
 });
-var mentionRowSchema = z27.object({
-  domain: z27.string(),
+var mentionRowSchema = z28.object({
+  domain: z28.string(),
   /** Number of (query × provider) pairs whose answer text mentioned this competitor's brand or domain. */
-  mentionCount: z27.number(),
+  mentionCount: z28.number(),
   /** Out-of count for the same denominator (snapshots that had answer text). */
-  totalCount: z27.number(),
+  totalCount: z28.number(),
   /** 'High' | 'Moderate' | 'Low' | 'None' — mention frequency tier (mirrors CompetitorRow.pressureLabel). */
-  pressureLabel: z27.enum(["High", "Moderate", "Low", "None"]),
+  pressureLabel: z28.enum(["High", "Moderate", "Low", "None"]),
   /** Distinct queries on which this competitor was mentioned. */
-  mentionedQueries: z27.array(z27.string()),
+  mentionedQueries: z28.array(z28.string()),
   /**
    * Mention share 0..100. Numerator = this competitor's `mentionCount`.
    * Denominator = sum of `mentionCount` across all competitors plus the
@@ -3418,129 +3785,129 @@ var mentionRowSchema = z27.object({
    * mention. Per-competitor split of the same head-to-head measure the
    * project's hero `MentionShareDto` gauge headlines.
    */
-  sharePct: z27.number()
+  sharePct: z28.number()
 });
-var mentionLandscapeSchema = z27.object({
+var mentionLandscapeSchema = z28.object({
   /** Project's own mention count (for the bar chart comparing project vs competitors). */
-  projectMentionCount: z27.number(),
+  projectMentionCount: z28.number(),
   /** Snapshots considered — those with non-empty answerText. Drives the totalCount denominator. */
-  totalAnswerSnapshots: z27.number(),
-  competitors: z27.array(mentionRowSchema)
+  totalAnswerSnapshots: z28.number(),
+  competitors: z28.array(mentionRowSchema)
 });
-var aiSourceCategoryBucketSchema = z27.object({
+var aiSourceCategoryBucketSchema = z28.object({
   /** Category slug from packages/contracts/src/source-categories. */
-  category: z27.string(),
+  category: z28.string(),
   /** Display label. */
-  label: z27.string(),
+  label: z28.string(),
   /** Number of citations falling in this category. */
-  count: z27.number(),
+  count: z28.number(),
   /** 0..100 share of total citations. */
-  sharePct: z27.number()
+  sharePct: z28.number()
 });
-var aiSourceOriginSchema = z27.object({
-  categories: z27.array(aiSourceCategoryBucketSchema),
+var aiSourceOriginSchema = z28.object({
+  categories: z28.array(aiSourceCategoryBucketSchema),
   /** Top 20 source domains by citation count (excluding the project's own domain). */
-  topDomains: z27.array(z27.object({
-    domain: z27.string(),
-    count: z27.number(),
+  topDomains: z28.array(z28.object({
+    domain: z28.string(),
+    count: z28.number(),
     /** True when the domain is one of the project's tracked competitors. */
-    isCompetitor: z27.boolean()
+    isCompetitor: z28.boolean()
   }))
 });
-var gscQueryRowSchema = z27.object({
-  query: z27.string(),
-  clicks: z27.number(),
-  impressions: z27.number(),
-  ctr: z27.number(),
-  avgPosition: z27.number(),
+var gscQueryRowSchema = z28.object({
+  query: z28.string(),
+  clicks: z28.number(),
+  impressions: z28.number(),
+  ctr: z28.number(),
+  avgPosition: z28.number(),
   /** Heuristic categorization: 'brand' | 'lead-gen' | 'industry' | 'other'. */
-  category: z27.enum(["brand", "lead-gen", "industry", "other"])
-});
-var gscSectionSchema = z27.object({
-  periodStart: z27.string(),
-  periodEnd: z27.string(),
-  totalClicks: z27.number(),
-  totalImpressions: z27.number(),
-  ctr: z27.number(),
-  avgPosition: z27.number(),
-  topQueries: z27.array(gscQueryRowSchema),
-  categoryBreakdown: z27.array(z27.object({
-    category: z27.enum(["brand", "lead-gen", "industry", "other"]),
-    clicks: z27.number(),
-    impressions: z27.number(),
-    sharePct: z27.number()
+  category: z28.enum(["brand", "lead-gen", "industry", "other"])
+});
+var gscSectionSchema = z28.object({
+  periodStart: z28.string(),
+  periodEnd: z28.string(),
+  totalClicks: z28.number(),
+  totalImpressions: z28.number(),
+  ctr: z28.number(),
+  avgPosition: z28.number(),
+  topQueries: z28.array(gscQueryRowSchema),
+  categoryBreakdown: z28.array(z28.object({
+    category: z28.enum(["brand", "lead-gen", "industry", "other"]),
+    clicks: z28.number(),
+    impressions: z28.number(),
+    sharePct: z28.number()
   })),
-  trend: z27.array(z27.object({ date: z27.string(), clicks: z27.number(), impressions: z27.number() })),
+  trend: z28.array(z28.object({ date: z28.string(), clicks: z28.number(), impressions: z28.number() })),
   /**
    * Tracked AEO queries that have no GSC impressions in the report window.
    * Surfaces queries that may not represent real search demand.
    */
-  trackedButNoGsc: z27.array(z27.string()),
+  trackedButNoGsc: z28.array(z28.string()),
   /**
    * GSC top queries (sorted by impressions desc) that are not tracked as
    * AEO queries — the candidate set for adding to the AEO project.
    */
-  gscButNotTracked: z27.array(z27.string())
-});
-var gaTrafficSectionSchema = z27.object({
-  totalSessions: z27.number(),
-  totalUsers: z27.number(),
-  totalOrganicSessions: z27.number(),
-  periodStart: z27.string(),
-  periodEnd: z27.string(),
-  topLandingPages: z27.array(z27.object({
-    page: z27.string(),
-    sessions: z27.number(),
-    users: z27.number(),
-    organicSessions: z27.number()
+  gscButNotTracked: z28.array(z28.string())
+});
+var gaTrafficSectionSchema = z28.object({
+  totalSessions: z28.number(),
+  totalUsers: z28.number(),
+  totalOrganicSessions: z28.number(),
+  periodStart: z28.string(),
+  periodEnd: z28.string(),
+  topLandingPages: z28.array(z28.object({
+    page: z28.string(),
+    sessions: z28.number(),
+    users: z28.number(),
+    organicSessions: z28.number()
   })),
-  channelBreakdown: z27.array(z27.object({
-    channel: z27.string(),
-    sessions: z27.number(),
-    sharePct: z27.number()
+  channelBreakdown: z28.array(z28.object({
+    channel: z28.string(),
+    sessions: z28.number(),
+    sharePct: z28.number()
   }))
 });
-var socialReferralSectionSchema = z27.object({
-  totalSessions: z27.number(),
-  organicSessions: z27.number(),
-  paidSessions: z27.number(),
-  channels: z27.array(z27.object({
-    channelGroup: z27.string(),
-    sessions: z27.number(),
-    sharePct: z27.number()
+var socialReferralSectionSchema = z28.object({
+  totalSessions: z28.number(),
+  organicSessions: z28.number(),
+  paidSessions: z28.number(),
+  channels: z28.array(z28.object({
+    channelGroup: z28.string(),
+    sessions: z28.number(),
+    sharePct: z28.number()
   })),
-  topCampaigns: z27.array(z27.object({
-    source: z27.string(),
-    medium: z27.string(),
-    sessions: z27.number()
+  topCampaigns: z28.array(z28.object({
+    source: z28.string(),
+    medium: z28.string(),
+    sessions: z28.number()
   }))
 });
-var aiReferralSectionSchema = z27.object({
-  totalSessions: z27.number(),
-  totalUsers: z27.number(),
-  bySource: z27.array(z27.object({
-    source: z27.string(),
-    sessions: z27.number(),
-    users: z27.number(),
-    sharePct: z27.number()
+var aiReferralSectionSchema = z28.object({
+  totalSessions: z28.number(),
+  totalUsers: z28.number(),
+  bySource: z28.array(z28.object({
+    source: z28.string(),
+    sessions: z28.number(),
+    users: z28.number(),
+    sharePct: z28.number()
   })),
-  trend: z27.array(z27.object({ date: z27.string(), sessions: z27.number() })),
-  topLandingPages: z27.array(z27.object({
-    page: z27.string(),
-    sessions: z27.number(),
-    users: z27.number()
+  trend: z28.array(z28.object({ date: z28.string(), sessions: z28.number() })),
+  topLandingPages: z28.array(z28.object({
+    page: z28.string(),
+    sessions: z28.number(),
+    users: z28.number()
   }))
 });
-var serverActivitySectionSchema = z27.object({
+var serverActivitySectionSchema = z28.object({
   /** ISO8601 inclusive lower bound of the report window (default: 7 days). */
-  windowStart: z27.string(),
+  windowStart: z28.string(),
   /** ISO8601 inclusive upper bound. */
-  windowEnd: z27.string(),
-  hasData: z27.boolean(),
+  windowEnd: z28.string(),
+  hasData: z28.boolean(),
   /** Last-7d total verified crawler hits, with prior 7d for delta. */
-  verifiedCrawlerHits: z27.object({ current: z27.number(), prior: z27.number(), deltaPct: z27.number().nullable() }),
+  verifiedCrawlerHits: z28.object({ current: z28.number(), prior: z28.number(), deltaPct: z28.number().nullable() }),
   /** Last-7d total unverified crawler hits, separated from verified trust metrics. */
-  unverifiedCrawlerHits: z27.object({ current: z27.number(), prior: z27.number(), deltaPct: z27.number().nullable() }),
+  unverifiedCrawlerHits: z28.object({ current: z28.number(), prior: z28.number(), deltaPct: z28.number().nullable() }),
   /**
    * Last-7d on-demand per-user fetches from AI surfaces (ChatGPT-User,
    * Perplexity-User, MistralAI-User). Disjoint from `verifiedCrawlerHits` /
@@ -3549,19 +3916,19 @@ var serverActivitySectionSchema = z27.object({
    * because the operational question for user-fetch is "is this happening?"
    * not "is this a confirmed bot identity?"
    */
-  aiUserFetchHits: z27.object({ current: z27.number(), prior: z27.number(), deltaPct: z27.number().nullable() }),
+  aiUserFetchHits: z28.object({ current: z28.number(), prior: z28.number(), deltaPct: z28.number().nullable() }),
   /** Last-7d AI-referral sessions (sessionized from server-side request evidence). */
-  referralArrivals: z27.object({ current: z27.number(), prior: z27.number(), deltaPct: z27.number().nullable() }),
+  referralArrivals: z28.object({ current: z28.number(), prior: z28.number(), deltaPct: z28.number().nullable() }),
   /** Per-AI-operator breakdown (OpenAI, Anthropic, Google AI, Perplexity, …). */
-  byOperator: z27.array(z27.object({
-    operator: z27.string(),
-    verifiedHits: z27.number(),
+  byOperator: z28.array(z28.object({
+    operator: z28.string(),
+    verifiedHits: z28.number(),
     /** Shown to agency audience only: claimed-bot UA, source IP not in a published range. */
-    unverifiedHits: z27.number(),
+    unverifiedHits: z28.number(),
     /** Per-user fetches from this operator's AI surface (ChatGPT-User, …). */
-    userFetchHits: z27.number(),
-    referralArrivals: z27.number(),
-    deltaPct: z27.number().nullable()
+    userFetchHits: z28.number(),
+    referralArrivals: z28.number(),
+    deltaPct: z28.number().nullable()
   })),
   /**
    * Top crawled paths (verified only, last-7d). Path-level citation cross-reference
@@ -3571,84 +3938,84 @@ var serverActivitySectionSchema = z27.object({
    * citation evidence can extend this entry with a `citationState` field without
    * breaking the contract.
    */
-  topCrawledPaths: z27.array(z27.object({
-    path: z27.string(),
-    verifiedHits: z27.number(),
+  topCrawledPaths: z28.array(z28.object({
+    path: z28.string(),
+    verifiedHits: z28.number(),
     /** How many distinct AI operators crawled this path in the window. */
-    distinctOperators: z27.number()
+    distinctOperators: z28.number()
   })),
   /** AI products that sent ≥1 session in the window (referral by destination). */
-  referralProducts: z27.array(z27.object({
-    product: z27.string(),
-    arrivals: z27.number(),
-    distinctLandingPaths: z27.number()
+  referralProducts: z28.array(z28.object({
+    product: z28.string(),
+    arrivals: z28.number(),
+    distinctLandingPaths: z28.number()
   })),
   /** Daily trend, last 14d for sparkline / chart rendering. */
-  dailyTrend: z27.array(z27.object({
-    date: z27.string(),
-    verifiedCrawlerHits: z27.number(),
-    userFetchHits: z27.number(),
-    referralArrivals: z27.number()
+  dailyTrend: z28.array(z28.object({
+    date: z28.string(),
+    verifiedCrawlerHits: z28.number(),
+    userFetchHits: z28.number(),
+    referralArrivals: z28.number()
   })),
   /**
    * Top landing paths for AI-referral sessions (last-7d).
    * Complements `topCrawledPaths` (what bots fetch) with what humans actually land on.
    */
-  topReferralLandingPaths: z27.array(z27.object({
-    path: z27.string(),
-    arrivals: z27.number(),
-    distinctProducts: z27.number()
+  topReferralLandingPaths: z28.array(z28.object({
+    path: z28.string(),
+    arrivals: z28.number(),
+    distinctProducts: z28.number()
   }))
 });
-var indexingHealthSectionSchema = z27.object({
+var indexingHealthSectionSchema = z28.object({
   /** Source: 'google' | 'bing' | null when neither is connected. */
-  provider: z27.enum(["google", "bing"]).nullable(),
-  total: z27.number(),
-  indexed: z27.number(),
-  notIndexed: z27.number(),
+  provider: z28.enum(["google", "bing"]).nullable(),
+  total: z28.number(),
+  indexed: z28.number(),
+  notIndexed: z28.number(),
   /** Google-only — pages explicitly marked as deindexed. Bing reports 'unknown' instead. */
-  deindexed: z27.number(),
+  deindexed: z28.number(),
   /** Bing-only — pages with no inspection data yet. */
-  unknown: z27.number(),
+  unknown: z28.number(),
   /** 0..100. */
-  indexedPct: z27.number()
+  indexedPct: z28.number()
 });
-var citationsTrendPointSchema = z27.object({
+var citationsTrendPointSchema = z28.object({
   /** Run ID — anchor for cross-section linking. */
-  runId: z27.string(),
+  runId: z28.string(),
   /** ISO timestamp when the run finished (or createdAt fallback). */
-  date: z27.string(),
+  date: z28.string(),
   /**
    * 0..100 — same per-query unique-cited definition as
    * `ReportExecutiveSummary.citationRate`. Stable across runs with different
    * provider counts so the trend line measures real movement rather than
    * provider-count variance.
    */
-  citationRate: z27.number(),
+  citationRate: z28.number(),
   /** Numerator of `citationRate` for this run. */
-  citedQueryCount: z27.number(),
+  citedQueryCount: z28.number(),
   /** Denominator of `citationRate` for this run. */
-  totalQueryCount: z27.number(),
+  totalQueryCount: z28.number(),
   /** 0..100 — same per-query unique-mentioned definition as `ReportExecutiveSummary.mentionRate`. */
-  mentionRate: z27.number(),
+  mentionRate: z28.number(),
   /** Numerator of `mentionRate` for this run. */
-  mentionedQueryCount: z27.number(),
+  mentionedQueryCount: z28.number(),
   /**
    * Per-provider rates for the same run. Each provider's rate is per-pair
    * within that provider (`cited / scanned`), so it remains comparable
    * between providers in the same run.
    */
-  providerRates: z27.array(z27.object({ provider: z27.string(), citationRate: z27.number() }))
-});
-var reportInsightSchema = z27.object({
-  id: z27.string(),
-  type: z27.enum(["regression", "gain", "opportunity"]),
-  severity: z27.enum(["critical", "high", "medium", "low"]),
-  title: z27.string(),
-  query: z27.string(),
-  provider: z27.string(),
-  recommendation: z27.string().nullable(),
-  createdAt: z27.string(),
+  providerRates: z28.array(z28.object({ provider: z28.string(), citationRate: z28.number() }))
+});
+var reportInsightSchema = z28.object({
+  id: z28.string(),
+  type: z28.enum(["regression", "gain", "opportunity"]),
+  severity: z28.enum(["critical", "high", "medium", "low"]),
+  title: z28.string(),
+  query: z28.string(),
+  provider: z28.string(),
+  recommendation: z28.string().nullable(),
+  createdAt: z28.string(),
   /**
    * How many times this insight fired across recent runs for the same
    * `(query, provider, type)` tuple. Always ≥ 1. Insights returned by the
@@ -3656,57 +4023,57 @@ var reportInsightSchema = z27.object({
    * surfacing the multiplicity. Use it directly instead of grouping again
    * client-side — counts derived from raw insight rows will overcount.
    */
-  instanceCount: z27.number()
+  instanceCount: z28.number()
 });
-var recommendedNextStepSchema = z27.object({
+var recommendedNextStepSchema = z28.object({
   /** 'immediate' | 'short-term' | 'medium-term' — bucketed by severity heuristic. */
-  horizon: z27.enum(["immediate", "short-term", "medium-term"]),
-  title: z27.string(),
-  rationale: z27.string()
+  horizon: z28.enum(["immediate", "short-term", "medium-term"]),
+  title: z28.string(),
+  rationale: z28.string()
 });
-var reportRateDeltaSchema = z27.object({
+var reportRateDeltaSchema = z28.object({
   /** Current value (0..100 for rates, raw count otherwise). When `window`
    *  is present this is the average over the last `window` checks. */
-  current: z27.number(),
+  current: z28.number(),
   /** Prior value compared against. When `window` is present this is the
    *  average over the prior `window` checks before that. */
-  prior: z27.number(),
+  prior: z28.number(),
   /** Absolute delta (current − prior). Negative = decrease. */
-  deltaAbs: z27.number(),
+  deltaAbs: z28.number(),
   /**
    * Direction tag for tone mapping. Threshold is metric-specific (3pp for
    * rates, 0.5 for counts) so small noise lands as 'flat' rather than
    * flipping up/down each run.
    */
-  direction: z27.enum(["up", "down", "flat"]),
+  direction: z28.enum(["up", "down", "flat"]),
   /**
    * How many points went into each side of the average. Omitted (or 1)
    * means point-to-point (legacy "since last check"). Higher values mean
    * a rolling-average comparison — renderers should label it as
    * "vs prior N checks" when this is ≥ 2.
    */
-  window: z27.number().optional()
+  window: z28.number().optional()
 });
-var reportProviderMovementSchema = z27.object({
-  provider: z27.string(),
-  current: z27.number(),
-  prior: z27.number(),
-  deltaAbs: z27.number(),
-  direction: z27.enum(["up", "down", "flat"])
+var reportProviderMovementSchema = z28.object({
+  provider: z28.string(),
+  current: z28.number(),
+  prior: z28.number(),
+  deltaAbs: z28.number(),
+  direction: z28.enum(["up", "down", "flat"])
 });
-var whatsChangedSectionSchema = z27.object({
+var whatsChangedSectionSchema = z28.object({
   /**
    * False when there's no prior run (or fewer than the trend baseline),
    * meaning all per-metric deltas will be null. Renderers use this to swap
    * in a "establishing baseline" fallback rather than rendering empty
    * delta tiles.
    */
-  enoughHistory: z27.boolean(),
+  enoughHistory: z28.boolean(),
   /**
    * One-sentence narrative summary suitable as a section subtitle.
    * Always present — even on baseline, narrates whatever signal exists.
    */
-  headline: z27.string(),
+  headline: z28.string(),
   /** Citation rate delta vs the prior completed run. Null when no prior run. */
   citationRate: reportRateDeltaSchema.nullable(),
   /** Mention rate delta vs the prior completed run. Null when no prior run. */
@@ -3729,24 +4096,24 @@ var whatsChangedSectionSchema = z27.object({
    * when no prior run. Sorted by |deltaAbs| desc — providers with the
    * biggest swing first.
    */
-  providerMovements: z27.array(reportProviderMovementSchema),
+  providerMovements: z28.array(reportProviderMovementSchema),
   /**
    * Top wins this period — gains surfaced by the intelligence engine.
    * Capped at 5; sourced from `insights` filtered to `type: 'gain'`.
    */
-  wins: z27.array(reportInsightSchema),
+  wins: z28.array(reportInsightSchema),
   /**
    * Top regressions this period — citations or mentions lost. Capped at 5;
    * sourced from `insights` filtered to `type: 'regression'`.
    */
-  regressions: z27.array(reportInsightSchema)
-});
-var reportAudienceSchema = z27.enum(["agency", "client"]);
-var reportActionAudienceSchema = z27.enum(["agency", "client", "both"]);
-var reportActionHorizonSchema = z27.enum(["immediate", "short-term", "medium-term"]);
-var reportActionConfidenceSchema = z27.enum(["high", "medium", "low"]);
-var reportToneSchema = z27.enum(["positive", "caution", "negative", "neutral"]);
-var reportActionCategorySchema = z27.enum([
+  regressions: z28.array(reportInsightSchema)
+});
+var reportAudienceSchema = z28.enum(["agency", "client"]);
+var reportActionAudienceSchema = z28.enum(["agency", "client", "both"]);
+var reportActionHorizonSchema = z28.enum(["immediate", "short-term", "medium-term"]);
+var reportActionConfidenceSchema = z28.enum(["high", "medium", "low"]);
+var reportToneSchema = z28.enum(["positive", "caution", "negative", "neutral"]);
+var reportActionCategorySchema = z28.enum([
   "content",
   "competitors",
   "provider",
@@ -3755,23 +4122,23 @@ var reportActionCategorySchema = z27.enum([
   "location",
   "monitoring"
 ]);
-var reportActionPlanItemSchema = z27.object({
+var reportActionPlanItemSchema = z28.object({
   /** Which report audience should see this action. `both` renders in both modes. */
   audience: reportActionAudienceSchema,
   /** Stable sort priority. Lower numbers render earlier. */
-  priority: z27.number(),
+  priority: z28.number(),
   /** When this should be tackled. */
   horizon: reportActionHorizonSchema,
   category: reportActionCategorySchema,
-  title: z27.string(),
+  title: z28.string(),
   /** Direct next step written as an operator/client-friendly imperative. */
-  action: z27.string(),
+  action: z28.string(),
   /** Why this matters. Keep each entry concise and evidence-backed. */
-  why: z27.array(z27.string()),
+  why: z28.array(z28.string()),
   /** Specific observations that justify the action. */
-  evidence: z27.array(z27.string()),
+  evidence: z28.array(z28.string()),
   /** What should move if the action worked. */
-  successMetric: z27.string(),
+  successMetric: z28.string(),
   /** Confidence in the recommendation based on the available evidence. */
   confidence: reportActionConfidenceSchema,
   /**
@@ -3783,23 +4150,23 @@ var reportActionPlanItemSchema = z27.object({
    * load. Actions sourced from other signals (competitor gaps, indexing
    * issues, etc.) omit this and use their own dismiss flows.
    */
-  targetRef: z27.string().optional()
+  targetRef: z28.string().optional()
 });
-var reportClientSummarySchema = z27.object({
-  headline: z27.string(),
-  overview: z27.string(),
-  actionItems: z27.array(reportActionPlanItemSchema),
-  confidenceNotes: z27.array(z27.string())
+var reportClientSummarySchema = z28.object({
+  headline: z28.string(),
+  overview: z28.string(),
+  actionItems: z28.array(reportActionPlanItemSchema),
+  confidenceNotes: z28.array(z28.string())
 });
-var reportAgencyDiagnosticSchema = z27.object({
-  title: z27.string(),
-  detail: z27.string(),
-  severity: z27.enum(["positive", "caution", "negative", "neutral"]),
-  evidence: z27.array(z27.string())
+var reportAgencyDiagnosticSchema = z28.object({
+  title: z28.string(),
+  detail: z28.string(),
+  severity: z28.enum(["positive", "caution", "negative", "neutral"]),
+  evidence: z28.array(z28.string())
 });
-var reportAgencyDiagnosticsSchema = z27.object({
-  priorities: z27.array(reportActionPlanItemSchema),
-  diagnostics: z27.array(reportAgencyDiagnosticSchema)
+var reportAgencyDiagnosticsSchema = z28.object({
+  priorities: z28.array(reportActionPlanItemSchema),
+  diagnostics: z28.array(reportAgencyDiagnosticSchema)
 });
 function reportActionTone(action) {
   if (action.horizon === "immediate") return "negative";
@@ -3857,7 +4224,7 @@ function reportConfidenceLabel(confidence) {
       return "Low";
   }
 }
-var projectReportDtoSchema = z27.object({
+var projectReportDtoSchema = z28.object({
   meta: reportMetaSchema,
   executiveSummary: reportExecutiveSummarySchema,
   citationScorecard: citationScorecardSchema,
@@ -3871,16 +4238,16 @@ var projectReportDtoSchema = z27.object({
   /** Server-side log-evidence visibility (crawls + click-through sessions). Null when no traffic source connected. */
   serverActivity: serverActivitySectionSchema.nullable(),
   indexingHealth: indexingHealthSectionSchema.nullable(),
-  citationsTrend: z27.array(citationsTrendPointSchema),
+  citationsTrend: z28.array(citationsTrendPointSchema),
   /**
    * Trend-focused "what's changed" summary for the report's act 2. Always
    * present; renderers gate empty/baseline states via `enoughHistory`.
    */
   whatsChanged: whatsChangedSectionSchema,
-  insights: z27.array(reportInsightSchema),
-  recommendedNextSteps: z27.array(recommendedNextStepSchema),
+  insights: z28.array(reportInsightSchema),
+  recommendedNextSteps: z28.array(recommendedNextStepSchema),
   /** Canonical structured actions shared by the client and agency render modes. */
-  actionPlan: z27.array(reportActionPlanItemSchema),
+  actionPlan: z28.array(reportActionPlanItemSchema),
   /** Polished client-facing summary and action shortlist. */
   clientSummary: reportClientSummarySchema,
   /** Technical, evidence-oriented operator diagnostics for agency mode. */
@@ -3890,17 +4257,17 @@ var projectReportDtoSchema = z27.object({
    * intelligence layer (`buildContentTargetRows`). Empty when no run has
    * produced candidate queries with demand or competitor signal.
    */
-  contentOpportunities: z27.array(contentTargetRowDtoSchema),
+  contentOpportunities: z28.array(contentTargetRowDtoSchema),
   /**
    * Queries where competitors were cited but the project was not. Sourced
    * from `buildContentGapRows`. Empty until the first answer-visibility run.
    */
-  contentGaps: z27.array(contentGapRowDtoSchema),
+  contentGaps: z28.array(contentGapRowDtoSchema),
   /**
    * Per-query grounding source map (own + competitor cited URLs). Sourced
    * from `buildContentSourceRows`. Empty until the first answer-visibility run.
    */
-  groundingSources: z27.array(contentSourceRowDtoSchema)
+  groundingSources: z28.array(contentSourceRowDtoSchema)
 });
 
 // ../contracts/src/report-dedup.ts
@@ -3971,10 +4338,10 @@ function dedupeReportOpportunities(report) {
 }
 
 // ../contracts/src/skills.ts
-import { z as z28 } from "zod";
-var codingAgentSchema = z28.enum(["claude", "codex"]);
+import { z as z29 } from "zod";
+var codingAgentSchema = z29.enum(["claude", "codex"]);
 var CodingAgents = codingAgentSchema.enum;
-var skillsClientSchema = z28.enum(["claude", "codex", "all"]);
+var skillsClientSchema = z29.enum(["claude", "codex", "all"]);
 var SkillsClients = skillsClientSchema.enum;
 var SKILL_MANIFEST_FILENAME = ".canonry-skill-manifest.json";
 function classifySkillFile(params) {
@@ -3992,8 +4359,8 @@ function coerceSkillManifest(parsed) {
 }
 
 // ../contracts/src/traffic.ts
-import { z as z29 } from "zod";
-var trafficSourceTypeSchema = z29.enum([
+import { z as z30 } from "zod";
+var trafficSourceTypeSchema = z30.enum([
   "cloud-run",
   "wordpress",
   "cloudflare",
@@ -4001,7 +4368,7 @@ var trafficSourceTypeSchema = z29.enum([
   "generic-log"
 ]);
 var TrafficSourceTypes = trafficSourceTypeSchema.enum;
-var trafficAdapterCapabilitySchema = z29.enum([
+var trafficAdapterCapabilitySchema = z30.enum([
   "raw-request-events",
   "aggregate-request-metrics",
   "request-url",
@@ -4012,285 +4379,216 @@ var trafficAdapterCapabilitySchema = z29.enum([
   "cursor-pull"
 ]);
 var TrafficAdapterCapabilities = trafficAdapterCapabilitySchema.enum;
-var trafficEvidenceKindSchema = z29.enum(["raw-request", "aggregate-bucket"]);
+var trafficEvidenceKindSchema = z30.enum(["raw-request", "aggregate-bucket"]);
 var TrafficEvidenceKinds = trafficEvidenceKindSchema.enum;
-var trafficEventConfidenceSchema = z29.enum(["observed", "provider-aggregated", "inferred"]);
+var trafficEventConfidenceSchema = z30.enum(["observed", "provider-aggregated", "inferred"]);
 var TrafficEventConfidences = trafficEventConfidenceSchema.enum;
-var trafficProviderResourceSchema = z29.object({
-  type: z29.string().nullable(),
-  labels: z29.record(z29.string(), z29.string())
+var trafficProviderResourceSchema = z30.object({
+  type: z30.string().nullable(),
+  labels: z30.record(z30.string(), z30.string())
 });
-var normalizedTrafficRequestSchema = z29.object({
+var normalizedTrafficRequestSchema = z30.object({
   sourceType: trafficSourceTypeSchema,
-  evidenceKind: z29.literal(TrafficEvidenceKinds["raw-request"]),
-  confidence: z29.literal(TrafficEventConfidences.observed),
-  eventId: z29.string().min(1),
-  observedAt: z29.string().min(1),
-  method: z29.string().nullable(),
-  requestUrl: z29.string().nullable(),
-  host: z29.string().nullable(),
-  path: z29.string().min(1),
-  queryString: z29.string().nullable(),
-  status: z29.number().int().nullable(),
-  userAgent: z29.string().nullable(),
-  remoteIp: z29.string().nullable(),
-  referer: z29.string().nullable(),
-  latencyMs: z29.number().nullable(),
-  requestSizeBytes: z29.number().int().nullable(),
-  responseSizeBytes: z29.number().int().nullable(),
+  evidenceKind: z30.literal(TrafficEvidenceKinds["raw-request"]),
+  confidence: z30.literal(TrafficEventConfidences.observed),
+  eventId: z30.string().min(1),
+  observedAt: z30.string().min(1),
+  method: z30.string().nullable(),
+  requestUrl: z30.string().nullable(),
+  host: z30.string().nullable(),
+  path: z30.string().min(1),
+  queryString: z30.string().nullable(),
+  status: z30.number().int().nullable(),
+  userAgent: z30.string().nullable(),
+  remoteIp: z30.string().nullable(),
+  referer: z30.string().nullable(),
+  latencyMs: z30.number().nullable(),
+  requestSizeBytes: z30.number().int().nullable(),
+  responseSizeBytes: z30.number().int().nullable(),
   providerResource: trafficProviderResourceSchema,
-  providerLabels: z29.record(z29.string(), z29.string())
+  providerLabels: z30.record(z30.string(), z30.string())
 });
-var normalizedTrafficPullPageSchema = z29.object({
-  events: z29.array(normalizedTrafficRequestSchema),
-  rawEntryCount: z29.number().int().nonnegative(),
-  skippedEntryCount: z29.number().int().nonnegative(),
-  nextPageToken: z29.string().optional(),
-  filter: z29.string()
+var normalizedTrafficPullPageSchema = z30.object({
+  events: z30.array(normalizedTrafficRequestSchema),
+  rawEntryCount: z30.number().int().nonnegative(),
+  skippedEntryCount: z30.number().int().nonnegative(),
+  nextPageToken: z30.string().optional(),
+  filter: z30.string()
 });
-var trafficSourceStatusSchema = z29.enum(["connected", "paused", "error", "archived"]);
+var trafficSourceStatusSchema = z30.enum(["connected", "paused", "error", "archived"]);
 var TrafficSourceStatuses = trafficSourceStatusSchema.enum;
-var trafficSourceAuthModeSchema = z29.enum(["oauth", "service-account"]);
+var trafficSourceAuthModeSchema = z30.enum(["oauth", "service-account"]);
 var TrafficSourceAuthModes = trafficSourceAuthModeSchema.enum;
-var verificationStatusSchema = z29.enum(["verified", "claimed_unverified", "unknown_ai_like"]);
+var verificationStatusSchema = z30.enum(["verified", "claimed_unverified", "unknown_ai_like"]);
 var VerificationStatuses = verificationStatusSchema.enum;
-var cloudRunSourceConfigSchema = z29.object({
-  gcpProjectId: z29.string().min(1),
-  serviceName: z29.string().nullable().optional(),
-  location: z29.string().nullable().optional(),
+var cloudRunSourceConfigSchema = z30.object({
+  gcpProjectId: z30.string().min(1),
+  serviceName: z30.string().nullable().optional(),
+  location: z30.string().nullable().optional(),
   authMode: trafficSourceAuthModeSchema
 });
-var wordpressTrafficSourceConfigSchema = z29.object({
-  baseUrl: z29.string().url(),
-  username: z29.string().min(1)
+var wordpressTrafficSourceConfigSchema = z30.object({
+  baseUrl: z30.string().url(),
+  username: z30.string().min(1)
 });
-var vercelTrafficEnvironmentSchema = z29.enum(["production", "preview"]);
+var vercelTrafficEnvironmentSchema = z30.enum(["production", "preview"]);
 var VercelTrafficEnvironments = vercelTrafficEnvironmentSchema.enum;
-var vercelTrafficSourceConfigSchema = z29.object({
+var vercelTrafficSourceConfigSchema = z30.object({
   /** Vercel project id (e.g. `prj_...`). */
-  projectId: z29.string().min(1),
+  projectId: z30.string().min(1),
   /** Vercel team or account id: the org that owns the project. */
-  teamId: z29.string().min(1),
+  teamId: z30.string().min(1),
   environment: vercelTrafficEnvironmentSchema
 });
-var trafficSourceDtoSchema = z29.object({
-  id: z29.string(),
-  projectId: z29.string(),
+var trafficSourceDtoSchema = z30.object({
+  id: z30.string(),
+  projectId: z30.string(),
   sourceType: trafficSourceTypeSchema,
-  displayName: z29.string(),
+  displayName: z30.string(),
   status: trafficSourceStatusSchema,
-  lastSyncedAt: z29.string().nullable(),
-  lastCursor: z29.string().nullable(),
-  lastError: z29.string().nullable(),
-  archivedAt: z29.string().nullable(),
-  config: z29.record(z29.string(), z29.unknown()),
-  createdAt: z29.string(),
-  updatedAt: z29.string()
-});
-var trafficConnectCloudRunRequestSchema = z29.object({
-  gcpProjectId: z29.string().min(1),
-  serviceName: z29.string().min(1).optional(),
-  location: z29.string().min(1).optional(),
-  displayName: z29.string().min(1).optional(),
+  lastSyncedAt: z30.string().nullable(),
+  lastCursor: z30.string().nullable(),
+  lastError: z30.string().nullable(),
+  archivedAt: z30.string().nullable(),
+  config: z30.record(z30.string(), z30.unknown()),
+  createdAt: z30.string(),
+  updatedAt: z30.string()
+});
+var trafficConnectCloudRunRequestSchema = z30.object({
+  gcpProjectId: z30.string().min(1),
+  serviceName: z30.string().min(1).optional(),
+  location: z30.string().min(1).optional(),
+  displayName: z30.string().min(1).optional(),
   /** Service-account JSON content (string). When omitted, defaults to OAuth via `canonry google connect <project> --type ga4` flow. */
-  keyJson: z29.string().optional()
+  keyJson: z30.string().optional()
 });
-var trafficConnectWordpressRequestSchema = z29.object({
-  baseUrl: z29.string().url(),
-  username: z29.string().min(1),
+var trafficConnectWordpressRequestSchema = z30.object({
+  baseUrl: z30.string().url(),
+  username: z30.string().min(1),
   /** WordPress Application Password (the same auth used by the content client). */
-  applicationPassword: z29.string().min(1),
-  displayName: z29.string().min(1).optional()
+  applicationPassword: z30.string().min(1),
+  displayName: z30.string().min(1).optional()
 });
-var trafficConnectVercelRequestSchema = z29.object({
+var trafficConnectVercelRequestSchema = z30.object({
   /** Vercel project id (e.g. `prj_...`) — from the Vercel dashboard or `.vercel/project.json`. */
-  projectId: z29.string().min(1),
+  projectId: z30.string().min(1),
   /** Vercel team or account id: the org that owns the project ("orgId" in .vercel/project.json). */
-  teamId: z29.string().min(1),
+  teamId: z30.string().min(1),
   /** Vercel personal access token. Stored in `~/.canonry/config.yaml`, never the DB. */
-  token: z29.string().min(1),
+  token: z30.string().min(1),
   /** Which deployment environment's request logs to pull. Default: `production`. */
   environment: vercelTrafficEnvironmentSchema.optional(),
-  displayName: z29.string().min(1).optional()
+  displayName: z30.string().min(1).optional()
 });
-var trafficSyncResponseSchema = z29.object({
-  sourceId: z29.string(),
-  runId: z29.string(),
-  syncedAt: z29.string(),
-  pulledEvents: z29.number().int().nonnegative(),
+var trafficSyncResponseSchema = z30.object({
+  sourceId: z30.string(),
+  runId: z30.string(),
+  syncedAt: z30.string(),
+  pulledEvents: z30.number().int().nonnegative(),
   /** Self-traffic events (Canonry's own tooling) dropped before rollup. */
-  selfTrafficExcluded: z29.number().int().nonnegative(),
-  crawlerHits: z29.number().int().nonnegative(),
-  aiUserFetchHits: z29.number().int().nonnegative(),
-  aiReferralHits: z29.number().int().nonnegative(),
-  unknownHits: z29.number().int().nonnegative(),
-  crawlerBucketRows: z29.number().int().nonnegative(),
-  aiUserFetchBucketRows: z29.number().int().nonnegative(),
-  aiReferralBucketRows: z29.number().int().nonnegative(),
-  sampleRows: z29.number().int().nonnegative(),
-  windowStart: z29.string(),
-  windowEnd: z29.string()
-});
-var trafficBackfillRequestSchema = z29.object({
+  selfTrafficExcluded: z30.number().int().nonnegative(),
+  crawlerHits: z30.number().int().nonnegative(),
+  aiUserFetchHits: z30.number().int().nonnegative(),
+  aiReferralHits: z30.number().int().nonnegative(),
+  unknownHits: z30.number().int().nonnegative(),
+  crawlerBucketRows: z30.number().int().nonnegative(),
+  aiUserFetchBucketRows: z30.number().int().nonnegative(),
+  aiReferralBucketRows: z30.number().int().nonnegative(),
+  sampleRows: z30.number().int().nonnegative(),
+  windowStart: z30.string(),
+  windowEnd: z30.string()
+});
+var trafficBackfillRequestSchema = z30.object({
   /** Lookback window in days. Capped server-side at the upstream log retention ceiling (Cloud Logging _Default = 30d). Default: 30. */
-  days: z29.number().int().positive().optional()
+  days: z30.number().int().positive().optional()
 });
-var trafficResetRequestSchema = z29.object({
-  advanceToNow: z29.literal(true)
+var trafficResetRequestSchema = z30.object({
+  advanceToNow: z30.literal(true)
 });
-var trafficBackfillResponseSchema = z29.object({
-  sourceId: z29.string(),
-  runId: z29.string(),
+var trafficBackfillResponseSchema = z30.object({
+  sourceId: z30.string(),
+  runId: z30.string(),
   status: runStatusSchema,
-  windowStart: z29.string(),
-  windowEnd: z29.string(),
+  windowStart: z30.string(),
+  windowEnd: z30.string(),
   /** Days actually used after server-side clamping (≤ requested). */
-  daysRequested: z29.number().int().positive(),
-  daysApplied: z29.number().int().positive()
+  daysRequested: z30.number().int().positive(),
+  daysApplied: z30.number().int().positive()
 });
-var trafficSourceTotalsSchema = z29.object({
-  crawlerHits: z29.number().int().nonnegative(),
-  aiUserFetchHits: z29.number().int().nonnegative(),
-  aiReferralHits: z29.number().int().nonnegative(),
-  sampleCount: z29.number().int().nonnegative()
+var trafficSourceTotalsSchema = z30.object({
+  crawlerHits: z30.number().int().nonnegative(),
+  aiUserFetchHits: z30.number().int().nonnegative(),
+  aiReferralHits: z30.number().int().nonnegative(),
+  sampleCount: z30.number().int().nonnegative()
 });
-var trafficSourceListResponseSchema = z29.object({
-  sources: z29.array(trafficSourceDtoSchema)
+var trafficSourceListResponseSchema = z30.object({
+  sources: z30.array(trafficSourceDtoSchema)
 });
 var trafficSourceDetailDtoSchema = trafficSourceDtoSchema.extend({
   totals24h: trafficSourceTotalsSchema,
-  latestRun: z29.object({
-    runId: z29.string(),
+  latestRun: z30.object({
+    runId: z30.string(),
     status: runStatusSchema,
-    startedAt: z29.string().nullable(),
-    finishedAt: z29.string().nullable(),
-    error: z29.string().nullable()
+    startedAt: z30.string().nullable(),
+    finishedAt: z30.string().nullable(),
+    error: z30.string().nullable()
   }).nullable()
 });
-var trafficStatusResponseSchema = z29.object({
-  sources: z29.array(trafficSourceDetailDtoSchema)
+var trafficStatusResponseSchema = z30.object({
+  sources: z30.array(trafficSourceDetailDtoSchema)
 });
-var trafficEventKindSchema = z29.enum(["crawler", "ai-user-fetch", "ai-referral"]);
+var trafficEventKindSchema = z30.enum(["crawler", "ai-user-fetch", "ai-referral"]);
 var TrafficEventKinds = trafficEventKindSchema.enum;
-var trafficCrawlerEventEntrySchema = z29.object({
-  kind: z29.literal(TrafficEventKinds.crawler),
-  sourceId: z29.string(),
-  tsHour: z29.string(),
-  botId: z29.string(),
-  operator: z29.string(),
-  verificationStatus: z29.string(),
-  pathNormalized: z29.string(),
-  status: z29.number().int(),
-  hits: z29.number().int().nonnegative()
-});
-var trafficAiUserFetchEventEntrySchema = z29.object({
-  kind: z29.literal(TrafficEventKinds["ai-user-fetch"]),
-  sourceId: z29.string(),
-  tsHour: z29.string(),
-  botId: z29.string(),
-  operator: z29.string(),
-  verificationStatus: z29.string(),
-  pathNormalized: z29.string(),
-  status: z29.number().int(),
-  hits: z29.number().int().nonnegative()
-});
-var trafficAiReferralEventEntrySchema = z29.object({
-  kind: z29.literal(TrafficEventKinds["ai-referral"]),
-  sourceId: z29.string(),
-  tsHour: z29.string(),
-  product: z29.string(),
-  operator: z29.string(),
-  sourceDomain: z29.string(),
-  evidenceType: z29.string(),
-  landingPathNormalized: z29.string(),
-  status: z29.number().int(),
-  hits: z29.number().int().nonnegative()
-});
-var trafficEventEntrySchema = z29.discriminatedUnion("kind", [
+var trafficCrawlerEventEntrySchema = z30.object({
+  kind: z30.literal(TrafficEventKinds.crawler),
+  sourceId: z30.string(),
+  tsHour: z30.string(),
+  botId: z30.string(),
+  operator: z30.string(),
+  verificationStatus: z30.string(),
+  pathNormalized: z30.string(),
+  status: z30.number().int(),
+  hits: z30.number().int().nonnegative()
+});
+var trafficAiUserFetchEventEntrySchema = z30.object({
+  kind: z30.literal(TrafficEventKinds["ai-user-fetch"]),
+  sourceId: z30.string(),
+  tsHour: z30.string(),
+  botId: z30.string(),
+  operator: z30.string(),
+  verificationStatus: z30.string(),
+  pathNormalized: z30.string(),
+  status: z30.number().int(),
+  hits: z30.number().int().nonnegative()
+});
+var trafficAiReferralEventEntrySchema = z30.object({
+  kind: z30.literal(TrafficEventKinds["ai-referral"]),
+  sourceId: z30.string(),
+  tsHour: z30.string(),
+  product: z30.string(),
+  operator: z30.string(),
+  sourceDomain: z30.string(),
+  evidenceType: z30.string(),
+  landingPathNormalized: z30.string(),
+  status: z30.number().int(),
+  hits: z30.number().int().nonnegative()
+});
+var trafficEventEntrySchema = z30.discriminatedUnion("kind", [
   trafficCrawlerEventEntrySchema,
   trafficAiUserFetchEventEntrySchema,
   trafficAiReferralEventEntrySchema
 ]);
-var trafficEventsResponseSchema = z29.object({
-  windowStart: z29.string(),
-  windowEnd: z29.string(),
-  totals: z29.object({
-    crawlerHits: z29.number().int().nonnegative(),
-    aiUserFetchHits: z29.number().int().nonnegative(),
-    aiReferralHits: z29.number().int().nonnegative()
+var trafficEventsResponseSchema = z30.object({
+  windowStart: z30.string(),
+  windowEnd: z30.string(),
+  totals: z30.object({
+    crawlerHits: z30.number().int().nonnegative(),
+    aiUserFetchHits: z30.number().int().nonnegative(),
+    aiReferralHits: z30.number().int().nonnegative()
   }),
-  events: z29.array(trafficEventEntrySchema)
+  events: z30.array(trafficEventEntrySchema)
 });
 
-// ../contracts/src/embeddings.ts
-function cosineSimilarity(a, b) {
-  if (a.length === 0 || b.length === 0) {
-    throw new Error("cosineSimilarity: vectors must be non-empty");
-  }
-  if (a.length !== b.length) {
-    throw new Error(`cosineSimilarity: vector length mismatch (${a.length} vs ${b.length})`);
-  }
-  let dot = 0;
-  let magA = 0;
-  let magB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    magA += a[i] * a[i];
-    magB += b[i] * b[i];
-  }
-  if (magA === 0 || magB === 0) return 0;
-  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
-}
-function clusterByCosine(items, vectors, threshold) {
-  if (threshold < 0 || threshold > 1) {
-    throw new Error(`clusterByCosine: threshold must be in [0, 1], got ${threshold}`);
-  }
-  if (items.length !== vectors.length) {
-    throw new Error(`clusterByCosine: items/vectors length mismatch (${items.length} vs ${vectors.length})`);
-  }
-  if (items.length === 0) return [];
-  const parent = items.map((_, i) => i);
-  const find = (x) => {
-    let root = x;
-    while (parent[root] !== root) root = parent[root];
-    let cur = x;
-    while (parent[cur] !== root) {
-      const next = parent[cur];
-      parent[cur] = root;
-      cur = next;
-    }
-    return root;
-  };
-  const union = (a, b) => {
-    const ra = find(a);
-    const rb = find(b);
-    if (ra !== rb) parent[ra] = rb;
-  };
-  for (let i = 0; i < items.length; i++) {
-    for (let j = i + 1; j < items.length; j++) {
-      if (cosineSimilarity(vectors[i], vectors[j]) >= threshold) {
-        union(i, j);
-      }
-    }
-  }
-  const byRoot = /* @__PURE__ */ new Map();
-  for (let i = 0; i < items.length; i++) {
-    const root = find(i);
-    const existing = byRoot.get(root);
-    if (existing) existing.push(i);
-    else byRoot.set(root, [i]);
-  }
-  return Array.from(byRoot.values()).map((indices) => indices.map((idx) => items[idx]));
-}
-function pickClusterRepresentative(cluster) {
-  if (cluster.length === 0) throw new Error("pickClusterRepresentative: cluster is empty");
-  let best = cluster[0];
-  for (let i = 1; i < cluster.length; i++) {
-    if (cluster[i].length < best.length) best = cluster[i];
-  }
-  return best;
-}
-
 // ../contracts/src/formatting.ts
 function formatRatio(value) {
   if (!Number.isFinite(value) || value === 0) return "0%";
@@ -4332,6 +4630,12 @@ function formatDateRange(start, end) {
   if (start && end) return `${formatDate(start)} \u2192 ${formatDate(end)}`;
   return formatDate(start || end);
 }
+var DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+function parseInclusiveEndMs(iso) {
+  const ms = Date.parse(iso);
+  if (Number.isNaN(ms)) return null;
+  return DATE_ONLY_PATTERN.test(iso) ? ms + 864e5 - 1 : ms;
+}
 function deltaPercent(current, prior) {
   if (prior <= 0) return null;
   return Math.round((current - prior) / prior * 100);
@@ -4350,105 +4654,105 @@ function formatDeltaCopy(d, suffix, windowLabel = "vs prior 7 days") {
 }
 
 // ../contracts/src/ads.ts
-import { z as z30 } from "zod";
-var adsConnectRequestSchema = z30.object({
+import { z as z31 } from "zod";
+var adsConnectRequestSchema = z31.object({
   /** Ads Manager "SDK key" scoped to one ad account. Stored in config.yaml, never the DB. */
-  apiKey: z30.string().min(1)
-});
-var adsConnectionStatusDtoSchema = z30.object({
-  connected: z30.boolean(),
-  adAccountId: z30.string().nullable().optional(),
-  displayName: z30.string().nullable().optional(),
-  currencyCode: z30.string().nullable().optional(),
-  timezone: z30.string().nullable().optional(),
-  status: z30.string().nullable().optional(),
-  lastSyncedAt: z30.string().nullable().optional()
-});
-var adsDisconnectResponseSchema = z30.object({
-  disconnected: z30.boolean()
-});
-var adsSyncResponseSchema = z30.object({
-  runId: z30.string(),
-  status: z30.string()
-});
-var adsCreativeDtoSchema = z30.object({
-  type: z30.string().nullable().optional(),
-  title: z30.string().nullable().optional(),
-  body: z30.string().nullable().optional(),
-  targetUrl: z30.string().nullable().optional()
-});
-var adsAdDtoSchema = z30.object({
-  id: z30.string(),
-  adGroupId: z30.string(),
-  name: z30.string(),
-  status: z30.string(),
-  reviewStatus: z30.string().nullable().optional(),
+  apiKey: z31.string().min(1)
+});
+var adsConnectionStatusDtoSchema = z31.object({
+  connected: z31.boolean(),
+  adAccountId: z31.string().nullable().optional(),
+  displayName: z31.string().nullable().optional(),
+  currencyCode: z31.string().nullable().optional(),
+  timezone: z31.string().nullable().optional(),
+  status: z31.string().nullable().optional(),
+  lastSyncedAt: z31.string().nullable().optional()
+});
+var adsDisconnectResponseSchema = z31.object({
+  disconnected: z31.boolean()
+});
+var adsSyncResponseSchema = z31.object({
+  runId: z31.string(),
+  status: z31.string()
+});
+var adsCreativeDtoSchema = z31.object({
+  type: z31.string().nullable().optional(),
+  title: z31.string().nullable().optional(),
+  body: z31.string().nullable().optional(),
+  targetUrl: z31.string().nullable().optional()
+});
+var adsAdDtoSchema = z31.object({
+  id: z31.string(),
+  adGroupId: z31.string(),
+  name: z31.string(),
+  status: z31.string(),
+  reviewStatus: z31.string().nullable().optional(),
   creative: adsCreativeDtoSchema.nullable().optional()
 });
-var adsAdGroupDtoSchema = z30.object({
-  id: z30.string(),
-  campaignId: z30.string(),
-  name: z30.string(),
-  status: z30.string(),
-  billingEventType: z30.string().nullable().optional(),
-  maxBidMicros: z30.number().int().nullable().optional(),
+var adsAdGroupDtoSchema = z31.object({
+  id: z31.string(),
+  campaignId: z31.string(),
+  name: z31.string(),
+  status: z31.string(),
+  billingEventType: z31.string().nullable().optional(),
+  maxBidMicros: z31.number().int().nullable().optional(),
   /**
    * The targeting primitive: entries are multi-line strings of
    * newline-separated example queries (the live Ads Manager format).
    */
-  contextHints: z30.array(z30.string()).default([]),
-  ads: z30.array(adsAdDtoSchema).default([])
-});
-var adsCampaignDtoSchema = z30.object({
-  id: z30.string(),
-  name: z30.string(),
-  status: z30.string(),
-  biddingType: z30.string().nullable().optional(),
-  dailySpendLimitMicros: z30.number().int().nullable().optional(),
-  lifetimeSpendLimitMicros: z30.number().int().nullable().optional(),
-  adGroups: z30.array(adsAdGroupDtoSchema).default([])
-});
-var adsCampaignListResponseSchema = z30.object({
-  campaigns: z30.array(adsCampaignDtoSchema)
-});
-var adsInsightLevelSchema = z30.enum(["campaign", "ad_group"]);
+  contextHints: z31.array(z31.string()).default([]),
+  ads: z31.array(adsAdDtoSchema).default([])
+});
+var adsCampaignDtoSchema = z31.object({
+  id: z31.string(),
+  name: z31.string(),
+  status: z31.string(),
+  biddingType: z31.string().nullable().optional(),
+  dailySpendLimitMicros: z31.number().int().nullable().optional(),
+  lifetimeSpendLimitMicros: z31.number().int().nullable().optional(),
+  adGroups: z31.array(adsAdGroupDtoSchema).default([])
+});
+var adsCampaignListResponseSchema = z31.object({
+  campaigns: z31.array(adsCampaignDtoSchema)
+});
+var adsInsightLevelSchema = z31.enum(["campaign", "ad_group"]);
 var AdsInsightLevels = adsInsightLevelSchema.enum;
-var adsInsightRowDtoSchema = z30.object({
+var adsInsightRowDtoSchema = z31.object({
   level: adsInsightLevelSchema,
-  entityId: z30.string(),
-  date: z30.string(),
-  impressions: z30.number().int(),
-  clicks: z30.number().int(),
-  spendMicros: z30.number().int(),
+  entityId: z31.string(),
+  date: z31.string(),
+  impressions: z31.number().int(),
+  clicks: z31.number().int(),
+  spendMicros: z31.number().int(),
   /** clicks / impressions; null when impressions is 0. */
-  ctr: z30.number().nullable(),
+  ctr: z31.number().nullable(),
   /** spendMicros / clicks, rounded to integer micros; null when clicks is 0. */
-  cpcMicros: z30.number().int().nullable()
+  cpcMicros: z31.number().int().nullable()
 });
-var adsInsightsResponseSchema = z30.object({
-  rows: z30.array(adsInsightRowDtoSchema),
+var adsInsightsResponseSchema = z31.object({
+  rows: z31.array(adsInsightRowDtoSchema),
   /** Account currency for rendering spend/cpc; null before the first sync. */
-  currencyCode: z30.string().nullable().optional()
-});
-var adsTotalsDtoSchema = z30.object({
-  impressions: z30.number().int(),
-  clicks: z30.number().int(),
-  spendMicros: z30.number().int(),
-  ctr: z30.number().nullable(),
-  cpcMicros: z30.number().int().nullable()
-});
-var adsSummaryDtoSchema = z30.object({
-  connected: z30.boolean(),
-  displayName: z30.string().nullable().optional(),
-  currencyCode: z30.string().nullable().optional(),
-  lastSyncedAt: z30.string().nullable().optional(),
-  campaignCount: z30.number().int(),
-  adGroupCount: z30.number().int(),
-  adCount: z30.number().int(),
+  currencyCode: z31.string().nullable().optional()
+});
+var adsTotalsDtoSchema = z31.object({
+  impressions: z31.number().int(),
+  clicks: z31.number().int(),
+  spendMicros: z31.number().int(),
+  ctr: z31.number().nullable(),
+  cpcMicros: z31.number().int().nullable()
+});
+var adsSummaryDtoSchema = z31.object({
+  connected: z31.boolean(),
+  displayName: z31.string().nullable().optional(),
+  currencyCode: z31.string().nullable().optional(),
+  lastSyncedAt: z31.string().nullable().optional(),
+  campaignCount: z31.number().int(),
+  adGroupCount: z31.number().int(),
+  adCount: z31.number().int(),
   /** Date range the totals cover (oldest/newest rollup date), null when empty. */
-  window: z30.object({
-    from: z30.string().nullable(),
-    to: z30.string().nullable()
+  window: z31.object({
+    from: z31.string().nullable(),
+    to: z31.string().nullable()
   }),
   /** Campaign-level rollup totals over the window (levels are not summed across). */
   totals: adsTotalsDtoSchema
@@ -4659,6 +4963,11 @@ export {
   categorizeSource,
   categorizeSourceWithCompetitors,
   categoryLabel,
+  clusterByCosine,
+  pickClusterRepresentative,
+  absolutizeProjectUrl,
+  hostOf,
+  normalizeUrlPath,
   discoveryBucketSchema,
   DiscoveryBuckets,
   DEFAULT_DISCOVERY_PROMOTE_BUCKETS,
@@ -4677,6 +4986,11 @@ export {
   discoveryPromoteRequestSchema,
   discoveryPromotePreviewSchema,
   discoveryPromoteResultSchema,
+  discoveryHarvestDtoSchema,
+  buildHarvestAnchorTerms,
+  gateHarvestedSearchQueries,
+  applyHarvestSemanticNovelty,
+  aggregateHarvestedQueries,
   surfaceClassLabel,
   surfaceClassFromCompetitorType,
   classifySurfaceFromCategory,
@@ -4685,6 +4999,7 @@ export {
   sourceBreakdownDtoSchema,
   parseWindow,
   windowCutoff,
+  visibilityStatsDtoSchema,
   ga4StatusDtoSchema,
   ga4SyncResponseDtoSchema,
   ga4AiReferralHistoryEntrySchema,
@@ -4737,9 +5052,6 @@ export {
   CheckCategories,
   doctorReportSchema,
   summarizeCheckResults,
-  absolutizeProjectUrl,
-  hostOf,
-  normalizeUrlPath,
   citationVisibilityResponseSchema,
   emptyCitationVisibility,
   citationStateToCited,
@@ -4776,13 +5088,12 @@ export {
   trafficEventKindSchema,
   TrafficEventKinds,
   trafficEventsResponseSchema,
-  clusterByCosine,
-  pickClusterRepresentative,
   formatRatio,
   formatNumber,
   formatDate,
   formatIsoDate,
   formatDateRange,
+  parseInclusiveEndMs,
   deltaPercent,
   deltaTone,
   formatDeltaCopy,