@ainyc/canonry 4.71.0 → 4.72.0

package/dist/{chunk-5FM7QRYD.js → chunk-SJI6JGPN.js}

@@ -1561,56 +1561,24 @@ var scheduleUpsertRequestSchema = z14.object({
 );
 
 // ../contracts/src/analytics.ts
-import { z as z15 } from "zod";
-var metricsWindowSchema = z15.enum(["7d", "30d", "90d", "all"]);
-var trendDirectionSchema = z15.enum(["improving", "declining", "stable"]);
-var visibilityMetricModeSchema = z15.enum(["mentioned", "cited"]);
-var VisibilityMetricModes = visibilityMetricModeSchema.enum;
-var providerMetricSchema = z15.object({
-  citationRate: z15.number(),
-  cited: z15.number().int(),
-  total: z15.number().int(),
-  mentionRate: z15.number(),
-  mentionedCount: z15.number().int()
-});
-var timeBucketSchema = z15.object({
-  startDate: z15.string(),
-  endDate: z15.string(),
-  citationRate: z15.number(),
-  cited: z15.number().int(),
-  total: z15.number().int(),
-  queryCount: z15.number().int(),
-  mentionRate: z15.number(),
-  mentionedCount: z15.number().int(),
-  byProvider: z15.record(z15.string(), providerMetricSchema)
-});
-var queryChangeEventSchema = z15.object({
-  date: z15.string(),
-  delta: z15.number().int(),
-  label: z15.string()
-});
-var brandMetricsDtoSchema = z15.object({
-  window: metricsWindowSchema,
-  buckets: z15.array(timeBucketSchema),
-  overall: providerMetricSchema,
-  byProvider: z15.record(z15.string(), providerMetricSchema),
-  trend: trendDirectionSchema,
-  mentionTrend: trendDirectionSchema,
-  queryChanges: z15.array(queryChangeEventSchema)
-});
-function parseWindow(value) {
-  if (value === "7d" || value === "30d" || value === "90d" || value === "all") return value;
-  return "all";
-}
-function windowCutoff(window) {
-  if (window === "all") return null;
-  const days = window === "7d" ? 7 : window === "30d" ? 30 : 90;
-  const d = /* @__PURE__ */ new Date();
-  d.setDate(d.getDate() - days);
-  return d.toISOString();
-}
+import { z as z18 } from "zod";
 
 // ../contracts/src/source-categories.ts
+import { z as z15 } from "zod";
+var sourceCategorySchema = z15.enum([
+  "competitor",
+  "directory",
+  "social",
+  "forum",
+  "news",
+  "reference",
+  "blog",
+  "ecommerce",
+  "video",
+  "academic",
+  "other"
+]);
+var SourceCategories = sourceCategorySchema.enum;
 var SOURCE_CATEGORY_RULES = [
   // Directories, marketplaces & review platforms — generic across industries.
   // Industry-specific directories (NRCA, GAF, etc.) intentionally omitted;
@@ -1635,6 +1603,21 @@ var SOURCE_CATEGORY_RULES = [
   { pattern: "producthunt.com", category: "directory", label: "Product Hunt" },
   { pattern: "glassdoor.com", category: "directory", label: "Glassdoor" },
   { pattern: "indeed.com", category: "directory", label: "Indeed" },
+  // Major GLOBAL travel / lodging / dining aggregators (OTAs). Included
+  // because — unlike niche per-vertical directories (NRCA, GAF) which are
+  // deliberately omitted — these are top-tier cross-business marketplaces in
+  // the same class as Yelp/Angi, and AEO for hospitality routinely competes
+  // against them. They classify as `ota-aggregator` surfaces (see #675).
+  { pattern: "tripadvisor.com", category: "directory", label: "Tripadvisor" },
+  { pattern: "booking.com", category: "directory", label: "Booking.com" },
+  { pattern: "expedia.com", category: "directory", label: "Expedia" },
+  { pattern: "hotels.com", category: "directory", label: "Hotels.com" },
+  { pattern: "agoda.com", category: "directory", label: "Agoda" },
+  { pattern: "kayak.com", category: "directory", label: "Kayak" },
+  { pattern: "trivago.com", category: "directory", label: "Trivago" },
+  { pattern: "airbnb.com", category: "directory", label: "Airbnb" },
+  { pattern: "vrbo.com", category: "directory", label: "Vrbo" },
+  { pattern: "opentable.com", category: "directory", label: "OpenTable" },
   // Forums
   { pattern: "reddit.com", category: "forum", label: "Reddit" },
   { pattern: "quora.com", category: "forum", label: "Quora" },
@@ -1734,30 +1717,312 @@ function categoryLabel(category) {
   return CATEGORY_LABELS[category];
 }
 
-// ../contracts/src/ga.ts
+// ../contracts/src/surface-class.ts
+import { z as z17 } from "zod";
+
+// ../contracts/src/discovery.ts
 import { z as z16 } from "zod";
-var ga4ConnectionDtoSchema = z16.object({
+var discoveryBucketSchema = z16.enum(["cited", "aspirational", "wasted-surface"]);
+var DiscoveryBuckets = discoveryBucketSchema.enum;
+var DEFAULT_DISCOVERY_PROMOTE_BUCKETS = [
+  DiscoveryBuckets.cited,
+  DiscoveryBuckets.aspirational
+];
+var DISCOVERY_PROMOTE_COMPETITOR_CAP = 20;
+var DISCOVERY_PROMOTE_COMPETITOR_MIN_HITS = 2;
+var discoveryCompetitorTypeSchema = z16.enum([
+  "direct-competitor",
+  "ota-aggregator",
+  "editorial-media",
+  "other",
+  "unknown"
+]);
+var DiscoveryCompetitorTypes = discoveryCompetitorTypeSchema.enum;
+var DEFAULT_DISCOVERY_PROMOTE_COMPETITOR_TYPES = [
+  DiscoveryCompetitorTypes["direct-competitor"]
+];
+var discoverySessionStatusSchema = z16.enum(["queued", "seeding", "probing", "completed", "failed"]);
+var DiscoverySessionStatuses = discoverySessionStatusSchema.enum;
+var discoveryCompetitorMapEntrySchema = z16.object({
+  domain: z16.string().min(1),
+  hits: z16.number().int().positive(),
+  /**
+   * Domain classification from the session's post-probe AI classification
+   * pass. Defaults to `unknown` so competitor maps persisted before
+   * classification existed (or by a session whose classification call failed)
+   * still parse — those entries are excluded from the default promote filter.
+   */
+  competitorType: discoveryCompetitorTypeSchema.default("unknown")
+});
+var discoveryProbeDtoSchema = z16.object({
   id: z16.string(),
+  sessionId: z16.string(),
   projectId: z16.string(),
-  propertyId: z16.string(),
-  clientEmail: z16.string(),
-  connected: z16.boolean(),
-  createdAt: z16.string(),
-  updatedAt: z16.string()
-});
-var ga4TrafficSnapshotDtoSchema = z16.object({
-  date: z16.string(),
-  landingPage: z16.string(),
-  sessions: z16.number(),
-  organicSessions: z16.number(),
-  users: z16.number()
-});
-var ga4SourceDimensionSchema = z16.enum(["session", "first_user", "manual_utm"]);
-var ga4AiReferralDtoSchema = z16.object({
-  source: z16.string(),
-  medium: z16.string(),
-  sessions: z16.number(),
-  users: z16.number(),
+  query: z16.string(),
+  bucket: discoveryBucketSchema.nullable().default(null),
+  citationState: citationStateSchema,
+  citedDomains: z16.array(z16.string()).default([]),
+  createdAt: z16.string()
+});
+var discoverySessionDtoSchema = z16.object({
+  id: z16.string(),
+  projectId: z16.string(),
+  status: discoverySessionStatusSchema,
+  icpDescription: z16.string().nullable().optional(),
+  seedProvider: z16.string().nullable().optional(),
+  seedCountRaw: z16.number().int().nullable().optional(),
+  seedCount: z16.number().int().nullable().optional(),
+  dedupThreshold: z16.number().nullable().optional(),
+  probeCount: z16.number().int().nullable().optional(),
+  citedCount: z16.number().int().nullable().default(null),
+  aspirationalCount: z16.number().int().nullable().default(null),
+  wastedCount: z16.number().int().nullable().default(null),
+  competitorMap: z16.array(discoveryCompetitorMapEntrySchema).default([]),
+  error: z16.string().nullable().optional(),
+  startedAt: z16.string().nullable().optional(),
+  finishedAt: z16.string().nullable().optional(),
+  createdAt: z16.string()
+});
+var discoverySessionDetailDtoSchema = discoverySessionDtoSchema.extend({
+  probes: z16.array(discoveryProbeDtoSchema).default([])
+});
+var DISCOVERY_MAX_PROBES_CAP = 500;
+var discoveryRunRequestSchema = z16.object({
+  icpDescription: z16.string().min(1).optional(),
+  dedupThreshold: z16.number().min(0).max(1).optional(),
+  maxProbes: z16.number().int().positive().max(DISCOVERY_MAX_PROBES_CAP).optional(),
+  /**
+   * Optional override of the project's location labels, constraining seed
+   * generation to a subset of the configured service areas. Each label must
+   * match a configured project location (resolved server-side via
+   * `resolveLocations`). Omitted means "use every project location" — a
+   * project with no locations is unaffected.
+   */
+  locations: z16.array(z16.string().min(1)).optional()
+});
+var discoveryPromoteRequestSchema = z16.object({
+  buckets: z16.array(discoveryBucketSchema).min(1).optional(),
+  includeCompetitors: z16.boolean().optional(),
+  competitorTypes: z16.array(discoveryCompetitorTypeSchema).min(1).optional()
+});
+var discoveryPromotePreviewSchema = z16.object({
+  sessionId: z16.string(),
+  projectId: z16.string(),
+  status: discoverySessionStatusSchema,
+  queriesByBucket: z16.object({
+    cited: z16.array(z16.string()),
+    aspirational: z16.array(z16.string()),
+    "wasted-surface": z16.array(z16.string())
+  }),
+  suggestedCompetitors: z16.array(discoveryCompetitorMapEntrySchema)
+});
+var discoveryPromoteResultSchema = z16.object({
+  sessionId: z16.string(),
+  projectId: z16.string(),
+  promoted: z16.object({
+    queries: z16.array(z16.string()),
+    competitors: z16.array(z16.string())
+  }),
+  skipped: z16.object({
+    queries: z16.array(z16.string()),
+    competitors: z16.array(z16.string())
+  })
+});
+var queryProvenanceSchema = z16.union([
+  z16.literal("cli"),
+  z16.string().regex(/^discovery:.+$/)
+]);
+
+// ../contracts/src/surface-class.ts
+var surfaceClassSchema = z17.enum([
+  "own",
+  "direct-competitor",
+  "ota-aggregator",
+  "editorial-media",
+  "other"
+]);
+var SurfaceClasses = surfaceClassSchema.enum;
+var SURFACE_CLASS_LABELS = {
+  own: "Your domains",
+  "direct-competitor": "Direct competitors",
+  "ota-aggregator": "Aggregators & marketplaces",
+  "editorial-media": "Editorial & media",
+  other: "Other sources"
+};
+function surfaceClassLabel(surfaceClass) {
+  return SURFACE_CLASS_LABELS[surfaceClass];
+}
+function surfaceClassFromCompetitorType(type) {
+  switch (type) {
+    case DiscoveryCompetitorTypes["direct-competitor"]:
+      return SurfaceClasses["direct-competitor"];
+    case DiscoveryCompetitorTypes["ota-aggregator"]:
+      return SurfaceClasses["ota-aggregator"];
+    case DiscoveryCompetitorTypes["editorial-media"]:
+      return SurfaceClasses["editorial-media"];
+    case DiscoveryCompetitorTypes.other:
+      return SurfaceClasses.other;
+    case DiscoveryCompetitorTypes.unknown:
+      return void 0;
+  }
+}
+function matchesAnyDomain(candidate, domains) {
+  if (!candidate) return false;
+  for (const domain of domains) {
+    const normalized = normalizeProjectDomain(domain);
+    if (!normalized) continue;
+    if (candidate === normalized || candidate.endsWith(`.${normalized}`)) return true;
+  }
+  return false;
+}
+function classifySurfaceFromCategory(domain, category, context, storedClass) {
+  const candidate = normalizeProjectDomain(domain);
+  if (matchesAnyDomain(candidate, context.projectDomains)) return SurfaceClasses.own;
+  if (matchesAnyDomain(candidate, context.competitorDomains)) return SurfaceClasses["direct-competitor"];
+  if (storedClass) return storedClass;
+  switch (category) {
+    case "directory":
+    case "ecommerce":
+      return SurfaceClasses["ota-aggregator"];
+    case "news":
+    case "blog":
+    case "reference":
+      return SurfaceClasses["editorial-media"];
+    case "competitor":
+      return SurfaceClasses["direct-competitor"];
+    case "social":
+    case "forum":
+    case "video":
+    case "academic":
+    case "other":
+      return SurfaceClasses.other;
+  }
+}
+
+// ../contracts/src/analytics.ts
+var metricsWindowSchema = z18.enum(["7d", "30d", "90d", "all"]);
+var trendDirectionSchema = z18.enum(["improving", "declining", "stable"]);
+var visibilityMetricModeSchema = z18.enum(["mentioned", "cited"]);
+var VisibilityMetricModes = visibilityMetricModeSchema.enum;
+var providerMetricSchema = z18.object({
+  citationRate: z18.number(),
+  cited: z18.number().int(),
+  total: z18.number().int(),
+  mentionRate: z18.number(),
+  mentionedCount: z18.number().int()
+});
+var timeBucketSchema = z18.object({
+  startDate: z18.string(),
+  endDate: z18.string(),
+  citationRate: z18.number(),
+  cited: z18.number().int(),
+  total: z18.number().int(),
+  queryCount: z18.number().int(),
+  mentionRate: z18.number(),
+  mentionedCount: z18.number().int(),
+  byProvider: z18.record(z18.string(), providerMetricSchema)
+});
+var queryChangeEventSchema = z18.object({
+  date: z18.string(),
+  delta: z18.number().int(),
+  label: z18.string()
+});
+var brandMetricsDtoSchema = z18.object({
+  window: metricsWindowSchema,
+  buckets: z18.array(timeBucketSchema),
+  overall: providerMetricSchema,
+  byProvider: z18.record(z18.string(), providerMetricSchema),
+  trend: trendDirectionSchema,
+  mentionTrend: trendDirectionSchema,
+  queryChanges: z18.array(queryChangeEventSchema)
+});
+var sourceCategoryCountSchema = z18.object({
+  category: sourceCategorySchema,
+  label: z18.string(),
+  count: z18.number().int(),
+  /** Share of all cited slots in scope, 0..1 (4dp). */
+  percentage: z18.number(),
+  topDomains: z18.array(z18.object({ domain: z18.string(), count: z18.number().int() }))
+});
+var sourceRankEntrySchema = z18.object({
+  domain: z18.string(),
+  count: z18.number().int(),
+  /** Share of the list's `totalCitedSlots`, 0..1 (4dp). */
+  percentage: z18.number(),
+  category: sourceCategorySchema,
+  label: z18.string(),
+  surfaceClass: surfaceClassSchema
+});
+var surfaceClassCountSchema = z18.object({
+  surfaceClass: surfaceClassSchema,
+  label: z18.string(),
+  count: z18.number().int(),
+  /** Share of the list's `totalCitedSlots`, 0..1 (4dp). */
+  percentage: z18.number(),
+  domainCount: z18.number().int()
+});
+var rankedSourceListSchema = z18.object({
+  /** Total cited slots (grounding citations) counted in this scope. */
+  totalCitedSlots: z18.number().int(),
+  /** Distinct domains in this scope. */
+  domainTotal: z18.number().int(),
+  /** Ranked domains, desc by count; truncated to the applied limit if any. */
+  entries: z18.array(sourceRankEntrySchema),
+  /** Distinct domains beyond the limit (0 when full). */
+  truncatedDomainCount: z18.number().int(),
+  /** Cited slots beyond the limit (0 when full). */
+  truncatedCitedSlots: z18.number().int(),
+  /** Surface-class roll-up over the FULL scope (not just `entries`). */
+  bySurfaceClass: z18.array(surfaceClassCountSchema)
+});
+var sourceBreakdownDtoSchema = z18.object({
+  overall: z18.array(sourceCategoryCountSchema),
+  byQuery: z18.record(z18.string(), z18.array(sourceCategoryCountSchema)),
+  /** Full ranked + classified cited-domain list across all providers (#675). */
+  ranked: rankedSourceListSchema,
+  /** Per-provider ranked + classified breakdown, keyed by provider name (#675). */
+  byProvider: z18.record(z18.string(), rankedSourceListSchema),
+  runId: z18.string(),
+  window: metricsWindowSchema,
+  /** Applied ranked-list limit; null when the full list is returned. */
+  limit: z18.number().int().nullable()
+});
+function parseWindow(value) {
+  if (value === "7d" || value === "30d" || value === "90d" || value === "all") return value;
+  return "all";
+}
+function windowCutoff(window) {
+  if (window === "all") return null;
+  const days = window === "7d" ? 7 : window === "30d" ? 30 : 90;
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() - days);
+  return d.toISOString();
+}
+
+// ../contracts/src/ga.ts
+import { z as z19 } from "zod";
+var ga4ConnectionDtoSchema = z19.object({
+  id: z19.string(),
+  projectId: z19.string(),
+  propertyId: z19.string(),
+  clientEmail: z19.string(),
+  connected: z19.boolean(),
+  createdAt: z19.string(),
+  updatedAt: z19.string()
+});
+var ga4TrafficSnapshotDtoSchema = z19.object({
+  date: z19.string(),
+  landingPage: z19.string(),
+  sessions: z19.number(),
+  organicSessions: z19.number(),
+  users: z19.number()
+});
+var ga4SourceDimensionSchema = z19.enum(["session", "first_user", "manual_utm"]);
+var ga4AiReferralDtoSchema = z19.object({
+  source: z19.string(),
+  medium: z19.string(),
+  sessions: z19.number(),
+  users: z19.number(),
   /**
    * The winning attribution dimension for this (source, medium) tuple — the
    * one with the highest session count. GA4 emits one row per dimension
@@ -1767,144 +2032,144 @@ var ga4AiReferralDtoSchema = z16.object({
    */
   sourceDimension: ga4SourceDimensionSchema
 });
-var ga4AiReferralLandingPageDtoSchema = z16.object({
-  source: z16.string(),
-  medium: z16.string(),
+var ga4AiReferralLandingPageDtoSchema = z19.object({
+  source: z19.string(),
+  medium: z19.string(),
   /**
    * The winning attribution dimension for this (source, medium, landingPage)
    * tuple — the one with the highest session count.
    */
   sourceDimension: ga4SourceDimensionSchema,
-  landingPage: z16.string(),
-  sessions: z16.number(),
-  users: z16.number()
-});
-var ga4SocialReferralDtoSchema = z16.object({
-  source: z16.string(),
-  medium: z16.string(),
-  sessions: z16.number(),
-  users: z16.number(),
+  landingPage: z19.string(),
+  sessions: z19.number(),
+  users: z19.number()
+});
+var ga4SocialReferralDtoSchema = z19.object({
+  source: z19.string(),
+  medium: z19.string(),
+  sessions: z19.number(),
+  users: z19.number(),
   /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: z16.string()
+  channelGroup: z19.string()
 });
-var ga4ChannelBucketDtoSchema = z16.object({
-  sessions: z16.number(),
-  sharePct: z16.number(),
-  sharePctDisplay: z16.string()
+var ga4ChannelBucketDtoSchema = z19.object({
+  sessions: z19.number(),
+  sharePct: z19.number(),
+  sharePctDisplay: z19.string()
 });
-var ga4ChannelBreakdownDtoSchema = z16.object({
+var ga4ChannelBreakdownDtoSchema = z19.object({
   organic: ga4ChannelBucketDtoSchema,
   social: ga4ChannelBucketDtoSchema,
   direct: ga4ChannelBucketDtoSchema,
   ai: ga4ChannelBucketDtoSchema,
   other: ga4ChannelBucketDtoSchema
 });
-var ga4TrafficSummaryDtoSchema = z16.object({
-  totalSessions: z16.number(),
-  totalOrganicSessions: z16.number(),
+var ga4TrafficSummaryDtoSchema = z19.object({
+  totalSessions: z19.number(),
+  totalOrganicSessions: z19.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: z16.number(),
-  totalUsers: z16.number(),
-  topPages: z16.array(z16.object({
-    landingPage: z16.string(),
-    sessions: z16.number(),
-    organicSessions: z16.number(),
+  totalDirectSessions: z19.number(),
+  totalUsers: z19.number(),
+  topPages: z19.array(z19.object({
+    landingPage: z19.string(),
+    sessions: z19.number(),
+    organicSessions: z19.number(),
     /** Per-page Direct-channel sessions. 0 for legacy rows. */
-    directSessions: z16.number(),
-    users: z16.number()
+    directSessions: z19.number(),
+    users: z19.number()
   })),
-  aiReferrals: z16.array(ga4AiReferralDtoSchema),
-  aiReferralLandingPages: z16.array(ga4AiReferralLandingPageDtoSchema),
+  aiReferrals: z19.array(ga4AiReferralDtoSchema),
+  aiReferralLandingPages: z19.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: z16.number(),
+  aiSessionsDeduped: z19.number(),
   /** Deduped AI user total: MAX(users) per date+source+medium across attribution dimensions, then summed. */
-  aiUsersDeduped: z16.number(),
+  aiUsersDeduped: z19.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: z16.number(),
+  aiSessionsBySession: z19.number(),
   /** AI users whose CURRENT sessionSource matched an AI engine. Can overlap with raw Organic/Social/Direct totals. */
-  aiUsersBySession: z16.number(),
-  socialReferrals: z16.array(ga4SocialReferralDtoSchema),
+  aiUsersBySession: z19.number(),
+  socialReferrals: z19.array(ga4SocialReferralDtoSchema),
   /** Total social sessions (session-scoped, no cross-dimension dedup needed). */
-  socialSessions: z16.number(),
+  socialSessions: z19.number(),
   /** Total social users (session-scoped, no cross-dimension dedup needed). */
-  socialUsers: z16.number(),
+  socialUsers: z19.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: z16.number(),
+  organicSharePct: z19.number(),
   /** Deduped AI sessions as a percentage of total sessions (0–100, rounded). Cross-cutting: can overlap with Direct/Organic/Social. */
-  aiSharePct: z16.number(),
+  aiSharePct: z19.number(),
   /** Session-source-only AI sessions as a percentage of total sessions (0–100, rounded). Can overlap with raw Organic/Social/Direct totals. */
-  aiSharePctBySession: z16.number(),
+  aiSharePctBySession: z19.number(),
   /** Direct-channel sessions as a percentage of total sessions (0–100, rounded). */
-  directSharePct: z16.number(),
+  directSharePct: z19.number(),
   /** Social sessions as a percentage of total sessions (0–100, rounded). */
-  socialSharePct: z16.number(),
+  socialSharePct: z19.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: z16.string(),
+  organicSharePctDisplay: z19.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: z16.string(),
+  aiSharePctDisplay: z19.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: z16.string(),
+  aiSharePctBySessionDisplay: z19.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: z16.string(),
+  directSharePctDisplay: z19.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: z16.string(),
+  socialSharePctDisplay: z19.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: z16.number(),
+  otherSessions: z19.number(),
   /** Other sessions as a percentage of total sessions (0–100, rounded). */
-  otherSharePct: z16.number(),
+  otherSharePct: z19.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: z16.string(),
-  lastSyncedAt: z16.string().nullable()
-});
-var ga4StatusDtoSchema = z16.object({
-  connected: z16.boolean(),
-  propertyId: z16.string().nullable(),
-  clientEmail: z16.string().nullable(),
-  authMethod: z16.enum(["service-account", "oauth"]).nullable(),
-  lastSyncedAt: z16.string().nullable(),
-  createdAt: z16.string().nullable().optional(),
-  updatedAt: z16.string().nullable().optional()
-});
-var ga4SyncResponseDtoSchema = z16.object({
-  synced: z16.boolean(),
-  rowCount: z16.number().int().nonnegative(),
-  aiReferralCount: z16.number().int().nonnegative(),
-  socialReferralCount: z16.number().int().nonnegative(),
-  days: z16.number().int().nonnegative(),
-  syncedAt: z16.string(),
+  otherSharePctDisplay: z19.string(),
+  lastSyncedAt: z19.string().nullable()
+});
+var ga4StatusDtoSchema = z19.object({
+  connected: z19.boolean(),
+  propertyId: z19.string().nullable(),
+  clientEmail: z19.string().nullable(),
+  authMethod: z19.enum(["service-account", "oauth"]).nullable(),
+  lastSyncedAt: z19.string().nullable(),
+  createdAt: z19.string().nullable().optional(),
+  updatedAt: z19.string().nullable().optional()
+});
+var ga4SyncResponseDtoSchema = z19.object({
+  synced: z19.boolean(),
+  rowCount: z19.number().int().nonnegative(),
+  aiReferralCount: z19.number().int().nonnegative(),
+  socialReferralCount: z19.number().int().nonnegative(),
+  days: z19.number().int().nonnegative(),
+  syncedAt: z19.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: z16.array(z16.string()).optional()
-});
-var ga4AiReferralHistoryEntrySchema = z16.object({
-  date: z16.string(),
-  source: z16.string(),
-  medium: z16.string(),
-  landingPage: z16.string(),
-  sessions: z16.number(),
-  users: z16.number(),
+  syncedComponents: z19.array(z19.string()).optional()
+});
+var ga4AiReferralHistoryEntrySchema = z19.object({
+  date: z19.string(),
+  source: z19.string(),
+  medium: z19.string(),
+  landingPage: z19.string(),
+  sessions: z19.number(),
+  users: z19.number(),
   /** Which GA4 dimension this row came from: session (sessionSource), first_user (firstUserSource), or manual_utm (utm_source parameter) */
   sourceDimension: ga4SourceDimensionSchema
 });
-var ga4SocialReferralHistoryEntrySchema = z16.object({
-  date: z16.string(),
-  source: z16.string(),
-  medium: z16.string(),
-  sessions: z16.number(),
-  users: z16.number(),
+var ga4SocialReferralHistoryEntrySchema = z19.object({
+  date: z19.string(),
+  source: z19.string(),
+  medium: z19.string(),
+  sessions: z19.number(),
+  users: z19.number(),
   /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: z16.string()
+  channelGroup: z19.string()
 });
-var ga4SessionHistoryEntrySchema = z16.object({
-  date: z16.string(),
-  sessions: z16.number(),
-  organicSessions: z16.number(),
-  users: z16.number()
+var ga4SessionHistoryEntrySchema = z19.object({
+  date: z19.string(),
+  sessions: z19.number(),
+  organicSessions: z19.number(),
+  users: z19.number()
 });
 
 // ../contracts/src/answer-visibility.ts
@@ -2072,149 +2337,149 @@ function escapeRegExp(value) {
 }
 
 // ../contracts/src/agent.ts
-import { z as z17 } from "zod";
-var agentProviderIdSchema = z17.enum(["claude", "openai", "gemini", "zai"]);
-var agentProviderOptionDtoSchema = z17.object({
+import { z as z20 } from "zod";
+var agentProviderIdSchema = z20.enum(["claude", "openai", "gemini", "zai"]);
+var agentProviderOptionDtoSchema = z20.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: z17.string(),
+  label: z20.string(),
   /** Default model if the caller doesn't pick one. */
-  defaultModel: z17.string(),
+  defaultModel: z20.string(),
   /** Whether a usable API key was found (config.yaml or provider env var). */
-  configured: z17.boolean(),
+  configured: z20.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: z17.enum(["config", "env"]).nullable()
+  keySource: z20.enum(["config", "env"]).nullable()
 });
-var agentProvidersResponseDtoSchema = z17.object({
+var agentProvidersResponseDtoSchema = z20.object({
   /**
    * Every provider Aero knows about. `configured === false` entries are
    * included so the UI can render them disabled with an onboarding hint.
    */
-  providers: z17.array(agentProviderOptionDtoSchema).default([]),
+  providers: z20.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 = z17.enum(["aero", "user", "compaction"]);
+var memorySourceSchema = z20.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 = z17.object({
-  key: z17.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH),
-  value: z17.string().min(1)
+var agentMemoryUpsertRequestSchema = z20.object({
+  key: z20.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH),
+  value: z20.string().min(1)
 });
-var agentMemoryDeleteRequestSchema = z17.object({
-  key: z17.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH)
+var agentMemoryDeleteRequestSchema = z20.object({
+  key: z20.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH)
 });
 
 // ../contracts/src/backlinks.ts
-import { z as z18 } from "zod";
-var ccReleaseSyncStatusSchema = z18.enum(["queued", "downloading", "querying", "ready", "failed"]);
+import { z as z21 } from "zod";
+var ccReleaseSyncStatusSchema = z21.enum(["queued", "downloading", "querying", "ready", "failed"]);
 var CcReleaseSyncStatuses = ccReleaseSyncStatusSchema.enum;
-var ccReleaseSyncDtoSchema = z18.object({
-  id: z18.string(),
-  release: z18.string(),
+var ccReleaseSyncDtoSchema = z21.object({
+  id: z21.string(),
+  release: z21.string(),
   status: ccReleaseSyncStatusSchema,
-  phaseDetail: z18.string().nullable().optional(),
-  vertexPath: z18.string().nullable().optional(),
-  edgesPath: z18.string().nullable().optional(),
-  vertexSha256: z18.string().nullable().optional(),
-  edgesSha256: z18.string().nullable().optional(),
-  vertexBytes: z18.number().int().nullable().optional(),
-  edgesBytes: z18.number().int().nullable().optional(),
-  projectsProcessed: z18.number().int().nullable().optional(),
-  domainsDiscovered: z18.number().int().nullable().optional(),
-  downloadStartedAt: z18.string().nullable().optional(),
-  downloadFinishedAt: z18.string().nullable().optional(),
-  queryStartedAt: z18.string().nullable().optional(),
-  queryFinishedAt: z18.string().nullable().optional(),
-  error: z18.string().nullable().optional(),
-  createdAt: z18.string(),
-  updatedAt: z18.string()
-});
-var backlinkDomainDtoSchema = z18.object({
-  linkingDomain: z18.string(),
-  numHosts: z18.number().int()
-});
-var backlinkSummaryDtoSchema = z18.object({
-  projectId: z18.string(),
-  release: z18.string(),
-  targetDomain: z18.string(),
-  totalLinkingDomains: z18.number().int(),
-  totalHosts: z18.number().int(),
-  top10HostsShare: z18.string(),
-  queriedAt: z18.string(),
+  phaseDetail: z21.string().nullable().optional(),
+  vertexPath: z21.string().nullable().optional(),
+  edgesPath: z21.string().nullable().optional(),
+  vertexSha256: z21.string().nullable().optional(),
+  edgesSha256: z21.string().nullable().optional(),
+  vertexBytes: z21.number().int().nullable().optional(),
+  edgesBytes: z21.number().int().nullable().optional(),
+  projectsProcessed: z21.number().int().nullable().optional(),
+  domainsDiscovered: z21.number().int().nullable().optional(),
+  downloadStartedAt: z21.string().nullable().optional(),
+  downloadFinishedAt: z21.string().nullable().optional(),
+  queryStartedAt: z21.string().nullable().optional(),
+  queryFinishedAt: z21.string().nullable().optional(),
+  error: z21.string().nullable().optional(),
+  createdAt: z21.string(),
+  updatedAt: z21.string()
+});
+var backlinkDomainDtoSchema = z21.object({
+  linkingDomain: z21.string(),
+  numHosts: z21.number().int()
+});
+var backlinkSummaryDtoSchema = z21.object({
+  projectId: z21.string(),
+  release: z21.string(),
+  targetDomain: z21.string(),
+  totalLinkingDomains: z21.number().int(),
+  totalHosts: z21.number().int(),
+  top10HostsShare: z21.string(),
+  queriedAt: z21.string(),
   // 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: z18.number().int().optional(),
-  excludedHosts: z18.number().int().optional()
+  excludedLinkingDomains: z21.number().int().optional(),
+  excludedHosts: z21.number().int().optional()
 });
-var backlinkListResponseSchema = z18.object({
+var backlinkListResponseSchema = z21.object({
   summary: backlinkSummaryDtoSchema.nullable(),
-  total: z18.number().int(),
-  rows: z18.array(backlinkDomainDtoSchema)
-});
-var backlinkHistoryEntrySchema = z18.object({
-  release: z18.string(),
-  totalLinkingDomains: z18.number().int(),
-  totalHosts: z18.number().int(),
-  top10HostsShare: z18.string(),
-  queriedAt: z18.string()
-});
-var backlinksInstallStatusDtoSchema = z18.object({
-  duckdbInstalled: z18.boolean(),
-  duckdbVersion: z18.string().nullable().optional(),
-  duckdbSpec: z18.string(),
-  pluginDir: z18.string()
-});
-var backlinksInstallResultDtoSchema = z18.object({
-  installed: z18.boolean(),
-  version: z18.string(),
-  path: z18.string(),
-  alreadyPresent: z18.boolean()
-});
-var ccAvailableReleaseSchema = z18.object({
-  release: z18.string(),
-  vertexUrl: z18.string(),
-  edgesUrl: z18.string(),
-  vertexBytes: z18.number().int().nullable(),
-  edgesBytes: z18.number().int().nullable(),
-  lastModified: z18.string().nullable()
-});
-var ccCachedReleaseSchema = z18.object({
-  release: z18.string(),
+  total: z21.number().int(),
+  rows: z21.array(backlinkDomainDtoSchema)
+});
+var backlinkHistoryEntrySchema = z21.object({
+  release: z21.string(),
+  totalLinkingDomains: z21.number().int(),
+  totalHosts: z21.number().int(),
+  top10HostsShare: z21.string(),
+  queriedAt: z21.string()
+});
+var backlinksInstallStatusDtoSchema = z21.object({
+  duckdbInstalled: z21.boolean(),
+  duckdbVersion: z21.string().nullable().optional(),
+  duckdbSpec: z21.string(),
+  pluginDir: z21.string()
+});
+var backlinksInstallResultDtoSchema = z21.object({
+  installed: z21.boolean(),
+  version: z21.string(),
+  path: z21.string(),
+  alreadyPresent: z21.boolean()
+});
+var ccAvailableReleaseSchema = z21.object({
+  release: z21.string(),
+  vertexUrl: z21.string(),
+  edgesUrl: z21.string(),
+  vertexBytes: z21.number().int().nullable(),
+  edgesBytes: z21.number().int().nullable(),
+  lastModified: z21.string().nullable()
+});
+var ccCachedReleaseSchema = z21.object({
+  release: z21.string(),
   syncStatus: ccReleaseSyncStatusSchema.nullable(),
-  bytes: z18.number().int(),
-  lastUsedAt: z18.string().nullable()
+  bytes: z21.number().int(),
+  lastUsedAt: z21.string().nullable()
 });
 
 // ../contracts/src/composites.ts
-import { z as z19 } from "zod";
-var searchHitKindSchema = z19.enum(["snapshot", "insight"]);
-var projectSearchSnapshotHitSchema = z19.object({
-  kind: z19.literal("snapshot"),
-  id: z19.string(),
-  runId: z19.string(),
-  query: z19.string(),
-  provider: z19.string(),
-  model: z19.string().nullable(),
+import { z as z22 } from "zod";
+var searchHitKindSchema = z22.enum(["snapshot", "insight"]);
+var projectSearchSnapshotHitSchema = z22.object({
+  kind: z22.literal("snapshot"),
+  id: z22.string(),
+  runId: z22.string(),
+  query: z22.string(),
+  provider: z22.string(),
+  model: z22.string().nullable(),
   citationState: citationStateSchema,
-  matchedField: z19.enum(["answerText", "citedDomains", "searchQueries", "query"]),
-  snippet: z19.string(),
-  createdAt: z19.string()
-});
-var projectSearchInsightHitSchema = z19.object({
-  kind: z19.literal("insight"),
-  id: z19.string(),
-  runId: z19.string().nullable(),
-  type: z19.enum([
+  matchedField: z22.enum(["answerText", "citedDomains", "searchQueries", "query"]),
+  snippet: z22.string(),
+  createdAt: z22.string()
+});
+var projectSearchInsightHitSchema = z22.object({
+  kind: z22.literal("insight"),
+  id: z22.string(),
+  runId: z22.string().nullable(),
+  type: z22.enum([
     "regression",
     "gain",
     "opportunity",
@@ -2230,29 +2495,29 @@ var projectSearchInsightHitSchema = z19.object({
     "gbp-metric-drop",
     "gbp-keyword-drop"
   ]),
-  severity: z19.enum(["critical", "high", "medium", "low"]),
-  title: z19.string(),
-  query: z19.string(),
-  provider: z19.string(),
-  matchedField: z19.enum(["title", "query", "recommendation", "cause"]),
-  snippet: z19.string(),
-  dismissed: z19.boolean(),
-  createdAt: z19.string()
-});
-var projectSearchHitSchema = z19.discriminatedUnion("kind", [
+  severity: z22.enum(["critical", "high", "medium", "low"]),
+  title: z22.string(),
+  query: z22.string(),
+  provider: z22.string(),
+  matchedField: z22.enum(["title", "query", "recommendation", "cause"]),
+  snippet: z22.string(),
+  dismissed: z22.boolean(),
+  createdAt: z22.string()
+});
+var projectSearchHitSchema = z22.discriminatedUnion("kind", [
   projectSearchSnapshotHitSchema,
   projectSearchInsightHitSchema
 ]);
-var projectSearchResponseSchema = z19.object({
-  query: z19.string(),
-  totalHits: z19.number().int().nonnegative(),
-  truncated: z19.boolean(),
-  hits: z19.array(projectSearchHitSchema)
+var projectSearchResponseSchema = z22.object({
+  query: z22.string(),
+  totalHits: z22.number().int().nonnegative(),
+  truncated: z22.boolean(),
+  hits: z22.array(projectSearchHitSchema)
 });
 
 // ../contracts/src/content.ts
-import { z as z20 } from "zod";
-var contentActionSchema = z20.enum(["create", "expand", "refresh", "add-schema"]);
+import { z as z23 } from "zod";
+var contentActionSchema = z23.enum(["create", "expand", "refresh", "add-schema"]);
 var ContentActions = contentActionSchema.enum;
 function contentActionLabel(action) {
   switch (action) {
@@ -2266,9 +2531,9 @@ function contentActionLabel(action) {
       return "Add schema";
   }
 }
-var demandSourceSchema = z20.enum(["gsc", "competitor-evidence", "both"]);
+var demandSourceSchema = z23.enum(["gsc", "competitor-evidence", "both"]);
 var DemandSources = demandSourceSchema.enum;
-var actionConfidenceSchema = z20.enum(["high", "medium", "low"]);
+var actionConfidenceSchema = z23.enum(["high", "medium", "low"]);
 var ActionConfidences = actionConfidenceSchema.enum;
 function actionConfidenceLabel(confidence) {
   switch (confidence) {
@@ -2280,7 +2545,7 @@ function actionConfidenceLabel(confidence) {
       return "Low";
   }
 }
-var pageTypeSchema = z20.enum([
+var pageTypeSchema = z23.enum([
   "blog-post",
   "comparison",
   "listicle",
@@ -2289,7 +2554,7 @@ var pageTypeSchema = z20.enum([
   "glossary"
 ]);
 var PageTypes = pageTypeSchema.enum;
-var contentActionStateSchema = z20.enum([
+var contentActionStateSchema = z23.enum([
   "proposed",
   "briefed",
   "payload-generated",
@@ -2299,136 +2564,217 @@ var contentActionStateSchema = z20.enum([
   "dismissed"
 ]);
 var ContentActionStates = contentActionStateSchema.enum;
-var ourBestPageSchema = z20.object({
-  url: z20.string(),
-  gscImpressions: z20.number().nonnegative(),
-  gscClicks: z20.number().nonnegative(),
+var winnabilityClassSchema = z23.enum(["ownable", "ceded"]);
+var WinnabilityClasses = winnabilityClassSchema.enum;
+function winnabilityClassLabel(winnabilityClass) {
+  switch (winnabilityClass) {
+    case "ownable":
+      return "Ownable";
+    case "ceded":
+      return "Ceded";
+  }
+}
+var CEDED_SURFACE_THRESHOLD = 0.6;
+function deriveWinnabilityClass(citedSurfaceDomains, domainClasses, threshold = CEDED_SURFACE_THRESHOLD) {
+  const hasCoverage = citedSurfaceDomains.some((d) => domainClasses.has(d.domain));
+  if (citedSurfaceDomains.length === 0 || domainClasses.size === 0 || !hasCoverage) {
+    return { winnabilityClass: WinnabilityClasses.ownable, winnability: null };
+  }
+  let total = 0;
+  let ceded = 0;
+  for (const { domain, citationCount } of citedSurfaceDomains) {
+    total += citationCount;
+    const cls = domainClasses.get(domain);
+    if (cls === DiscoveryCompetitorTypes["ota-aggregator"] || cls === DiscoveryCompetitorTypes["editorial-media"]) {
+      ceded += citationCount;
+    }
+  }
+  if (total === 0) {
+    return { winnabilityClass: WinnabilityClasses.ownable, winnability: null };
+  }
+  const cededShare = ceded / total;
+  const winnability = Math.min(1, Math.max(0, 1 - cededShare));
+  return {
+    winnabilityClass: cededShare >= threshold ? WinnabilityClasses.ceded : WinnabilityClasses.ownable,
+    winnability
+  };
+}
+var ourBestPageSchema = z23.object({
+  url: z23.string(),
+  gscImpressions: z23.number().nonnegative(),
+  gscClicks: z23.number().nonnegative(),
   // Null when the page came from the inventory fallback (no GSC ranking data).
-  gscAvgPosition: z20.number().nonnegative().nullable(),
-  organicSessions: z20.number().nonnegative()
-});
-var winningCompetitorSchema = z20.object({
-  domain: z20.string(),
-  url: z20.string(),
-  title: z20.string(),
-  citationCount: z20.number().int().nonnegative()
-});
-var scoreBreakdownSchema = z20.object({
-  demand: z20.number(),
-  competitor: z20.number(),
-  absence: z20.number(),
-  gapSeverity: z20.number()
-});
-var existingActionRefSchema = z20.object({
-  actionId: z20.string(),
+  gscAvgPosition: z23.number().nonnegative().nullable(),
+  organicSessions: z23.number().nonnegative()
+});
+var winningCompetitorSchema = z23.object({
+  domain: z23.string(),
+  url: z23.string(),
+  title: z23.string(),
+  citationCount: z23.number().int().nonnegative()
+});
+var scoreBreakdownSchema = z23.object({
+  demand: z23.number(),
+  competitor: z23.number(),
+  absence: z23.number(),
+  gapSeverity: z23.number()
+});
+var existingActionRefSchema = z23.object({
+  actionId: z23.string(),
   state: contentActionStateSchema,
-  lastUpdated: z20.string()
+  lastUpdated: z23.string()
 });
-var contentTargetRowDtoSchema = z20.object({
-  targetRef: z20.string(),
-  query: z20.string(),
+var contentTargetRowDtoSchema = z23.object({
+  targetRef: z23.string(),
+  query: z23.string(),
   action: contentActionSchema,
   ourBestPage: ourBestPageSchema.nullable(),
   winningCompetitor: winningCompetitorSchema.nullable(),
-  score: z20.number(),
+  score: z23.number(),
   scoreBreakdown: scoreBreakdownSchema,
-  drivers: z20.array(z20.string()),
+  drivers: z23.array(z23.string()),
   demandSource: demandSourceSchema,
   actionConfidence: actionConfidenceSchema,
-  existingAction: existingActionRefSchema.nullable()
-});
-var contentTargetsResponseDtoSchema = z20.object({
-  targets: z20.array(contentTargetRowDtoSchema),
-  contextMetrics: z20.object({
-    totalAiReferralSessions: z20.number().int().nonnegative(),
-    latestRunId: z20.string(),
-    runTimestamp: z20.string()
+  existingAction: existingActionRefSchema.nullable(),
+  /**
+   * Deterministic winnability gate. `ceded` ⇒ the cited surface is dominated by
+   * aggregators/editorial and not worth chasing; `ownable` ⇒ worth a brief.
+   * Derived (no LLM) from the discovery domain classifier.
+   */
+  winnabilityClass: winnabilityClassSchema,
+  /**
+   * Citation-weighted complement of the ceded share (`1 - cededShare`), in
+   * `[0, 1]`. `null` when the gate failed open (no classification coverage for
+   * the cited surface) — distinct from a computed `1.0`.
+   */
+  winnability: z23.number().min(0).max(1).nullable()
+});
+var contentTargetsResponseDtoSchema = z23.object({
+  targets: z23.array(contentTargetRowDtoSchema),
+  contextMetrics: z23.object({
+    totalAiReferralSessions: z23.number().int().nonnegative(),
+    latestRunId: z23.string(),
+    runTimestamp: z23.string()
   })
 });
-var contentTargetDismissalDtoSchema = z20.object({
-  targetRef: z20.string(),
-  addressedUrl: z20.string().nullable(),
-  note: z20.string().nullable(),
-  dismissedAt: z20.string()
+var contentTargetDismissalDtoSchema = z23.object({
+  targetRef: z23.string(),
+  addressedUrl: z23.string().nullable(),
+  note: z23.string().nullable(),
+  dismissedAt: z23.string()
 });
-var contentTargetDismissalsResponseDtoSchema = z20.object({
-  dismissals: z20.array(contentTargetDismissalDtoSchema)
+var contentTargetDismissalsResponseDtoSchema = z23.object({
+  dismissals: z23.array(contentTargetDismissalDtoSchema)
 });
-var contentTargetDismissRequestSchema = z20.object({
-  targetRef: z20.string().min(1),
+var contentTargetDismissRequestSchema = z23.object({
+  targetRef: z23.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: z20.string().url().optional(),
+  addressedUrl: z23.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: z20.string().max(500).optional()
+  note: z23.string().max(500).optional()
 });
-var recommendationExplanationDtoSchema = z20.object({
-  targetRef: z20.string(),
+var recommendationExplanationDtoSchema = z23.object({
+  targetRef: z23.string(),
   /** Version of the prompt template used. Bumping the version invalidates the cache forward without touching the table. */
-  promptVersion: z20.string(),
+  promptVersion: z23.string(),
   /** Provider that produced the explanation (e.g. "claude", "gemini"). */
-  provider: z20.string(),
+  provider: z23.string(),
   /** Model id within that provider (e.g. "claude-sonnet-4-6"). */
-  model: z20.string(),
+  model: z23.string(),
   /** Markdown-formatted rationale + recommended next steps. */
-  responseText: z20.string(),
+  responseText: z23.string(),
   /** Estimated cost in millicents (1/100 of a cent). 0 when unknown. */
-  costMillicents: z20.number().int().nonnegative(),
-  generatedAt: z20.string()
+  costMillicents: z23.number().int().nonnegative(),
+  generatedAt: z23.string()
 });
-var recommendationExplainRequestSchema = z20.object({
+var recommendationExplainRequestSchema = z23.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: z20.string().optional(),
+  provider: z23.string().optional(),
   /**
    * Optional model override within the chosen provider. Falls through to
    * the `analyze`-tier default model when omitted.
    */
-  model: z20.string().optional(),
+  model: z23.string().optional(),
   /**
    * Force a fresh LLM call even if a cached explanation exists for the
    * current prompt version. Use sparingly — defeats the cache.
    */
-  forceRefresh: z20.boolean().optional()
-});
-var contentGroundingSourceSchema = z20.object({
-  uri: z20.string(),
-  title: z20.string(),
-  domain: z20.string(),
-  isOurDomain: z20.boolean(),
-  isCompetitor: z20.boolean(),
-  citationCount: z20.number().int().nonnegative(),
-  providers: z20.array(providerNameSchema)
-});
-var contentSourceRowDtoSchema = z20.object({
-  query: z20.string(),
-  groundingSources: z20.array(contentGroundingSourceSchema)
-});
-var contentSourcesResponseDtoSchema = z20.object({
-  sources: z20.array(contentSourceRowDtoSchema),
-  latestRunId: z20.string()
-});
-var contentGapRowDtoSchema = z20.object({
-  query: z20.string(),
-  competitorDomains: z20.array(z20.string()),
-  competitorCount: z20.number().int().nonnegative(),
-  missRate: z20.number().min(0).max(1),
-  lastSeenInRunId: z20.string()
-});
-var contentGapsResponseDtoSchema = z20.object({
-  gaps: z20.array(contentGapRowDtoSchema),
-  latestRunId: z20.string()
+  forceRefresh: z23.boolean().optional()
+});
+var contentBriefDtoSchema = z23.object({
+  /** The query the brief is for (echoed from the recommendation). */
+  targetQuery: z23.string().trim().min(1),
+  /** Always `ownable` in practice — the gate rejects `ceded` before synthesis. */
+  winnabilityClass: winnabilityClassSchema,
+  /** The differentiated content angle to take. */
+  angle: z23.string().trim().min(1),
+  /** Why this query is winnable, citing the cited-surface signal. */
+  whyWinnable: z23.string().trim().min(1),
+  /** The schema.org type or markup to add or extend. */
+  schemaHookup: z23.string().trim().min(1),
+  /** Why the cited surface is controllable (the ownable-vs-ceded reasoning). */
+  controllableSurfaceRationale: z23.string().trim().min(1)
+});
+var recommendationBriefDtoSchema = z23.object({
+  targetRef: z23.string(),
+  /** Version of the brief prompt template; bumping invalidates the cache forward. */
+  promptVersion: z23.string(),
+  provider: z23.string(),
+  model: z23.string(),
+  brief: contentBriefDtoSchema,
+  /** Estimated cost in millicents (1/100 of a cent). 0 when unknown. */
+  costMillicents: z23.number().int().nonnegative(),
+  generatedAt: z23.string()
+});
+var domainClassificationDtoSchema = z23.object({
+  domain: z23.string(),
+  competitorType: discoveryCompetitorTypeSchema,
+  hits: z23.number().int().nonnegative(),
+  updatedAt: z23.string()
+});
+var domainClassificationsResponseDtoSchema = z23.object({
+  classifications: z23.array(domainClassificationDtoSchema)
+});
+var contentGroundingSourceSchema = z23.object({
+  uri: z23.string(),
+  title: z23.string(),
+  domain: z23.string(),
+  isOurDomain: z23.boolean(),
+  isCompetitor: z23.boolean(),
+  citationCount: z23.number().int().nonnegative(),
+  providers: z23.array(providerNameSchema)
+});
+var contentSourceRowDtoSchema = z23.object({
+  query: z23.string(),
+  groundingSources: z23.array(contentGroundingSourceSchema)
+});
+var contentSourcesResponseDtoSchema = z23.object({
+  sources: z23.array(contentSourceRowDtoSchema),
+  latestRunId: z23.string()
+});
+var contentGapRowDtoSchema = z23.object({
+  query: z23.string(),
+  competitorDomains: z23.array(z23.string()),
+  competitorCount: z23.number().int().nonnegative(),
+  missRate: z23.number().min(0).max(1),
+  lastSeenInRunId: z23.string()
+});
+var contentGapsResponseDtoSchema = z23.object({
+  gaps: z23.array(contentGapRowDtoSchema),
+  latestRunId: z23.string()
 });
 
 // ../contracts/src/doctor.ts
-import { z as z21 } from "zod";
-var checkStatusSchema = z21.enum(["ok", "warn", "fail", "skipped"]);
+import { z as z24 } from "zod";
+var checkStatusSchema = z24.enum(["ok", "warn", "fail", "skipped"]);
 var CheckStatuses = checkStatusSchema.enum;
-var checkScopeSchema = z21.enum(["global", "project"]);
+var checkScopeSchema = z24.enum(["global", "project"]);
 var CheckScopes = checkScopeSchema.enum;
-var checkCategorySchema = z21.enum([
+var checkCategorySchema = z24.enum([
   "auth",
   "config",
   "providers",
@@ -2439,31 +2785,31 @@ var checkCategorySchema = z21.enum([
   "agent"
 ]);
 var CheckCategories = checkCategorySchema.enum;
-var checkResultSchema = z21.object({
-  id: z21.string(),
+var checkResultSchema = z24.object({
+  id: z24.string(),
   category: checkCategorySchema,
   scope: checkScopeSchema,
-  title: z21.string(),
+  title: z24.string(),
   status: checkStatusSchema,
-  code: z21.string().describe('Stable machine-readable code (e.g. "google.token.refresh-failed"). Use this for filtering and remediation logic.'),
-  summary: z21.string(),
-  remediation: z21.string().nullable().optional().describe('Operator-facing next step. Null when status is "ok" or no specific remediation applies.'),
-  details: z21.record(z21.string(), z21.unknown()).optional().describe("Structured context \u2014 principal email, redirect URI, missing scopes, etc. Stable per check id."),
-  durationMs: z21.number().int().nonnegative().describe("How long the check took to execute.")
+  code: z24.string().describe('Stable machine-readable code (e.g. "google.token.refresh-failed"). Use this for filtering and remediation logic.'),
+  summary: z24.string(),
+  remediation: z24.string().nullable().optional().describe('Operator-facing next step. Null when status is "ok" or no specific remediation applies.'),
+  details: z24.record(z24.string(), z24.unknown()).optional().describe("Structured context \u2014 principal email, redirect URI, missing scopes, etc. Stable per check id."),
+  durationMs: z24.number().int().nonnegative().describe("How long the check took to execute.")
 });
-var doctorReportSchema = z21.object({
+var doctorReportSchema = z24.object({
   scope: checkScopeSchema,
-  project: z21.string().nullable().describe('Project name when scope is "project", null otherwise.'),
-  generatedAt: z21.string().describe("ISO-8601 timestamp when this doctor run started."),
-  durationMs: z21.number().int().nonnegative(),
-  summary: z21.object({
-    total: z21.number().int().nonnegative(),
-    ok: z21.number().int().nonnegative(),
-    warn: z21.number().int().nonnegative(),
-    fail: z21.number().int().nonnegative(),
-    skipped: z21.number().int().nonnegative()
+  project: z24.string().nullable().describe('Project name when scope is "project", null otherwise.'),
+  generatedAt: z24.string().describe("ISO-8601 timestamp when this doctor run started."),
+  durationMs: z24.number().int().nonnegative(),
+  summary: z24.object({
+    total: z24.number().int().nonnegative(),
+    ok: z24.number().int().nonnegative(),
+    warn: z24.number().int().nonnegative(),
+    fail: z24.number().int().nonnegative(),
+    skipped: z24.number().int().nonnegative()
   }),
-  checks: z21.array(checkResultSchema)
+  checks: z24.array(checkResultSchema)
 });
 function summarizeCheckResults(results) {
   const summary = { total: results.length, ok: 0, warn: 0, fail: 0, skipped: 0 };
@@ -2609,52 +2955,52 @@ function normalizeUrlPath(input) {
 }
 
 // ../contracts/src/citations.ts
-import { z as z22 } from "zod";
-var citationCoverageProviderSchema = z22.object({
-  provider: z22.string(),
+import { z as z25 } from "zod";
+var citationCoverageProviderSchema = z25.object({
+  provider: z25.string(),
   citationState: citationStateSchema,
-  cited: z22.boolean(),
-  mentioned: z22.boolean(),
-  runId: z22.string(),
-  runCreatedAt: z22.string()
-});
-var citationCoverageRowSchema = z22.object({
-  queryId: z22.string(),
-  query: z22.string(),
-  providers: z22.array(citationCoverageProviderSchema),
-  citedCount: z22.number().int().nonnegative(),
-  mentionedCount: z22.number().int().nonnegative(),
-  totalProviders: z22.number().int().nonnegative()
-});
-var competitorGapRowSchema = z22.object({
-  queryId: z22.string(),
-  query: z22.string(),
-  provider: z22.string(),
-  citingCompetitors: z22.array(z22.string()),
-  runId: z22.string(),
-  runCreatedAt: z22.string()
+  cited: z25.boolean(),
+  mentioned: z25.boolean(),
+  runId: z25.string(),
+  runCreatedAt: z25.string()
+});
+var citationCoverageRowSchema = z25.object({
+  queryId: z25.string(),
+  query: z25.string(),
+  providers: z25.array(citationCoverageProviderSchema),
+  citedCount: z25.number().int().nonnegative(),
+  mentionedCount: z25.number().int().nonnegative(),
+  totalProviders: z25.number().int().nonnegative()
+});
+var competitorGapRowSchema = z25.object({
+  queryId: z25.string(),
+  query: z25.string(),
+  provider: z25.string(),
+  citingCompetitors: z25.array(z25.string()),
+  runId: z25.string(),
+  runCreatedAt: z25.string()
 });
-var citationVisibilitySummarySchema = z22.object({
-  providersConfigured: z22.number().int().nonnegative(),
-  providersCiting: z22.number().int().nonnegative(),
-  providersMentioning: z22.number().int().nonnegative(),
-  totalQueries: z22.number().int().nonnegative(),
+var citationVisibilitySummarySchema = z25.object({
+  providersConfigured: z25.number().int().nonnegative(),
+  providersCiting: z25.number().int().nonnegative(),
+  providersMentioning: z25.number().int().nonnegative(),
+  totalQueries: z25.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: z22.number().int().nonnegative(),
-  queriesCitedOnly: z22.number().int().nonnegative(),
-  queriesMentionedOnly: z22.number().int().nonnegative(),
-  queriesInvisible: z22.number().int().nonnegative(),
-  latestRunId: z22.string().nullable(),
-  latestRunAt: z22.string().nullable()
-});
-var citationVisibilityResponseSchema = z22.object({
+  queriesCitedAndMentioned: z25.number().int().nonnegative(),
+  queriesCitedOnly: z25.number().int().nonnegative(),
+  queriesMentionedOnly: z25.number().int().nonnegative(),
+  queriesInvisible: z25.number().int().nonnegative(),
+  latestRunId: z25.string().nullable(),
+  latestRunAt: z25.string().nullable()
+});
+var citationVisibilityResponseSchema = z25.object({
   summary: citationVisibilitySummarySchema,
-  byQuery: z22.array(citationCoverageRowSchema),
-  competitorGaps: z22.array(competitorGapRowSchema),
-  status: z22.enum(["ready", "no-data"]),
-  reason: z22.enum(["no-runs-yet", "no-queries"]).optional()
+  byQuery: z25.array(citationCoverageRowSchema),
+  competitorGaps: z25.array(competitorGapRowSchema),
+  status: z25.enum(["ready", "no-data"]),
+  reason: z25.enum(["no-runs-yet", "no-queries"]).optional()
 });
 function emptyCitationVisibility(reason) {
   return {
@@ -2681,46 +3027,46 @@ function citationStateToCited(state) {
 }
 
 // ../contracts/src/report.ts
-import { z as z23 } from "zod";
-var providerLocationTreatmentSchema = z23.enum([
+import { z as z26 } from "zod";
+var providerLocationTreatmentSchema = z26.enum([
   "prompt",
   "request-param",
   "browser-geo",
   "ignored"
 ]);
-var reportMetaLocationSchema = z23.object({
+var reportMetaLocationSchema = z26.object({
   /** Human-readable label as configured on the project (e.g. "michigan"). */
-  label: z23.string(),
+  label: z26.string(),
   /** Resolved city/region/country from the project's `LocationContext`. */
-  city: z23.string(),
-  region: z23.string(),
-  country: z23.string(),
+  city: z26.string(),
+  region: z26.string(),
+  country: z26.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: z23.array(z23.string())
+  otherConfiguredLabels: z26.array(z26.string())
 });
-var reportProviderLocationHandlingSchema = z23.object({
+var reportProviderLocationHandlingSchema = z26.object({
   /** Provider name (matches `query_snapshots.provider`). */
-  provider: z23.string(),
+  provider: z26.string(),
   /** How this provider applied the configured location during this run. */
   treatment: providerLocationTreatmentSchema,
   /** One-sentence explanation suitable for the report. */
-  description: z23.string()
+  description: z26.string()
 });
-var reportMetaSchema = z23.object({
+var reportMetaSchema = z26.object({
   /** ISO timestamp the report was generated (server clock). */
-  generatedAt: z23.string(),
+  generatedAt: z26.string(),
   /** Project the report covers. */
-  project: z23.object({
-    id: z23.string(),
-    name: z23.string(),
-    displayName: z23.string(),
-    canonicalDomain: z23.string(),
-    country: z23.string(),
-    language: z23.string()
+  project: z26.object({
+    id: z26.string(),
+    name: z26.string(),
+    displayName: z26.string(),
+    canonicalDomain: z26.string(),
+    country: z26.string(),
+    language: z26.string()
   }),
   /**
    * The location that powered the latest visibility run, when one was set.
@@ -2735,24 +3081,24 @@ var reportMetaSchema = z23.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: z23.array(reportProviderLocationHandlingSchema),
+  providerLocationHandling: z26.array(reportProviderLocationHandlingSchema),
   /** Earliest data point referenced by the report (ISO date). */
-  periodStart: z23.string().nullable(),
+  periodStart: z26.string().nullable(),
   /** Latest data point referenced by the report (ISO date). */
-  periodEnd: z23.string().nullable()
+  periodEnd: z26.string().nullable()
 });
-var reportExecutiveSummarySchema = z23.object({
+var reportExecutiveSummarySchema = z26.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: z23.number(),
+  citationRate: z26.number(),
   /** Numerator of `citationRate` — distinct tracked queries cited by ≥1 provider in the latest run. */
-  citedQueryCount: z23.number(),
+  citedQueryCount: z26.number(),
   /** Denominator of `citationRate` — total tracked queries. */
-  totalQueryCount: z23.number(),
+  totalQueryCount: z26.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.
@@ -2760,68 +3106,68 @@ var reportExecutiveSummarySchema = z23.object({
    * the prose without citing your domain in its sources, and vice versa.
    * Same per-query denominator as `citationRate` for consistency.
    */
-  mentionRate: z23.number(),
+  mentionRate: z26.number(),
   /** Numerator of `mentionRate` — distinct tracked queries mentioned in ≥1 provider's answer text. */
-  mentionedQueryCount: z23.number(),
+  mentionedQueryCount: z26.number(),
   /** Compared to the previous run: 'up' | 'down' | 'flat' | 'unknown' (no prior run). */
-  trend: z23.enum(["up", "down", "flat", "unknown"]),
+  trend: z26.enum(["up", "down", "flat", "unknown"]),
   /** Total tracked queries. */
-  queryCount: z23.number(),
+  queryCount: z26.number(),
   /** Total tracked competitors. */
-  competitorCount: z23.number(),
+  competitorCount: z26.number(),
   /** Number of providers in the latest run. */
-  providerCount: z23.number(),
+  providerCount: z26.number(),
   /** GSC totals across the most-recent sync window. Null when GSC is not connected. */
-  gsc: z23.object({
-    clicks: z23.number(),
-    impressions: z23.number(),
-    ctr: z23.number(),
-    avgPosition: z23.number(),
-    periodStart: z23.string(),
-    periodEnd: z23.string()
+  gsc: z26.object({
+    clicks: z26.number(),
+    impressions: z26.number(),
+    ctr: z26.number(),
+    avgPosition: z26.number(),
+    periodStart: z26.string(),
+    periodEnd: z26.string()
   }).nullable(),
   /** GA4 totals across the most-recent sync period. Null when GA4 is not connected. */
-  ga: z23.object({
-    sessions: z23.number(),
-    users: z23.number(),
-    periodStart: z23.string(),
-    periodEnd: z23.string()
+  ga: z26.object({
+    sessions: z26.number(),
+    users: z26.number(),
+    periodStart: z26.string(),
+    periodEnd: z26.string()
   }).nullable(),
   /** Top 3-5 findings, each rendered as a single-sentence narrative. */
-  findings: z23.array(z23.object({
-    title: z23.string(),
-    detail: z23.string(),
-    tone: z23.enum(["positive", "caution", "negative", "neutral"])
+  findings: z26.array(z26.object({
+    title: z26.string(),
+    detail: z26.string(),
+    tone: z26.enum(["positive", "caution", "negative", "neutral"])
   }))
 });
-var citationCellSchema = z23.object({
-  citationState: z23.enum(["cited", "not-cited", "pending"]),
-  answerMentioned: z23.boolean().nullable(),
-  model: z23.string().nullable()
+var citationCellSchema = z26.object({
+  citationState: z26.enum(["cited", "not-cited", "pending"]),
+  answerMentioned: z26.boolean().nullable(),
+  model: z26.string().nullable()
 });
-var citationScorecardSchema = z23.object({
-  queries: z23.array(z23.string()),
-  providers: z23.array(z23.string()),
+var citationScorecardSchema = z26.object({
+  queries: z26.array(z26.string()),
+  providers: z26.array(z26.string()),
   /** matrix[queryIndex][providerIndex] — null when no snapshot exists for the pair. */
-  matrix: z23.array(z23.array(citationCellSchema.nullable())),
+  matrix: z26.array(z26.array(citationCellSchema.nullable())),
   /** Per-provider citation rate (0..100). */
-  providerRates: z23.array(z23.object({
-    provider: z23.string(),
-    citedCount: z23.number(),
-    totalCount: z23.number(),
-    citationRate: z23.number()
+  providerRates: z26.array(z26.object({
+    provider: z26.string(),
+    citedCount: z26.number(),
+    totalCount: z26.number(),
+    citationRate: z26.number()
   }))
 });
-var competitorRowSchema = z23.object({
-  domain: z23.string(),
+var competitorRowSchema = z26.object({
+  domain: z26.string(),
   /** Number of (query × provider) pairs that cited this competitor. */
-  citationCount: z23.number(),
+  citationCount: z26.number(),
   /** Out-of count for the same denominator. */
-  totalCount: z23.number(),
+  totalCount: z26.number(),
   /** 'High' | 'Moderate' | 'Low' | 'None' — from buildPortfolioProject pressure logic. */
-  pressureLabel: z23.enum(["High", "Moderate", "Low", "None"]),
+  pressureLabel: z26.enum(["High", "Moderate", "Low", "None"]),
   /** Distinct queries on which this competitor was cited. */
-  citedQueries: z23.array(z23.string()),
+  citedQueries: z26.array(z26.string()),
   /**
    * Citation share 0..100. Numerator = this competitor's `citationCount`.
    * Denominator = sum of `citationCount` across all competitors plus the
@@ -2829,30 +3175,30 @@ var competitorRowSchema = z23.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: z23.number(),
+  sharePct: z26.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: z23.array(z23.object({ url: z23.string(), citedFor: z23.array(z23.string()) }))
+  theirCitedPages: z26.array(z26.object({ url: z26.string(), citedFor: z26.array(z26.string()) }))
 });
-var competitorLandscapeSchema = z23.object({
+var competitorLandscapeSchema = z26.object({
   /** Project's own citation count (for the bar chart comparing project vs competitors). */
-  projectCitationCount: z23.number(),
-  competitors: z23.array(competitorRowSchema)
+  projectCitationCount: z26.number(),
+  competitors: z26.array(competitorRowSchema)
 });
-var mentionRowSchema = z23.object({
-  domain: z23.string(),
+var mentionRowSchema = z26.object({
+  domain: z26.string(),
   /** Number of (query × provider) pairs whose answer text mentioned this competitor's brand or domain. */
-  mentionCount: z23.number(),
+  mentionCount: z26.number(),
   /** Out-of count for the same denominator (snapshots that had answer text). */
-  totalCount: z23.number(),
+  totalCount: z26.number(),
   /** 'High' | 'Moderate' | 'Low' | 'None' — mention frequency tier (mirrors CompetitorRow.pressureLabel). */
-  pressureLabel: z23.enum(["High", "Moderate", "Low", "None"]),
+  pressureLabel: z26.enum(["High", "Moderate", "Low", "None"]),
   /** Distinct queries on which this competitor was mentioned. */
-  mentionedQueries: z23.array(z23.string()),
+  mentionedQueries: z26.array(z26.string()),
   /**
    * Mention share 0..100. Numerator = this competitor's `mentionCount`.
    * Denominator = sum of `mentionCount` across all competitors plus the
@@ -2860,129 +3206,129 @@ var mentionRowSchema = z23.object({
    * mention. Per-competitor split of the same head-to-head measure the
    * project's hero `MentionShareDto` gauge headlines.
    */
-  sharePct: z23.number()
+  sharePct: z26.number()
 });
-var mentionLandscapeSchema = z23.object({
+var mentionLandscapeSchema = z26.object({
   /** Project's own mention count (for the bar chart comparing project vs competitors). */
-  projectMentionCount: z23.number(),
+  projectMentionCount: z26.number(),
   /** Snapshots considered — those with non-empty answerText. Drives the totalCount denominator. */
-  totalAnswerSnapshots: z23.number(),
-  competitors: z23.array(mentionRowSchema)
+  totalAnswerSnapshots: z26.number(),
+  competitors: z26.array(mentionRowSchema)
 });
-var aiSourceCategoryBucketSchema = z23.object({
+var aiSourceCategoryBucketSchema = z26.object({
   /** Category slug from packages/contracts/src/source-categories. */
-  category: z23.string(),
+  category: z26.string(),
   /** Display label. */
-  label: z23.string(),
+  label: z26.string(),
   /** Number of citations falling in this category. */
-  count: z23.number(),
+  count: z26.number(),
   /** 0..100 share of total citations. */
-  sharePct: z23.number()
+  sharePct: z26.number()
 });
-var aiSourceOriginSchema = z23.object({
-  categories: z23.array(aiSourceCategoryBucketSchema),
+var aiSourceOriginSchema = z26.object({
+  categories: z26.array(aiSourceCategoryBucketSchema),
   /** Top 20 source domains by citation count (excluding the project's own domain). */
-  topDomains: z23.array(z23.object({
-    domain: z23.string(),
-    count: z23.number(),
+  topDomains: z26.array(z26.object({
+    domain: z26.string(),
+    count: z26.number(),
     /** True when the domain is one of the project's tracked competitors. */
-    isCompetitor: z23.boolean()
+    isCompetitor: z26.boolean()
   }))
 });
-var gscQueryRowSchema = z23.object({
-  query: z23.string(),
-  clicks: z23.number(),
-  impressions: z23.number(),
-  ctr: z23.number(),
-  avgPosition: z23.number(),
+var gscQueryRowSchema = z26.object({
+  query: z26.string(),
+  clicks: z26.number(),
+  impressions: z26.number(),
+  ctr: z26.number(),
+  avgPosition: z26.number(),
   /** Heuristic categorization: 'brand' | 'lead-gen' | 'industry' | 'other'. */
-  category: z23.enum(["brand", "lead-gen", "industry", "other"])
-});
-var gscSectionSchema = z23.object({
-  periodStart: z23.string(),
-  periodEnd: z23.string(),
-  totalClicks: z23.number(),
-  totalImpressions: z23.number(),
-  ctr: z23.number(),
-  avgPosition: z23.number(),
-  topQueries: z23.array(gscQueryRowSchema),
-  categoryBreakdown: z23.array(z23.object({
-    category: z23.enum(["brand", "lead-gen", "industry", "other"]),
-    clicks: z23.number(),
-    impressions: z23.number(),
-    sharePct: z23.number()
+  category: z26.enum(["brand", "lead-gen", "industry", "other"])
+});
+var gscSectionSchema = z26.object({
+  periodStart: z26.string(),
+  periodEnd: z26.string(),
+  totalClicks: z26.number(),
+  totalImpressions: z26.number(),
+  ctr: z26.number(),
+  avgPosition: z26.number(),
+  topQueries: z26.array(gscQueryRowSchema),
+  categoryBreakdown: z26.array(z26.object({
+    category: z26.enum(["brand", "lead-gen", "industry", "other"]),
+    clicks: z26.number(),
+    impressions: z26.number(),
+    sharePct: z26.number()
   })),
-  trend: z23.array(z23.object({ date: z23.string(), clicks: z23.number(), impressions: z23.number() })),
+  trend: z26.array(z26.object({ date: z26.string(), clicks: z26.number(), impressions: z26.number() })),
   /**
    * Tracked AEO queries that have no GSC impressions in the report window.
    * Surfaces queries that may not represent real search demand.
    */
-  trackedButNoGsc: z23.array(z23.string()),
+  trackedButNoGsc: z26.array(z26.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: z23.array(z23.string())
-});
-var gaTrafficSectionSchema = z23.object({
-  totalSessions: z23.number(),
-  totalUsers: z23.number(),
-  totalOrganicSessions: z23.number(),
-  periodStart: z23.string(),
-  periodEnd: z23.string(),
-  topLandingPages: z23.array(z23.object({
-    page: z23.string(),
-    sessions: z23.number(),
-    users: z23.number(),
-    organicSessions: z23.number()
+  gscButNotTracked: z26.array(z26.string())
+});
+var gaTrafficSectionSchema = z26.object({
+  totalSessions: z26.number(),
+  totalUsers: z26.number(),
+  totalOrganicSessions: z26.number(),
+  periodStart: z26.string(),
+  periodEnd: z26.string(),
+  topLandingPages: z26.array(z26.object({
+    page: z26.string(),
+    sessions: z26.number(),
+    users: z26.number(),
+    organicSessions: z26.number()
   })),
-  channelBreakdown: z23.array(z23.object({
-    channel: z23.string(),
-    sessions: z23.number(),
-    sharePct: z23.number()
+  channelBreakdown: z26.array(z26.object({
+    channel: z26.string(),
+    sessions: z26.number(),
+    sharePct: z26.number()
   }))
 });
-var socialReferralSectionSchema = z23.object({
-  totalSessions: z23.number(),
-  organicSessions: z23.number(),
-  paidSessions: z23.number(),
-  channels: z23.array(z23.object({
-    channelGroup: z23.string(),
-    sessions: z23.number(),
-    sharePct: z23.number()
+var socialReferralSectionSchema = z26.object({
+  totalSessions: z26.number(),
+  organicSessions: z26.number(),
+  paidSessions: z26.number(),
+  channels: z26.array(z26.object({
+    channelGroup: z26.string(),
+    sessions: z26.number(),
+    sharePct: z26.number()
   })),
-  topCampaigns: z23.array(z23.object({
-    source: z23.string(),
-    medium: z23.string(),
-    sessions: z23.number()
+  topCampaigns: z26.array(z26.object({
+    source: z26.string(),
+    medium: z26.string(),
+    sessions: z26.number()
   }))
 });
-var aiReferralSectionSchema = z23.object({
-  totalSessions: z23.number(),
-  totalUsers: z23.number(),
-  bySource: z23.array(z23.object({
-    source: z23.string(),
-    sessions: z23.number(),
-    users: z23.number(),
-    sharePct: z23.number()
+var aiReferralSectionSchema = z26.object({
+  totalSessions: z26.number(),
+  totalUsers: z26.number(),
+  bySource: z26.array(z26.object({
+    source: z26.string(),
+    sessions: z26.number(),
+    users: z26.number(),
+    sharePct: z26.number()
   })),
-  trend: z23.array(z23.object({ date: z23.string(), sessions: z23.number() })),
-  topLandingPages: z23.array(z23.object({
-    page: z23.string(),
-    sessions: z23.number(),
-    users: z23.number()
+  trend: z26.array(z26.object({ date: z26.string(), sessions: z26.number() })),
+  topLandingPages: z26.array(z26.object({
+    page: z26.string(),
+    sessions: z26.number(),
+    users: z26.number()
   }))
 });
-var serverActivitySectionSchema = z23.object({
+var serverActivitySectionSchema = z26.object({
   /** ISO8601 inclusive lower bound of the report window (default: 7 days). */
-  windowStart: z23.string(),
+  windowStart: z26.string(),
   /** ISO8601 inclusive upper bound. */
-  windowEnd: z23.string(),
-  hasData: z23.boolean(),
+  windowEnd: z26.string(),
+  hasData: z26.boolean(),
   /** Last-7d total verified crawler hits, with prior 7d for delta. */
-  verifiedCrawlerHits: z23.object({ current: z23.number(), prior: z23.number(), deltaPct: z23.number().nullable() }),
+  verifiedCrawlerHits: z26.object({ current: z26.number(), prior: z26.number(), deltaPct: z26.number().nullable() }),
   /** Last-7d total unverified crawler hits, separated from verified trust metrics. */
-  unverifiedCrawlerHits: z23.object({ current: z23.number(), prior: z23.number(), deltaPct: z23.number().nullable() }),
+  unverifiedCrawlerHits: z26.object({ current: z26.number(), prior: z26.number(), deltaPct: z26.number().nullable() }),
   /**
    * Last-7d on-demand per-user fetches from AI surfaces (ChatGPT-User,
    * Perplexity-User, MistralAI-User). Disjoint from `verifiedCrawlerHits` /
@@ -2991,19 +3337,19 @@ var serverActivitySectionSchema = z23.object({
    * because the operational question for user-fetch is "is this happening?"
    * not "is this a confirmed bot identity?"
    */
-  aiUserFetchHits: z23.object({ current: z23.number(), prior: z23.number(), deltaPct: z23.number().nullable() }),
+  aiUserFetchHits: z26.object({ current: z26.number(), prior: z26.number(), deltaPct: z26.number().nullable() }),
   /** Last-7d AI-referral sessions (sessionized from server-side request evidence). */
-  referralArrivals: z23.object({ current: z23.number(), prior: z23.number(), deltaPct: z23.number().nullable() }),
+  referralArrivals: z26.object({ current: z26.number(), prior: z26.number(), deltaPct: z26.number().nullable() }),
   /** Per-AI-operator breakdown (OpenAI, Anthropic, Google AI, Perplexity, …). */
-  byOperator: z23.array(z23.object({
-    operator: z23.string(),
-    verifiedHits: z23.number(),
+  byOperator: z26.array(z26.object({
+    operator: z26.string(),
+    verifiedHits: z26.number(),
     /** Shown to agency audience only: claimed-bot UA, source IP not in a published range. */
-    unverifiedHits: z23.number(),
+    unverifiedHits: z26.number(),
     /** Per-user fetches from this operator's AI surface (ChatGPT-User, …). */
-    userFetchHits: z23.number(),
-    referralArrivals: z23.number(),
-    deltaPct: z23.number().nullable()
+    userFetchHits: z26.number(),
+    referralArrivals: z26.number(),
+    deltaPct: z26.number().nullable()
   })),
   /**
    * Top crawled paths (verified only, last-7d). Path-level citation cross-reference
@@ -3013,84 +3359,84 @@ var serverActivitySectionSchema = z23.object({
    * citation evidence can extend this entry with a `citationState` field without
    * breaking the contract.
    */
-  topCrawledPaths: z23.array(z23.object({
-    path: z23.string(),
-    verifiedHits: z23.number(),
+  topCrawledPaths: z26.array(z26.object({
+    path: z26.string(),
+    verifiedHits: z26.number(),
     /** How many distinct AI operators crawled this path in the window. */
-    distinctOperators: z23.number()
+    distinctOperators: z26.number()
   })),
   /** AI products that sent ≥1 session in the window (referral by destination). */
-  referralProducts: z23.array(z23.object({
-    product: z23.string(),
-    arrivals: z23.number(),
-    distinctLandingPaths: z23.number()
+  referralProducts: z26.array(z26.object({
+    product: z26.string(),
+    arrivals: z26.number(),
+    distinctLandingPaths: z26.number()
   })),
   /** Daily trend, last 14d for sparkline / chart rendering. */
-  dailyTrend: z23.array(z23.object({
-    date: z23.string(),
-    verifiedCrawlerHits: z23.number(),
-    userFetchHits: z23.number(),
-    referralArrivals: z23.number()
+  dailyTrend: z26.array(z26.object({
+    date: z26.string(),
+    verifiedCrawlerHits: z26.number(),
+    userFetchHits: z26.number(),
+    referralArrivals: z26.number()
   })),
   /**
    * Top landing paths for AI-referral sessions (last-7d).
    * Complements `topCrawledPaths` (what bots fetch) with what humans actually land on.
    */
-  topReferralLandingPaths: z23.array(z23.object({
-    path: z23.string(),
-    arrivals: z23.number(),
-    distinctProducts: z23.number()
+  topReferralLandingPaths: z26.array(z26.object({
+    path: z26.string(),
+    arrivals: z26.number(),
+    distinctProducts: z26.number()
   }))
 });
-var indexingHealthSectionSchema = z23.object({
+var indexingHealthSectionSchema = z26.object({
   /** Source: 'google' | 'bing' | null when neither is connected. */
-  provider: z23.enum(["google", "bing"]).nullable(),
-  total: z23.number(),
-  indexed: z23.number(),
-  notIndexed: z23.number(),
+  provider: z26.enum(["google", "bing"]).nullable(),
+  total: z26.number(),
+  indexed: z26.number(),
+  notIndexed: z26.number(),
   /** Google-only — pages explicitly marked as deindexed. Bing reports 'unknown' instead. */
-  deindexed: z23.number(),
+  deindexed: z26.number(),
   /** Bing-only — pages with no inspection data yet. */
-  unknown: z23.number(),
+  unknown: z26.number(),
   /** 0..100. */
-  indexedPct: z23.number()
+  indexedPct: z26.number()
 });
-var citationsTrendPointSchema = z23.object({
+var citationsTrendPointSchema = z26.object({
   /** Run ID — anchor for cross-section linking. */
-  runId: z23.string(),
+  runId: z26.string(),
   /** ISO timestamp when the run finished (or createdAt fallback). */
-  date: z23.string(),
+  date: z26.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: z23.number(),
+  citationRate: z26.number(),
   /** Numerator of `citationRate` for this run. */
-  citedQueryCount: z23.number(),
+  citedQueryCount: z26.number(),
   /** Denominator of `citationRate` for this run. */
-  totalQueryCount: z23.number(),
+  totalQueryCount: z26.number(),
   /** 0..100 — same per-query unique-mentioned definition as `ReportExecutiveSummary.mentionRate`. */
-  mentionRate: z23.number(),
+  mentionRate: z26.number(),
   /** Numerator of `mentionRate` for this run. */
-  mentionedQueryCount: z23.number(),
+  mentionedQueryCount: z26.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: z23.array(z23.object({ provider: z23.string(), citationRate: z23.number() }))
+  providerRates: z26.array(z26.object({ provider: z26.string(), citationRate: z26.number() }))
 });
-var reportInsightSchema = z23.object({
-  id: z23.string(),
-  type: z23.enum(["regression", "gain", "opportunity"]),
-  severity: z23.enum(["critical", "high", "medium", "low"]),
-  title: z23.string(),
-  query: z23.string(),
-  provider: z23.string(),
-  recommendation: z23.string().nullable(),
-  createdAt: z23.string(),
+var reportInsightSchema = z26.object({
+  id: z26.string(),
+  type: z26.enum(["regression", "gain", "opportunity"]),
+  severity: z26.enum(["critical", "high", "medium", "low"]),
+  title: z26.string(),
+  query: z26.string(),
+  provider: z26.string(),
+  recommendation: z26.string().nullable(),
+  createdAt: z26.string(),
   /**
    * How many times this insight fired across recent runs for the same
    * `(query, provider, type)` tuple. Always ≥ 1. Insights returned by the
@@ -3098,57 +3444,57 @@ var reportInsightSchema = z23.object({
    * surfacing the multiplicity. Use it directly instead of grouping again
    * client-side — counts derived from raw insight rows will overcount.
    */
-  instanceCount: z23.number()
+  instanceCount: z26.number()
 });
-var recommendedNextStepSchema = z23.object({
+var recommendedNextStepSchema = z26.object({
   /** 'immediate' | 'short-term' | 'medium-term' — bucketed by severity heuristic. */
-  horizon: z23.enum(["immediate", "short-term", "medium-term"]),
-  title: z23.string(),
-  rationale: z23.string()
+  horizon: z26.enum(["immediate", "short-term", "medium-term"]),
+  title: z26.string(),
+  rationale: z26.string()
 });
-var reportRateDeltaSchema = z23.object({
+var reportRateDeltaSchema = z26.object({
   /** Current value (0..100 for rates, raw count otherwise). When `window`
    *  is present this is the average over the last `window` checks. */
-  current: z23.number(),
+  current: z26.number(),
   /** Prior value compared against. When `window` is present this is the
    *  average over the prior `window` checks before that. */
-  prior: z23.number(),
+  prior: z26.number(),
   /** Absolute delta (current − prior). Negative = decrease. */
-  deltaAbs: z23.number(),
+  deltaAbs: z26.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: z23.enum(["up", "down", "flat"]),
+  direction: z26.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: z23.number().optional()
+  window: z26.number().optional()
 });
-var reportProviderMovementSchema = z23.object({
-  provider: z23.string(),
-  current: z23.number(),
-  prior: z23.number(),
-  deltaAbs: z23.number(),
-  direction: z23.enum(["up", "down", "flat"])
+var reportProviderMovementSchema = z26.object({
+  provider: z26.string(),
+  current: z26.number(),
+  prior: z26.number(),
+  deltaAbs: z26.number(),
+  direction: z26.enum(["up", "down", "flat"])
 });
-var whatsChangedSectionSchema = z23.object({
+var whatsChangedSectionSchema = z26.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: z23.boolean(),
+  enoughHistory: z26.boolean(),
   /**
    * One-sentence narrative summary suitable as a section subtitle.
    * Always present — even on baseline, narrates whatever signal exists.
    */
-  headline: z23.string(),
+  headline: z26.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. */
@@ -3171,24 +3517,24 @@ var whatsChangedSectionSchema = z23.object({
    * when no prior run. Sorted by |deltaAbs| desc — providers with the
    * biggest swing first.
    */
-  providerMovements: z23.array(reportProviderMovementSchema),
+  providerMovements: z26.array(reportProviderMovementSchema),
   /**
    * Top wins this period — gains surfaced by the intelligence engine.
    * Capped at 5; sourced from `insights` filtered to `type: 'gain'`.
    */
-  wins: z23.array(reportInsightSchema),
+  wins: z26.array(reportInsightSchema),
   /**
    * Top regressions this period — citations or mentions lost. Capped at 5;
    * sourced from `insights` filtered to `type: 'regression'`.
    */
-  regressions: z23.array(reportInsightSchema)
-});
-var reportAudienceSchema = z23.enum(["agency", "client"]);
-var reportActionAudienceSchema = z23.enum(["agency", "client", "both"]);
-var reportActionHorizonSchema = z23.enum(["immediate", "short-term", "medium-term"]);
-var reportActionConfidenceSchema = z23.enum(["high", "medium", "low"]);
-var reportToneSchema = z23.enum(["positive", "caution", "negative", "neutral"]);
-var reportActionCategorySchema = z23.enum([
+  regressions: z26.array(reportInsightSchema)
+});
+var reportAudienceSchema = z26.enum(["agency", "client"]);
+var reportActionAudienceSchema = z26.enum(["agency", "client", "both"]);
+var reportActionHorizonSchema = z26.enum(["immediate", "short-term", "medium-term"]);
+var reportActionConfidenceSchema = z26.enum(["high", "medium", "low"]);
+var reportToneSchema = z26.enum(["positive", "caution", "negative", "neutral"]);
+var reportActionCategorySchema = z26.enum([
   "content",
   "competitors",
   "provider",
@@ -3197,23 +3543,23 @@ var reportActionCategorySchema = z23.enum([
   "location",
   "monitoring"
 ]);
-var reportActionPlanItemSchema = z23.object({
+var reportActionPlanItemSchema = z26.object({
   /** Which report audience should see this action. `both` renders in both modes. */
   audience: reportActionAudienceSchema,
   /** Stable sort priority. Lower numbers render earlier. */
-  priority: z23.number(),
+  priority: z26.number(),
   /** When this should be tackled. */
   horizon: reportActionHorizonSchema,
   category: reportActionCategorySchema,
-  title: z23.string(),
+  title: z26.string(),
   /** Direct next step written as an operator/client-friendly imperative. */
-  action: z23.string(),
+  action: z26.string(),
   /** Why this matters. Keep each entry concise and evidence-backed. */
-  why: z23.array(z23.string()),
+  why: z26.array(z26.string()),
   /** Specific observations that justify the action. */
-  evidence: z23.array(z23.string()),
+  evidence: z26.array(z26.string()),
   /** What should move if the action worked. */
-  successMetric: z23.string(),
+  successMetric: z26.string(),
   /** Confidence in the recommendation based on the available evidence. */
   confidence: reportActionConfidenceSchema,
   /**
@@ -3225,23 +3571,23 @@ var reportActionPlanItemSchema = z23.object({
    * load. Actions sourced from other signals (competitor gaps, indexing
    * issues, etc.) omit this and use their own dismiss flows.
    */
-  targetRef: z23.string().optional()
+  targetRef: z26.string().optional()
 });
-var reportClientSummarySchema = z23.object({
-  headline: z23.string(),
-  overview: z23.string(),
-  actionItems: z23.array(reportActionPlanItemSchema),
-  confidenceNotes: z23.array(z23.string())
+var reportClientSummarySchema = z26.object({
+  headline: z26.string(),
+  overview: z26.string(),
+  actionItems: z26.array(reportActionPlanItemSchema),
+  confidenceNotes: z26.array(z26.string())
 });
-var reportAgencyDiagnosticSchema = z23.object({
-  title: z23.string(),
-  detail: z23.string(),
-  severity: z23.enum(["positive", "caution", "negative", "neutral"]),
-  evidence: z23.array(z23.string())
+var reportAgencyDiagnosticSchema = z26.object({
+  title: z26.string(),
+  detail: z26.string(),
+  severity: z26.enum(["positive", "caution", "negative", "neutral"]),
+  evidence: z26.array(z26.string())
 });
-var reportAgencyDiagnosticsSchema = z23.object({
-  priorities: z23.array(reportActionPlanItemSchema),
-  diagnostics: z23.array(reportAgencyDiagnosticSchema)
+var reportAgencyDiagnosticsSchema = z26.object({
+  priorities: z26.array(reportActionPlanItemSchema),
+  diagnostics: z26.array(reportAgencyDiagnosticSchema)
 });
 function reportActionTone(action) {
   if (action.horizon === "immediate") return "negative";
@@ -3299,7 +3645,7 @@ function reportConfidenceLabel(confidence) {
       return "Low";
   }
 }
-var projectReportDtoSchema = z23.object({
+var projectReportDtoSchema = z26.object({
   meta: reportMetaSchema,
   executiveSummary: reportExecutiveSummarySchema,
   citationScorecard: citationScorecardSchema,
@@ -3313,16 +3659,16 @@ var projectReportDtoSchema = z23.object({
   /** Server-side log-evidence visibility (crawls + click-through sessions). Null when no traffic source connected. */
   serverActivity: serverActivitySectionSchema.nullable(),
   indexingHealth: indexingHealthSectionSchema.nullable(),
-  citationsTrend: z23.array(citationsTrendPointSchema),
+  citationsTrend: z26.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: z23.array(reportInsightSchema),
-  recommendedNextSteps: z23.array(recommendedNextStepSchema),
+  insights: z26.array(reportInsightSchema),
+  recommendedNextSteps: z26.array(recommendedNextStepSchema),
   /** Canonical structured actions shared by the client and agency render modes. */
-  actionPlan: z23.array(reportActionPlanItemSchema),
+  actionPlan: z26.array(reportActionPlanItemSchema),
   /** Polished client-facing summary and action shortlist. */
   clientSummary: reportClientSummarySchema,
   /** Technical, evidence-oriented operator diagnostics for agency mode. */
@@ -3332,17 +3678,17 @@ var projectReportDtoSchema = z23.object({
    * intelligence layer (`buildContentTargetRows`). Empty when no run has
    * produced candidate queries with demand or competitor signal.
    */
-  contentOpportunities: z23.array(contentTargetRowDtoSchema),
+  contentOpportunities: z26.array(contentTargetRowDtoSchema),
   /**
    * Queries where competitors were cited but the project was not. Sourced
    * from `buildContentGapRows`. Empty until the first answer-visibility run.
    */
-  contentGaps: z23.array(contentGapRowDtoSchema),
+  contentGaps: z26.array(contentGapRowDtoSchema),
   /**
    * Per-query grounding source map (own + competitor cited URLs). Sourced
    * from `buildContentSourceRows`. Empty until the first answer-visibility run.
    */
-  groundingSources: z23.array(contentSourceRowDtoSchema)
+  groundingSources: z26.array(contentSourceRowDtoSchema)
 });
 
 // ../contracts/src/report-dedup.ts
@@ -3413,10 +3759,10 @@ function dedupeReportOpportunities(report) {
 }
 
 // ../contracts/src/skills.ts
-import { z as z24 } from "zod";
-var codingAgentSchema = z24.enum(["claude", "codex"]);
+import { z as z27 } from "zod";
+var codingAgentSchema = z27.enum(["claude", "codex"]);
 var CodingAgents = codingAgentSchema.enum;
-var skillsClientSchema = z24.enum(["claude", "codex", "all"]);
+var skillsClientSchema = z27.enum(["claude", "codex", "all"]);
 var SkillsClients = skillsClientSchema.enum;
 var SKILL_MANIFEST_FILENAME = ".canonry-skill-manifest.json";
 function classifySkillFile(params) {
@@ -3434,8 +3780,8 @@ function coerceSkillManifest(parsed) {
 }
 
 // ../contracts/src/traffic.ts
-import { z as z25 } from "zod";
-var trafficSourceTypeSchema = z25.enum([
+import { z as z28 } from "zod";
+var trafficSourceTypeSchema = z28.enum([
   "cloud-run",
   "wordpress",
   "cloudflare",
@@ -3443,7 +3789,7 @@ var trafficSourceTypeSchema = z25.enum([
   "generic-log"
 ]);
 var TrafficSourceTypes = trafficSourceTypeSchema.enum;
-var trafficAdapterCapabilitySchema = z25.enum([
+var trafficAdapterCapabilitySchema = z28.enum([
   "raw-request-events",
   "aggregate-request-metrics",
   "request-url",
@@ -3454,328 +3800,215 @@ var trafficAdapterCapabilitySchema = z25.enum([
   "cursor-pull"
 ]);
 var TrafficAdapterCapabilities = trafficAdapterCapabilitySchema.enum;
-var trafficEvidenceKindSchema = z25.enum(["raw-request", "aggregate-bucket"]);
+var trafficEvidenceKindSchema = z28.enum(["raw-request", "aggregate-bucket"]);
 var TrafficEvidenceKinds = trafficEvidenceKindSchema.enum;
-var trafficEventConfidenceSchema = z25.enum(["observed", "provider-aggregated", "inferred"]);
+var trafficEventConfidenceSchema = z28.enum(["observed", "provider-aggregated", "inferred"]);
 var TrafficEventConfidences = trafficEventConfidenceSchema.enum;
-var trafficProviderResourceSchema = z25.object({
-  type: z25.string().nullable(),
-  labels: z25.record(z25.string(), z25.string())
+var trafficProviderResourceSchema = z28.object({
+  type: z28.string().nullable(),
+  labels: z28.record(z28.string(), z28.string())
 });
-var normalizedTrafficRequestSchema = z25.object({
+var normalizedTrafficRequestSchema = z28.object({
   sourceType: trafficSourceTypeSchema,
-  evidenceKind: z25.literal(TrafficEvidenceKinds["raw-request"]),
-  confidence: z25.literal(TrafficEventConfidences.observed),
-  eventId: z25.string().min(1),
-  observedAt: z25.string().min(1),
-  method: z25.string().nullable(),
-  requestUrl: z25.string().nullable(),
-  host: z25.string().nullable(),
-  path: z25.string().min(1),
-  queryString: z25.string().nullable(),
-  status: z25.number().int().nullable(),
-  userAgent: z25.string().nullable(),
-  remoteIp: z25.string().nullable(),
-  referer: z25.string().nullable(),
-  latencyMs: z25.number().nullable(),
-  requestSizeBytes: z25.number().int().nullable(),
-  responseSizeBytes: z25.number().int().nullable(),
+  evidenceKind: z28.literal(TrafficEvidenceKinds["raw-request"]),
+  confidence: z28.literal(TrafficEventConfidences.observed),
+  eventId: z28.string().min(1),
+  observedAt: z28.string().min(1),
+  method: z28.string().nullable(),
+  requestUrl: z28.string().nullable(),
+  host: z28.string().nullable(),
+  path: z28.string().min(1),
+  queryString: z28.string().nullable(),
+  status: z28.number().int().nullable(),
+  userAgent: z28.string().nullable(),
+  remoteIp: z28.string().nullable(),
+  referer: z28.string().nullable(),
+  latencyMs: z28.number().nullable(),
+  requestSizeBytes: z28.number().int().nullable(),
+  responseSizeBytes: z28.number().int().nullable(),
   providerResource: trafficProviderResourceSchema,
-  providerLabels: z25.record(z25.string(), z25.string())
+  providerLabels: z28.record(z28.string(), z28.string())
 });
-var normalizedTrafficPullPageSchema = z25.object({
-  events: z25.array(normalizedTrafficRequestSchema),
-  rawEntryCount: z25.number().int().nonnegative(),
-  skippedEntryCount: z25.number().int().nonnegative(),
-  nextPageToken: z25.string().optional(),
-  filter: z25.string()
+var normalizedTrafficPullPageSchema = z28.object({
+  events: z28.array(normalizedTrafficRequestSchema),
+  rawEntryCount: z28.number().int().nonnegative(),
+  skippedEntryCount: z28.number().int().nonnegative(),
+  nextPageToken: z28.string().optional(),
+  filter: z28.string()
 });
-var trafficSourceStatusSchema = z25.enum(["connected", "paused", "error", "archived"]);
+var trafficSourceStatusSchema = z28.enum(["connected", "paused", "error", "archived"]);
 var TrafficSourceStatuses = trafficSourceStatusSchema.enum;
-var trafficSourceAuthModeSchema = z25.enum(["oauth", "service-account"]);
+var trafficSourceAuthModeSchema = z28.enum(["oauth", "service-account"]);
 var TrafficSourceAuthModes = trafficSourceAuthModeSchema.enum;
-var verificationStatusSchema = z25.enum(["verified", "claimed_unverified", "unknown_ai_like"]);
+var verificationStatusSchema = z28.enum(["verified", "claimed_unverified", "unknown_ai_like"]);
 var VerificationStatuses = verificationStatusSchema.enum;
-var cloudRunSourceConfigSchema = z25.object({
-  gcpProjectId: z25.string().min(1),
-  serviceName: z25.string().nullable().optional(),
-  location: z25.string().nullable().optional(),
+var cloudRunSourceConfigSchema = z28.object({
+  gcpProjectId: z28.string().min(1),
+  serviceName: z28.string().nullable().optional(),
+  location: z28.string().nullable().optional(),
   authMode: trafficSourceAuthModeSchema
 });
-var wordpressTrafficSourceConfigSchema = z25.object({
-  baseUrl: z25.string().url(),
-  username: z25.string().min(1)
+var wordpressTrafficSourceConfigSchema = z28.object({
+  baseUrl: z28.string().url(),
+  username: z28.string().min(1)
 });
-var vercelTrafficEnvironmentSchema = z25.enum(["production", "preview"]);
+var vercelTrafficEnvironmentSchema = z28.enum(["production", "preview"]);
 var VercelTrafficEnvironments = vercelTrafficEnvironmentSchema.enum;
-var vercelTrafficSourceConfigSchema = z25.object({
+var vercelTrafficSourceConfigSchema = z28.object({
   /** Vercel project id (e.g. `prj_...`). */
-  projectId: z25.string().min(1),
+  projectId: z28.string().min(1),
   /** Vercel team or account id: the org that owns the project. */
-  teamId: z25.string().min(1),
+  teamId: z28.string().min(1),
   environment: vercelTrafficEnvironmentSchema
 });
-var trafficSourceDtoSchema = z25.object({
-  id: z25.string(),
-  projectId: z25.string(),
+var trafficSourceDtoSchema = z28.object({
+  id: z28.string(),
+  projectId: z28.string(),
   sourceType: trafficSourceTypeSchema,
-  displayName: z25.string(),
+  displayName: z28.string(),
   status: trafficSourceStatusSchema,
-  lastSyncedAt: z25.string().nullable(),
-  lastCursor: z25.string().nullable(),
-  lastError: z25.string().nullable(),
-  archivedAt: z25.string().nullable(),
-  config: z25.record(z25.string(), z25.unknown()),
-  createdAt: z25.string(),
-  updatedAt: z25.string()
-});
-var trafficConnectCloudRunRequestSchema = z25.object({
-  gcpProjectId: z25.string().min(1),
-  serviceName: z25.string().min(1).optional(),
-  location: z25.string().min(1).optional(),
-  displayName: z25.string().min(1).optional(),
+  lastSyncedAt: z28.string().nullable(),
+  lastCursor: z28.string().nullable(),
+  lastError: z28.string().nullable(),
+  archivedAt: z28.string().nullable(),
+  config: z28.record(z28.string(), z28.unknown()),
+  createdAt: z28.string(),
+  updatedAt: z28.string()
+});
+var trafficConnectCloudRunRequestSchema = z28.object({
+  gcpProjectId: z28.string().min(1),
+  serviceName: z28.string().min(1).optional(),
+  location: z28.string().min(1).optional(),
+  displayName: z28.string().min(1).optional(),
   /** Service-account JSON content (string). When omitted, defaults to OAuth via `canonry google connect <project> --type ga4` flow. */
-  keyJson: z25.string().optional()
+  keyJson: z28.string().optional()
 });
-var trafficConnectWordpressRequestSchema = z25.object({
-  baseUrl: z25.string().url(),
-  username: z25.string().min(1),
+var trafficConnectWordpressRequestSchema = z28.object({
+  baseUrl: z28.string().url(),
+  username: z28.string().min(1),
   /** WordPress Application Password (the same auth used by the content client). */
-  applicationPassword: z25.string().min(1),
-  displayName: z25.string().min(1).optional()
+  applicationPassword: z28.string().min(1),
+  displayName: z28.string().min(1).optional()
 });
-var trafficConnectVercelRequestSchema = z25.object({
+var trafficConnectVercelRequestSchema = z28.object({
   /** Vercel project id (e.g. `prj_...`) — from the Vercel dashboard or `.vercel/project.json`. */
-  projectId: z25.string().min(1),
+  projectId: z28.string().min(1),
   /** Vercel team or account id: the org that owns the project ("orgId" in .vercel/project.json). */
-  teamId: z25.string().min(1),
+  teamId: z28.string().min(1),
   /** Vercel personal access token. Stored in `~/.canonry/config.yaml`, never the DB. */
-  token: z25.string().min(1),
+  token: z28.string().min(1),
   /** Which deployment environment's request logs to pull. Default: `production`. */
   environment: vercelTrafficEnvironmentSchema.optional(),
-  displayName: z25.string().min(1).optional()
+  displayName: z28.string().min(1).optional()
 });
-var trafficSyncResponseSchema = z25.object({
-  sourceId: z25.string(),
-  runId: z25.string(),
-  syncedAt: z25.string(),
-  pulledEvents: z25.number().int().nonnegative(),
+var trafficSyncResponseSchema = z28.object({
+  sourceId: z28.string(),
+  runId: z28.string(),
+  syncedAt: z28.string(),
+  pulledEvents: z28.number().int().nonnegative(),
   /** Self-traffic events (Canonry's own tooling) dropped before rollup. */
-  selfTrafficExcluded: z25.number().int().nonnegative(),
-  crawlerHits: z25.number().int().nonnegative(),
-  aiUserFetchHits: z25.number().int().nonnegative(),
-  aiReferralHits: z25.number().int().nonnegative(),
-  unknownHits: z25.number().int().nonnegative(),
-  crawlerBucketRows: z25.number().int().nonnegative(),
-  aiUserFetchBucketRows: z25.number().int().nonnegative(),
-  aiReferralBucketRows: z25.number().int().nonnegative(),
-  sampleRows: z25.number().int().nonnegative(),
-  windowStart: z25.string(),
-  windowEnd: z25.string()
-});
-var trafficBackfillRequestSchema = z25.object({
+  selfTrafficExcluded: z28.number().int().nonnegative(),
+  crawlerHits: z28.number().int().nonnegative(),
+  aiUserFetchHits: z28.number().int().nonnegative(),
+  aiReferralHits: z28.number().int().nonnegative(),
+  unknownHits: z28.number().int().nonnegative(),
+  crawlerBucketRows: z28.number().int().nonnegative(),
+  aiUserFetchBucketRows: z28.number().int().nonnegative(),
+  aiReferralBucketRows: z28.number().int().nonnegative(),
+  sampleRows: z28.number().int().nonnegative(),
+  windowStart: z28.string(),
+  windowEnd: z28.string()
+});
+var trafficBackfillRequestSchema = z28.object({
   /** Lookback window in days. Capped server-side at the upstream log retention ceiling (Cloud Logging _Default = 30d). Default: 30. */
-  days: z25.number().int().positive().optional()
+  days: z28.number().int().positive().optional()
 });
-var trafficResetRequestSchema = z25.object({
-  advanceToNow: z25.literal(true)
+var trafficResetRequestSchema = z28.object({
+  advanceToNow: z28.literal(true)
 });
-var trafficBackfillResponseSchema = z25.object({
-  sourceId: z25.string(),
-  runId: z25.string(),
+var trafficBackfillResponseSchema = z28.object({
+  sourceId: z28.string(),
+  runId: z28.string(),
   status: runStatusSchema,
-  windowStart: z25.string(),
-  windowEnd: z25.string(),
+  windowStart: z28.string(),
+  windowEnd: z28.string(),
   /** Days actually used after server-side clamping (≤ requested). */
-  daysRequested: z25.number().int().positive(),
-  daysApplied: z25.number().int().positive()
+  daysRequested: z28.number().int().positive(),
+  daysApplied: z28.number().int().positive()
 });
-var trafficSourceTotalsSchema = z25.object({
-  crawlerHits: z25.number().int().nonnegative(),
-  aiUserFetchHits: z25.number().int().nonnegative(),
-  aiReferralHits: z25.number().int().nonnegative(),
-  sampleCount: z25.number().int().nonnegative()
+var trafficSourceTotalsSchema = z28.object({
+  crawlerHits: z28.number().int().nonnegative(),
+  aiUserFetchHits: z28.number().int().nonnegative(),
+  aiReferralHits: z28.number().int().nonnegative(),
+  sampleCount: z28.number().int().nonnegative()
 });
-var trafficSourceListResponseSchema = z25.object({
-  sources: z25.array(trafficSourceDtoSchema)
+var trafficSourceListResponseSchema = z28.object({
+  sources: z28.array(trafficSourceDtoSchema)
 });
 var trafficSourceDetailDtoSchema = trafficSourceDtoSchema.extend({
   totals24h: trafficSourceTotalsSchema,
-  latestRun: z25.object({
-    runId: z25.string(),
+  latestRun: z28.object({
+    runId: z28.string(),
     status: runStatusSchema,
-    startedAt: z25.string().nullable(),
-    finishedAt: z25.string().nullable(),
-    error: z25.string().nullable()
+    startedAt: z28.string().nullable(),
+    finishedAt: z28.string().nullable(),
+    error: z28.string().nullable()
   }).nullable()
 });
-var trafficStatusResponseSchema = z25.object({
-  sources: z25.array(trafficSourceDetailDtoSchema)
+var trafficStatusResponseSchema = z28.object({
+  sources: z28.array(trafficSourceDetailDtoSchema)
 });
-var trafficEventKindSchema = z25.enum(["crawler", "ai-user-fetch", "ai-referral"]);
+var trafficEventKindSchema = z28.enum(["crawler", "ai-user-fetch", "ai-referral"]);
 var TrafficEventKinds = trafficEventKindSchema.enum;
-var trafficCrawlerEventEntrySchema = z25.object({
-  kind: z25.literal(TrafficEventKinds.crawler),
-  sourceId: z25.string(),
-  tsHour: z25.string(),
-  botId: z25.string(),
-  operator: z25.string(),
-  verificationStatus: z25.string(),
-  pathNormalized: z25.string(),
-  status: z25.number().int(),
-  hits: z25.number().int().nonnegative()
-});
-var trafficAiUserFetchEventEntrySchema = z25.object({
-  kind: z25.literal(TrafficEventKinds["ai-user-fetch"]),
-  sourceId: z25.string(),
-  tsHour: z25.string(),
-  botId: z25.string(),
-  operator: z25.string(),
-  verificationStatus: z25.string(),
-  pathNormalized: z25.string(),
-  status: z25.number().int(),
-  hits: z25.number().int().nonnegative()
-});
-var trafficAiReferralEventEntrySchema = z25.object({
-  kind: z25.literal(TrafficEventKinds["ai-referral"]),
-  sourceId: z25.string(),
-  tsHour: z25.string(),
-  product: z25.string(),
-  operator: z25.string(),
-  sourceDomain: z25.string(),
-  evidenceType: z25.string(),
-  landingPathNormalized: z25.string(),
-  status: z25.number().int(),
-  hits: z25.number().int().nonnegative()
-});
-var trafficEventEntrySchema = z25.discriminatedUnion("kind", [
+var trafficCrawlerEventEntrySchema = z28.object({
+  kind: z28.literal(TrafficEventKinds.crawler),
+  sourceId: z28.string(),
+  tsHour: z28.string(),
+  botId: z28.string(),
+  operator: z28.string(),
+  verificationStatus: z28.string(),
+  pathNormalized: z28.string(),
+  status: z28.number().int(),
+  hits: z28.number().int().nonnegative()
+});
+var trafficAiUserFetchEventEntrySchema = z28.object({
+  kind: z28.literal(TrafficEventKinds["ai-user-fetch"]),
+  sourceId: z28.string(),
+  tsHour: z28.string(),
+  botId: z28.string(),
+  operator: z28.string(),
+  verificationStatus: z28.string(),
+  pathNormalized: z28.string(),
+  status: z28.number().int(),
+  hits: z28.number().int().nonnegative()
+});
+var trafficAiReferralEventEntrySchema = z28.object({
+  kind: z28.literal(TrafficEventKinds["ai-referral"]),
+  sourceId: z28.string(),
+  tsHour: z28.string(),
+  product: z28.string(),
+  operator: z28.string(),
+  sourceDomain: z28.string(),
+  evidenceType: z28.string(),
+  landingPathNormalized: z28.string(),
+  status: z28.number().int(),
+  hits: z28.number().int().nonnegative()
+});
+var trafficEventEntrySchema = z28.discriminatedUnion("kind", [
   trafficCrawlerEventEntrySchema,
   trafficAiUserFetchEventEntrySchema,
   trafficAiReferralEventEntrySchema
 ]);
-var trafficEventsResponseSchema = z25.object({
-  windowStart: z25.string(),
-  windowEnd: z25.string(),
-  totals: z25.object({
-    crawlerHits: z25.number().int().nonnegative(),
-    aiUserFetchHits: z25.number().int().nonnegative(),
-    aiReferralHits: z25.number().int().nonnegative()
-  }),
-  events: z25.array(trafficEventEntrySchema)
-});
-
-// ../contracts/src/discovery.ts
-import { z as z26 } from "zod";
-var discoveryBucketSchema = z26.enum(["cited", "aspirational", "wasted-surface"]);
-var DiscoveryBuckets = discoveryBucketSchema.enum;
-var DEFAULT_DISCOVERY_PROMOTE_BUCKETS = [
-  DiscoveryBuckets.cited,
-  DiscoveryBuckets.aspirational
-];
-var DISCOVERY_PROMOTE_COMPETITOR_CAP = 20;
-var DISCOVERY_PROMOTE_COMPETITOR_MIN_HITS = 2;
-var discoveryCompetitorTypeSchema = z26.enum([
-  "direct-competitor",
-  "ota-aggregator",
-  "editorial-media",
-  "other",
-  "unknown"
-]);
-var DiscoveryCompetitorTypes = discoveryCompetitorTypeSchema.enum;
-var DEFAULT_DISCOVERY_PROMOTE_COMPETITOR_TYPES = [
-  DiscoveryCompetitorTypes["direct-competitor"]
-];
-var discoverySessionStatusSchema = z26.enum(["queued", "seeding", "probing", "completed", "failed"]);
-var DiscoverySessionStatuses = discoverySessionStatusSchema.enum;
-var discoveryCompetitorMapEntrySchema = z26.object({
-  domain: z26.string().min(1),
-  hits: z26.number().int().positive(),
-  /**
-   * Domain classification from the session's post-probe AI classification
-   * pass. Defaults to `unknown` so competitor maps persisted before
-   * classification existed (or by a session whose classification call failed)
-   * still parse — those entries are excluded from the default promote filter.
-   */
-  competitorType: discoveryCompetitorTypeSchema.default("unknown")
-});
-var discoveryProbeDtoSchema = z26.object({
-  id: z26.string(),
-  sessionId: z26.string(),
-  projectId: z26.string(),
-  query: z26.string(),
-  bucket: discoveryBucketSchema.nullable().default(null),
-  citationState: citationStateSchema,
-  citedDomains: z26.array(z26.string()).default([]),
-  createdAt: z26.string()
-});
-var discoverySessionDtoSchema = z26.object({
-  id: z26.string(),
-  projectId: z26.string(),
-  status: discoverySessionStatusSchema,
-  icpDescription: z26.string().nullable().optional(),
-  seedProvider: z26.string().nullable().optional(),
-  seedCountRaw: z26.number().int().nullable().optional(),
-  seedCount: z26.number().int().nullable().optional(),
-  dedupThreshold: z26.number().nullable().optional(),
-  probeCount: z26.number().int().nullable().optional(),
-  citedCount: z26.number().int().nullable().default(null),
-  aspirationalCount: z26.number().int().nullable().default(null),
-  wastedCount: z26.number().int().nullable().default(null),
-  competitorMap: z26.array(discoveryCompetitorMapEntrySchema).default([]),
-  error: z26.string().nullable().optional(),
-  startedAt: z26.string().nullable().optional(),
-  finishedAt: z26.string().nullable().optional(),
-  createdAt: z26.string()
-});
-var discoverySessionDetailDtoSchema = discoverySessionDtoSchema.extend({
-  probes: z26.array(discoveryProbeDtoSchema).default([])
-});
-var DISCOVERY_MAX_PROBES_CAP = 500;
-var discoveryRunRequestSchema = z26.object({
-  icpDescription: z26.string().min(1).optional(),
-  dedupThreshold: z26.number().min(0).max(1).optional(),
-  maxProbes: z26.number().int().positive().max(DISCOVERY_MAX_PROBES_CAP).optional(),
-  /**
-   * Optional override of the project's location labels, constraining seed
-   * generation to a subset of the configured service areas. Each label must
-   * match a configured project location (resolved server-side via
-   * `resolveLocations`). Omitted means "use every project location" — a
-   * project with no locations is unaffected.
-   */
-  locations: z26.array(z26.string().min(1)).optional()
-});
-var discoveryPromoteRequestSchema = z26.object({
-  buckets: z26.array(discoveryBucketSchema).min(1).optional(),
-  includeCompetitors: z26.boolean().optional(),
-  competitorTypes: z26.array(discoveryCompetitorTypeSchema).min(1).optional()
-});
-var discoveryPromotePreviewSchema = z26.object({
-  sessionId: z26.string(),
-  projectId: z26.string(),
-  status: discoverySessionStatusSchema,
-  queriesByBucket: z26.object({
-    cited: z26.array(z26.string()),
-    aspirational: z26.array(z26.string()),
-    "wasted-surface": z26.array(z26.string())
-  }),
-  suggestedCompetitors: z26.array(discoveryCompetitorMapEntrySchema)
-});
-var discoveryPromoteResultSchema = z26.object({
-  sessionId: z26.string(),
-  projectId: z26.string(),
-  promoted: z26.object({
-    queries: z26.array(z26.string()),
-    competitors: z26.array(z26.string())
+var trafficEventsResponseSchema = z28.object({
+  windowStart: z28.string(),
+  windowEnd: z28.string(),
+  totals: z28.object({
+    crawlerHits: z28.number().int().nonnegative(),
+    aiUserFetchHits: z28.number().int().nonnegative(),
+    aiReferralHits: z28.number().int().nonnegative()
   }),
-  skipped: z26.object({
-    queries: z26.array(z26.string()),
-    competitors: z26.array(z26.string())
-  })
+  events: z28.array(trafficEventEntrySchema)
 });
-var queryProvenanceSchema = z26.union([
-  z26.literal("cli"),
-  z26.string().regex(/^discovery:.+$/)
-]);
 
 // ../contracts/src/embeddings.ts
 function cosineSimilarity(a, b) {
@@ -4076,12 +4309,32 @@ export {
   SchedulableRunKinds,
   scheduleDtoSchema,
   scheduleUpsertRequestSchema,
-  brandMetricsDtoSchema,
-  parseWindow,
-  windowCutoff,
   categorizeSource,
   categorizeSourceWithCompetitors,
   categoryLabel,
+  discoveryBucketSchema,
+  DiscoveryBuckets,
+  DEFAULT_DISCOVERY_PROMOTE_BUCKETS,
+  DISCOVERY_PROMOTE_COMPETITOR_CAP,
+  DISCOVERY_PROMOTE_COMPETITOR_MIN_HITS,
+  discoveryCompetitorTypeSchema,
+  DiscoveryCompetitorTypes,
+  DEFAULT_DISCOVERY_PROMOTE_COMPETITOR_TYPES,
+  DiscoverySessionStatuses,
+  discoverySessionDtoSchema,
+  discoverySessionDetailDtoSchema,
+  DISCOVERY_MAX_PROBES_CAP,
+  discoveryRunRequestSchema,
+  discoveryPromoteRequestSchema,
+  discoveryPromotePreviewSchema,
+  discoveryPromoteResultSchema,
+  surfaceClassLabel,
+  surfaceClassFromCompetitorType,
+  classifySurfaceFromCategory,
+  brandMetricsDtoSchema,
+  sourceBreakdownDtoSchema,
+  parseWindow,
+  windowCutoff,
   ga4StatusDtoSchema,
   ga4SyncResponseDtoSchema,
   ga4AiReferralHistoryEntrySchema,
@@ -4110,12 +4363,19 @@ export {
   ContentActions,
   contentActionLabel,
   actionConfidenceLabel,
+  winnabilityClassSchema,
+  WinnabilityClasses,
+  winnabilityClassLabel,
+  deriveWinnabilityClass,
   contentTargetsResponseDtoSchema,
   contentTargetDismissalDtoSchema,
   contentTargetDismissalsResponseDtoSchema,
   contentTargetDismissRequestSchema,
   recommendationExplanationDtoSchema,
   recommendationExplainRequestSchema,
+  contentBriefDtoSchema,
+  recommendationBriefDtoSchema,
+  domainClassificationsResponseDtoSchema,
   contentSourcesResponseDtoSchema,
   contentGapsResponseDtoSchema,
   CheckStatuses,
@@ -4161,22 +4421,6 @@ export {
   trafficEventKindSchema,
   TrafficEventKinds,
   trafficEventsResponseSchema,
-  discoveryBucketSchema,
-  DiscoveryBuckets,
-  DEFAULT_DISCOVERY_PROMOTE_BUCKETS,
-  DISCOVERY_PROMOTE_COMPETITOR_CAP,
-  DISCOVERY_PROMOTE_COMPETITOR_MIN_HITS,
-  discoveryCompetitorTypeSchema,
-  DiscoveryCompetitorTypes,
-  DEFAULT_DISCOVERY_PROMOTE_COMPETITOR_TYPES,
-  DiscoverySessionStatuses,
-  discoverySessionDtoSchema,
-  discoverySessionDetailDtoSchema,
-  DISCOVERY_MAX_PROBES_CAP,
-  discoveryRunRequestSchema,
-  discoveryPromoteRequestSchema,
-  discoveryPromotePreviewSchema,
-  discoveryPromoteResultSchema,
   clusterByCosine,
   pickClusterRepresentative,
   formatRatio,