@ainyc/canonry 4.71.1 → 4.72.2

package/dist/{chunk-ETJDAMGA.js → chunk-J7SDOU2J.js}

@@ -28,6 +28,7 @@ import {
   TrafficSourceStatuses,
   TrafficSourceTypes,
   VerificationStatuses,
+  WinnabilityClasses,
   __export,
   absolutizeProjectUrl,
   actionConfidenceLabel,
@@ -65,6 +66,7 @@ import {
   citationStateToCited,
   citationVisibilityResponseSchema,
   classifySkillFile,
+  classifySurfaceFromCategory,
   clusterByCosine,
   coerceSkillManifest,
   competitorBatchRequestSchema,
@@ -83,6 +85,7 @@ import {
   deliveryFailed,
   deltaPercent,
   deltaTone,
+  deriveWinnabilityClass,
   determineAnswerMentioned,
   discoveryBucketSchema,
   discoveryPromotePreviewSchema,
@@ -92,6 +95,7 @@ import {
   discoverySessionDetailDtoSchema,
   discoverySessionDtoSchema,
   doctorReportSchema,
+  domainClassificationsResponseDtoSchema,
   effectiveBrandNames,
   effectiveDomains,
   emptyCitationVisibility,
@@ -158,6 +162,7 @@ import {
   queryDtoSchema,
   queryGenerateRequestSchema,
   quotaExceeded,
+  recommendationBriefDtoSchema,
   recommendationExplainRequestSchema,
   recommendationExplanationDtoSchema,
   registrableDomain,
@@ -184,7 +189,10 @@ import {
   snapshotListResponseSchema,
   snapshotReportSchema,
   snapshotRequestSchema,
+  sourceBreakdownDtoSchema,
   summarizeCheckResults,
+  surfaceClassFromCompetitorType,
+  surfaceClassLabel,
   trafficBackfillResponseSchema,
   trafficConnectVercelRequestSchema,
   trafficConnectWordpressRequestSchema,
@@ -199,6 +207,8 @@ import {
   validationError,
   visibilityStateFromAnswerMentioned,
   windowCutoff,
+  winnabilityClassLabel,
+  winnabilityClassSchema,
   withRetry,
   wordpressAuditPageDtoSchema,
   wordpressBulkMetaResultDtoSchema,
@@ -212,10 +222,10 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-5FM7QRYD.js";
+} from "./chunk-SJI6JGPN.js";
 
 // src/intelligence-service.ts
-import { eq as eq31, desc as desc16, asc as asc3, and as and23, ne as ne5, or as or5, inArray as inArray11, gte as gte6, lte as lte3 } from "drizzle-orm";
+import { eq as eq32, desc as desc16, asc as asc3, and as and23, ne as ne5, or as or5, inArray as inArray11, gte as gte6, lte as lte3 } from "drizzle-orm";
 
 // ../db/src/client.ts
 import { mkdirSync } from "fs";
@@ -244,6 +254,7 @@ __export(schema_exports, {
   crawlerEventsHourly: () => crawlerEventsHourly,
   discoveryProbes: () => discoveryProbes,
   discoverySessions: () => discoverySessions,
+  domainClassifications: () => domainClassifications,
   gaAiReferrals: () => gaAiReferrals,
   gaConnections: () => gaConnections,
   gaSocialReferrals: () => gaSocialReferrals,
@@ -269,6 +280,7 @@ __export(schema_exports, {
   queries: () => queries,
   querySnapshots: () => querySnapshots,
   rawEventSamples: () => rawEventSamples,
+  recommendationBriefs: () => recommendationBriefs,
   recommendationExplanations: () => recommendationExplanations,
   runs: () => runs,
   schedules: () => schedules,
@@ -981,6 +993,20 @@ var discoveryProbes = sqliteTable("discovery_probes", {
   index("idx_discovery_probes_session").on(table.sessionId),
   index("idx_discovery_probes_project").on(table.projectId)
 ]);
+var domainClassifications = sqliteTable("domain_classifications", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  domain: text("domain").notNull(),
+  competitorType: text("competitor_type").$type().notNull(),
+  /** Recurrence count from the latest classifying session; informational. */
+  hits: integer("hits").notNull().default(0),
+  /** Discovery session that produced the latest classification. */
+  sessionId: text("session_id"),
+  updatedAt: text("updated_at").notNull()
+}, (table) => [
+  uniqueIndex("idx_domain_classifications_project_domain").on(table.projectId, table.domain),
+  index("idx_domain_classifications_project").on(table.projectId)
+]);
 var contentTargetDismissals = sqliteTable("content_target_dismissals", {
   id: text("id").primaryKey(),
   projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
@@ -1011,6 +1037,26 @@ var recommendationExplanations = sqliteTable("recommendation_explanations", {
   ),
   index("idx_recommendation_explanations_project").on(table.projectId)
 ]);
+var recommendationBriefs = sqliteTable("recommendation_briefs", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  targetRef: text("target_ref").notNull(),
+  promptVersion: text("prompt_version").notNull(),
+  provider: text("provider").notNull(),
+  model: text("model").notNull(),
+  /** The structured brief payload (angle, why-winnable, schema hookup, etc.). */
+  brief: text("brief", { mode: "json" }).$type().notNull(),
+  /** Estimated cost in millicents (1/100 of a cent) for audit; 0 if unknown. */
+  costMillicents: integer("cost_millicents").notNull().default(0),
+  generatedAt: text("generated_at").notNull()
+}, (table) => [
+  uniqueIndex("idx_recommendation_briefs_unique").on(
+    table.projectId,
+    table.targetRef,
+    table.promptVersion
+  ),
+  index("idx_recommendation_briefs_project").on(table.projectId)
+]);
 var migrationsTable = sqliteTable("_migrations", {
   version: integer("version").primaryKey(),
   name: text("name").notNull(),
@@ -2690,6 +2736,49 @@ var MIGRATION_VERSIONS = [
       )`,
       `CREATE INDEX IF NOT EXISTS idx_gbp_place_details_loc ON gbp_place_details(project_id, location_name, synced_at)`
     ]
+  },
+  {
+    // Durable per-domain classification of cited surfaces, upserted on each
+    // discovery completion. Powers the content-targets winnabilityClass winnability
+    // gate without re-running a discovery probe. Keyed (project_id, domain).
+    version: 73,
+    name: "domain-classifications",
+    statements: [
+      `CREATE TABLE IF NOT EXISTS domain_classifications (
+        id              TEXT PRIMARY KEY,
+        project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        domain          TEXT NOT NULL,
+        competitor_type TEXT NOT NULL,
+        hits            INTEGER NOT NULL DEFAULT 0,
+        session_id      TEXT,
+        updated_at      TEXT NOT NULL
+      )`,
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_domain_classifications_project_domain ON domain_classifications(project_id, domain)`,
+      `CREATE INDEX IF NOT EXISTS idx_domain_classifications_project ON domain_classifications(project_id)`
+    ]
+  },
+  {
+    // Structured LLM content briefs, cached per (project, target_ref,
+    // prompt_version). Separate from recommendation_explanations so the
+    // structured brief payload and its version-keyed cache never collide with
+    // the prompt-version-blind explanation lookup.
+    version: 74,
+    name: "recommendation-briefs",
+    statements: [
+      `CREATE TABLE IF NOT EXISTS recommendation_briefs (
+        id              TEXT PRIMARY KEY,
+        project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        target_ref      TEXT NOT NULL,
+        prompt_version  TEXT NOT NULL,
+        provider        TEXT NOT NULL,
+        model           TEXT NOT NULL,
+        brief           TEXT NOT NULL,
+        cost_millicents INTEGER NOT NULL DEFAULT 0,
+        generated_at    TEXT NOT NULL
+      )`,
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_recommendation_briefs_unique ON recommendation_briefs(project_id, target_ref, prompt_version)`,
+      `CREATE INDEX IF NOT EXISTS idx_recommendation_briefs_project ON recommendation_briefs(project_id)`
+    ]
   }
 ];
 function isDuplicateColumnError(err) {
@@ -3547,6 +3636,7 @@ function buildContentTargetRows(input) {
       gscAvgPosition: cq.gscPosition,
       organicSessions: input.gaTrafficByPage.get(ourPage.url) ?? 0
     } : null;
+    const { winnabilityClass, winnability } = deriveWinnabilityClass(cq.citedSurfaceDomains, input.domainClasses);
     rows.push({
       targetRef,
       query: cq.query,
@@ -3558,7 +3648,9 @@ function buildContentTargetRows(input) {
       drivers: scoring.drivers,
       demandSource: scoring.demandSource,
       actionConfidence,
-      existingAction: input.inProgressActions.get(targetRef) ?? null
+      existingAction: input.inProgressActions.get(targetRef) ?? null,
+      winnabilityClass,
+      winnability
     });
   }
   return dedupeByIntent(
@@ -7173,9 +7265,32 @@ async function analyticsRoutes(app) {
     const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
+    let limit = null;
+    if (request.query.limit !== void 0) {
+      const n = Number(request.query.limit);
+      if (!Number.isInteger(n) || n <= 0) throw validationError('"limit" must be a positive integer');
+      limit = n;
+    }
+    const classifyCtx = {
+      projectDomains: effectiveDomains(project),
+      competitorDomains: app.db.select({ domain: competitors.domain }).from(competitors).where(eq10(competitors.projectId, project.id)).all().map((r) => r.domain)
+    };
+    const storedSurfaceClasses = /* @__PURE__ */ new Map();
+    for (const row of app.db.select({ domain: domainClassifications.domain, competitorType: domainClassifications.competitorType }).from(domainClassifications).where(eq10(domainClassifications.projectId, project.id)).all()) {
+      const mapped = surfaceClassFromCompetitorType(row.competitorType);
+      if (mapped) storedSurfaceClasses.set(normalizeProjectDomain(row.domain), mapped);
+    }
     const windowRuns = app.db.select().from(runs).where(and5(eq10(runs.projectId, project.id), notProbeRun())).orderBy(desc3(runs.createdAt), desc3(runs.id)).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
     if (windowRuns.length === 0) {
-      return reply.send({ overall: [], byQuery: {}, runId: "", window });
+      return reply.send({
+        overall: [],
+        byQuery: {},
+        ranked: buildRankedList(/* @__PURE__ */ new Map(), limit),
+        byProvider: {},
+        runId: "",
+        window,
+        limit
+      });
     }
     const latestGroup = groupRunsByCreatedAt(windowRuns)[0] ?? [];
     const latestRunId = pickGroupRepresentative(latestGroup)?.id ?? windowRuns[0].id;
@@ -7183,28 +7298,49 @@ async function analyticsRoutes(app) {
     const snapshots = app.db.select({
       queryId: querySnapshots.queryId,
       query: queries.query,
+      provider: querySnapshots.provider,
       rawResponse: querySnapshots.rawResponse
     }).from(querySnapshots).leftJoin(queries, eq10(querySnapshots.queryId, queries.id)).where(inArray3(querySnapshots.runId, windowRunIds)).all();
     const overallCounts = /* @__PURE__ */ new Map();
     const byQuery = {};
+    const overallDomains = /* @__PURE__ */ new Map();
+    const providerDomains = /* @__PURE__ */ new Map();
     for (const snap of snapshots) {
       const sources = parseGroundingSources(snap.rawResponse);
       const qCounts = /* @__PURE__ */ new Map();
       for (const source of sources) {
-        const { category, domain } = categorizeSource(source.uri);
+        const { category, label, domain } = categorizeSource(source.uri);
+        const surfaceClass = classifySurfaceFromCategory(
+          domain,
+          category,
+          classifyCtx,
+          storedSurfaceClasses.get(normalizeProjectDomain(domain))
+        );
         if (!overallCounts.has(category)) overallCounts.set(category, /* @__PURE__ */ new Map());
         const oDomains = overallCounts.get(category);
         oDomains.set(domain, (oDomains.get(domain) ?? 0) + 1);
         if (!qCounts.has(category)) qCounts.set(category, /* @__PURE__ */ new Map());
         const qDomains = qCounts.get(category);
         qDomains.set(domain, (qDomains.get(domain) ?? 0) + 1);
+        bumpDomain(overallDomains, domain, category, label, surfaceClass);
+        let pm = providerDomains.get(snap.provider);
+        if (!pm) {
+          pm = /* @__PURE__ */ new Map();
+          providerDomains.set(snap.provider, pm);
+        }
+        bumpDomain(pm, domain, category, label, surfaceClass);
       }
       if (sources.length > 0 && snap.query) {
         byQuery[snap.query] = buildCategoryCounts(qCounts);
       }
     }
     const overall = buildCategoryCounts(overallCounts);
-    return reply.send({ overall, byQuery, runId: latestRunId, window });
+    const ranked = buildRankedList(overallDomains, limit);
+    const byProvider = {};
+    for (const [provider, domains] of providerDomains) {
+      byProvider[provider] = buildRankedList(domains, limit);
+    }
+    return reply.send({ overall, byQuery, ranked, byProvider, runId: latestRunId, window, limit });
   });
 }
 function isProviderInfraDomain(uri) {
@@ -7315,6 +7451,52 @@ function computeTrend(buckets, rateKey) {
   if (diff < -0.05) return "declining";
   return "stable";
 }
+function round4(ratio) {
+  return Math.round(ratio * 1e4) / 1e4;
+}
+function bumpDomain(map, domain, category, label, surfaceClass) {
+  const existing = map.get(domain);
+  if (existing) existing.count += 1;
+  else map.set(domain, { domain, count: 1, category, label, surfaceClass });
+}
+function buildRankedList(domains, limit) {
+  const all = [...domains.values()];
+  const totalCitedSlots = all.reduce((sum, d) => sum + d.count, 0);
+  const domainTotal = all.length;
+  all.sort((a, b) => b.count - a.count || a.domain.localeCompare(b.domain));
+  const shownEntries = limit != null && limit < all.length ? all.slice(0, limit) : all;
+  const entries = shownEntries.map((d) => ({
+    domain: d.domain,
+    count: d.count,
+    percentage: totalCitedSlots > 0 ? round4(d.count / totalCitedSlots) : 0,
+    category: d.category,
+    label: d.label,
+    surfaceClass: d.surfaceClass
+  }));
+  const shownSlots = shownEntries.reduce((sum, d) => sum + d.count, 0);
+  const classAgg = /* @__PURE__ */ new Map();
+  for (const d of all) {
+    const entry = classAgg.get(d.surfaceClass) ?? { count: 0, domainCount: 0 };
+    entry.count += d.count;
+    entry.domainCount += 1;
+    classAgg.set(d.surfaceClass, entry);
+  }
+  const bySurfaceClass = [...classAgg.entries()].map(([surfaceClass, v]) => ({
+    surfaceClass,
+    label: surfaceClassLabel(surfaceClass),
+    count: v.count,
+    percentage: totalCitedSlots > 0 ? round4(v.count / totalCitedSlots) : 0,
+    domainCount: v.domainCount
+  })).sort((a, b) => b.count - a.count || a.surfaceClass.localeCompare(b.surfaceClass));
+  return {
+    totalCitedSlots,
+    domainTotal,
+    entries,
+    truncatedDomainCount: domainTotal - shownEntries.length,
+    truncatedCitedSlots: totalCitedSlots - shownSlots,
+    bySurfaceClass
+  };
+}
 function buildCategoryCounts(counts) {
   let grandTotal = 0;
   for (const domains of counts.values()) {
@@ -7528,6 +7710,7 @@ function loadOrchestratorInput(db, project, locationFilter = void 0) {
   });
   const gaTrafficByPage = buildGaTrafficByPage(db, projectId);
   const totalAiReferralSessions = sumAiReferralSessions(db, projectId);
+  const domainClasses = loadDomainClasses(db, projectId);
   return {
     projectId,
     ownDomain,
@@ -7540,9 +7723,14 @@ function loadOrchestratorInput(db, project, locationFilter = void 0) {
     totalAiReferralSessions,
     latestRunId,
     latestRunTimestamp,
-    inProgressActions: /* @__PURE__ */ new Map()
+    inProgressActions: /* @__PURE__ */ new Map(),
+    domainClasses
   };
 }
+function loadDomainClasses(db, projectId) {
+  const rows = db.select({ domain: domainClassifications.domain, competitorType: domainClassifications.competitorType }).from(domainClassifications).where(eq12(domainClassifications.projectId, projectId)).all();
+  return new Map(rows.map((r) => [normalizeDomain(r.domain), r.competitorType]));
+}
 function buildQueryIntentModifiers(project, locationFilter) {
   if (locationFilter === void 0 || locationFilter === null) return [];
   const locations = project.locations ?? [];
@@ -7749,6 +7937,7 @@ function aggregateCandidate(opts) {
   const competitorTally = /* @__PURE__ */ new Map();
   const competitorGroundingTally = /* @__PURE__ */ new Map();
   const ourGroundingTally = /* @__PURE__ */ new Map();
+  const citedSurfaceTally = /* @__PURE__ */ new Map();
   let ourCitedInLatestRun = false;
   for (const snap of opts.snapshots) {
     const isLatestRun = snap.runId === opts.latestRunId;
@@ -7767,6 +7956,7 @@ function aggregateCandidate(opts) {
         recordGroundingHit(ourGroundingTally, g, domain, snap.provider);
         continue;
       }
+      citedSurfaceTally.set(domain, (citedSurfaceTally.get(domain) ?? 0) + 1);
       if (!opts.competitorSet.has(domain)) continue;
       recordGroundingHit(competitorGroundingTally, g, domain, snap.provider);
     }
@@ -7785,6 +7975,7 @@ function aggregateCandidate(opts) {
     recentMissRate,
     ourGroundingUrls: Array.from(ourGroundingTally.values()),
     competitorGroundingUrls: Array.from(competitorGroundingTally.values()),
+    citedSurfaceDomains: Array.from(citedSurfaceTally.entries()).map(([domain, citationCount]) => ({ domain, citationCount })),
     runsOfHistory: new Set(opts.snapshots.map((s) => s.runId)).size
   };
 }
@@ -7820,6 +8011,7 @@ function emptyCandidate(query) {
     recentMissRate: 0,
     ourGroundingUrls: [],
     competitorGroundingUrls: [],
+    citedSurfaceDomains: [],
     runsOfHistory: 0
   };
 }
@@ -7886,6 +8078,17 @@ function formatExplanationRow(row) {
     generatedAt: row.generatedAt
   };
 }
+function formatBriefRow(row) {
+  return {
+    targetRef: row.targetRef,
+    promptVersion: row.promptVersion,
+    provider: row.provider,
+    model: row.model,
+    brief: row.brief,
+    costMillicents: row.costMillicents,
+    generatedAt: row.generatedAt
+  };
+}
 function findRecommendationByRef(db, project, targetRef) {
   const input = loadOrchestratorInput(db, project);
   const rows = buildContentTargetRows(input);
@@ -7896,6 +8099,10 @@ async function contentRoutes(app, opts = {}) {
     const project = resolveProject(app.db, request.params.name);
     const includeInProgress = request.query["include-in-progress"] === "true";
     const limit = parseLimitParam(request.query.limit);
+    if (request.query["surface-class"] !== void 0) {
+      throw validationError('"surface-class" was renamed to "winnability-class"');
+    }
+    const winnabilityClassFilter = parseWinnabilityClassFilter(request.query["winnability-class"], request.query.ownable);
     const input = loadOrchestratorInput(app.db, project);
     let rows = buildContentTargetRows(input);
     if (!includeInProgress) {
@@ -7905,6 +8112,10 @@ async function contentRoutes(app, opts = {}) {
     if (dismissed.size > 0) {
       rows = rows.filter((r) => !dismissed.has(r.targetRef));
     }
+    if (winnabilityClassFilter) {
+      rows = rows.filter((r) => r.winnabilityClass === winnabilityClassFilter);
+    }
+    rows = [...rows].sort((a, b) => winnabilityClassRank(a.winnabilityClass) - winnabilityClassRank(b.winnabilityClass));
     if (limit !== void 0) {
       rows = rows.slice(0, limit);
     }
@@ -8065,6 +8276,113 @@ async function contentRoutes(app, opts = {}) {
     if (!row) throw notFound("recommendationExplanation", targetRef);
     return reply.send(formatExplanationRow(row));
   });
+  app.get("/projects/:name/content/recommendations/:targetRef/brief", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const { targetRef } = request.params;
+    const recommendation = findRecommendationByRef(app.db, project, targetRef);
+    if (!recommendation) {
+      throw notFound("contentRecommendation", targetRef);
+    }
+    if (recommendation.winnabilityClass === WinnabilityClasses.ceded) {
+      throw validationError(
+        `Cannot return a brief for "${recommendation.query}": its cited surface is now ceded (dominated by aggregators/editorial).`
+      );
+    }
+    const row = lookupCachedBrief(app.db, project.id, targetRef, opts.briefPromptVersion);
+    if (!row) throw notFound("recommendationBrief", request.params.targetRef);
+    return reply.send(formatBriefRow(row));
+  });
+  app.post("/projects/:name/content/recommendations/:targetRef/brief", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const synthesizer = opts.briefContentRecommendation;
+    if (!synthesizer) {
+      throw providerError(
+        "No AI provider configured for content briefs. Configure a provider via `canonry settings` or set an API key env var (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, ZAI_API_KEY)."
+      );
+    }
+    const parsed = recommendationExplainRequestSchema.safeParse(request.body ?? {});
+    if (!parsed.success) {
+      throw validationError(parsed.error.issues[0]?.message ?? "Invalid request body.");
+    }
+    const body = parsed.data;
+    const { targetRef } = request.params;
+    const recommendation = findRecommendationByRef(app.db, project, targetRef);
+    if (!recommendation) {
+      throw notFound("contentRecommendation", targetRef);
+    }
+    if (recommendation.winnabilityClass === WinnabilityClasses.ceded) {
+      throw validationError(
+        `Cannot synthesize a brief for "${recommendation.query}": its cited surface is ceded (dominated by aggregators/editorial). This is not a query first-party content can realistically win.`
+      );
+    }
+    if (!body.forceRefresh) {
+      const cached = lookupCachedBrief(app.db, project.id, targetRef, opts.briefPromptVersion);
+      if (cached) return reply.send(formatBriefRow(cached));
+    }
+    const result = await synthesizer({
+      projectId: project.id,
+      projectName: project.name,
+      canonicalDomain: project.canonicalDomain,
+      recommendation,
+      providerOverride: body.provider,
+      modelOverride: body.model
+    });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    app.db.insert(recommendationBriefs).values({
+      id: crypto11.randomUUID(),
+      projectId: project.id,
+      targetRef,
+      promptVersion: result.promptVersion,
+      provider: result.provider,
+      model: result.model,
+      brief: result.brief,
+      costMillicents: result.costMillicents,
+      generatedAt: now
+    }).onConflictDoUpdate({
+      target: [
+        recommendationBriefs.projectId,
+        recommendationBriefs.targetRef,
+        recommendationBriefs.promptVersion
+      ],
+      set: {
+        provider: result.provider,
+        model: result.model,
+        brief: result.brief,
+        costMillicents: result.costMillicents,
+        generatedAt: now
+      }
+    }).run();
+    const row = app.db.select().from(recommendationBriefs).where(and8(
+      eq13(recommendationBriefs.projectId, project.id),
+      eq13(recommendationBriefs.targetRef, targetRef),
+      eq13(recommendationBriefs.promptVersion, result.promptVersion)
+    )).get();
+    if (!row) throw notFound("recommendationBrief", targetRef);
+    return reply.send(formatBriefRow(row));
+  });
+  app.get("/projects/:name/content/domain-classifications", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const rows = app.db.select().from(domainClassifications).where(eq13(domainClassifications.projectId, project.id)).orderBy(desc6(domainClassifications.hits)).all();
+    const response = {
+      classifications: rows.map((r) => ({
+        domain: r.domain,
+        competitorType: r.competitorType,
+        hits: r.hits,
+        updatedAt: r.updatedAt
+      }))
+    };
+    return response;
+  });
+}
+function lookupCachedBrief(db, projectId, targetRef, promptVersion) {
+  const conditions = [
+    eq13(recommendationBriefs.projectId, projectId),
+    eq13(recommendationBriefs.targetRef, targetRef)
+  ];
+  if (promptVersion !== void 0) {
+    conditions.push(eq13(recommendationBriefs.promptVersion, promptVersion));
+  }
+  return db.select().from(recommendationBriefs).where(and8(...conditions)).orderBy(desc6(recommendationBriefs.generatedAt)).limit(1).get();
 }
 function parseLimitParam(raw) {
   if (raw === void 0) return void 0;
@@ -8074,6 +8392,20 @@ function parseLimitParam(raw) {
   }
   return parsed;
 }
+function parseWinnabilityClassFilter(raw, ownable) {
+  if (raw !== void 0) {
+    const parsed = winnabilityClassSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw validationError('"winnability-class" must be "ownable" or "ceded"');
+    }
+    return parsed.data;
+  }
+  if (ownable === "true") return WinnabilityClasses.ownable;
+  return void 0;
+}
+function winnabilityClassRank(winnabilityClass) {
+  return winnabilityClass === WinnabilityClasses.ownable ? 0 : 1;
+}
 
 // ../api-routes/src/report-renderer.ts
 var COLORS = {
@@ -9995,9 +10327,11 @@ function renderOpportunities(report) {
     const ourPage = o.ourBestPage ? `<a href="${safeHref(absolutizeProjectUrl(o.ourBestPage.url, canonical))}" target="_blank" rel="noopener noreferrer">${escapeHtml(o.ourBestPage.url)}</a>` : '<span class="cell-not-cited">No page yet</span>';
     const winning = o.winningCompetitor ? `<a href="${safeHref(o.winningCompetitor.url)}" target="_blank" rel="noopener noreferrer">${escapeHtml(o.winningCompetitor.domain)}</a>` : '<span class="cell-not-cited">\u2014</span>';
     const drivers = o.drivers.length > 0 ? `<ul class="driver-list">${o.drivers.map((d) => `<li>${escapeHtml(d)}</li>`).join("")}</ul>` : '<span class="cell-not-cited">No driver signal yet</span>';
+    const surfaceTone = o.winnabilityClass === "ceded" ? "tone-caution" : "tone-neutral";
     return `<tr>
       <td>${escapeHtml(o.query)}</td>
       <td><span class="badge tone-neutral">${escapeHtml(contentActionLabel(o.action))}</span></td>
+      <td><span class="badge ${surfaceTone}">${escapeHtml(winnabilityClassLabel(o.winnabilityClass))}</span></td>
       <td class="numeric" title="Opportunity score (0\u2013100)">${Math.round(o.score)}</td>
       <td>${drivers}</td>
       <td>${ourPage}</td>
@@ -10010,10 +10344,10 @@ function renderOpportunities(report) {
       id: "content-opportunities",
       eyebrow: "Section 14",
       title: "Content Opportunities",
-      intro: "Queries where content work has the clearest path to more AI citations. Opportunity score is 0\u2013100, higher = stronger."
+      intro: "Queries where content work has the clearest path to more AI citations. Opportunity score is 0\u2013100, higher = stronger. Winnability flags whether the cited surface is ownable or ceded to aggregators/editorial."
     },
     `${highlights}<table class="report-table">
-      <thead><tr><th>Query</th><th>Action</th><th class="numeric" title="Opportunity score (0\u2013100)">Score</th><th>Why</th><th>Our page</th><th>Winning competitor</th><th>Confidence</th></tr></thead>
+      <thead><tr><th>Query</th><th>Action</th><th>Winnability</th><th class="numeric" title="Opportunity score (0\u2013100)">Score</th><th>Why</th><th>Our page</th><th>Winning competitor</th><th>Confidence</th></tr></thead>
       <tbody>${rows}</tbody>
     </table>`
   );
@@ -10241,7 +10575,7 @@ function renderClientEvidenceSummary(report) {
       <ul class="client-opportunity-list">
         ${opportunities.map((o) => `<li>
           <div class="op-query">${escapeHtml(o.query)}</div>
-          <div class="op-action">${escapeHtml(contentActionLabel(o.action))}</div>
+          <div class="op-action">${escapeHtml(contentActionLabel(o.action))}${o.winnabilityClass === "ceded" ? ' <span class="badge tone-caution">Ceded surface</span>' : ""}</div>
         </li>`).join("")}
       </ul>
     </div>`);
@@ -12618,6 +12952,8 @@ var SCHEMA_TABLE = {
   ContentTargetsResponseDto: contentTargetsResponseDtoSchema,
   CreateApiKeyRequest: createApiKeyRequestSchema,
   CreatedApiKeyDto: createdApiKeyDtoSchema,
+  DomainClassificationsResponseDto: domainClassificationsResponseDtoSchema,
+  RecommendationBriefDto: recommendationBriefDtoSchema,
   RecommendationExplanationDto: recommendationExplanationDtoSchema,
   DiscoveryPromotePreview: discoveryPromotePreviewSchema,
   DiscoveryPromoteResult: discoveryPromoteResultSchema,
@@ -12664,6 +13000,7 @@ var SCHEMA_TABLE = {
   SnapshotDiffResponse: snapshotDiffResponseSchema,
   SnapshotListResponse: snapshotListResponseSchema,
   SnapshotReportDto: snapshotReportSchema,
+  SourceBreakdownDto: sourceBreakdownDtoSchema,
   TrafficBackfillResponse: trafficBackfillResponseSchema,
   TrafficEventsResponse: trafficEventsResponseSchema,
   TrafficSourceDetailDto: trafficSourceDetailDtoSchema,
@@ -13616,10 +13953,9 @@ var routeCatalog = [
     path: "/api/v1/projects/{name}/analytics/sources",
     summary: "Get source origin analytics",
     tags: ["analytics"],
-    parameters: [nameParameter, analyticsWindowParameter],
+    parameters: [nameParameter, analyticsWindowParameter, limitQueryParameter],
     responses: {
-      // TODO: Add `SourceBreakdownDto` Zod schema in contracts.
-      200: rawJsonResponse("Source breakdown returned.", looseObjectSchema),
+      200: jsonResponse("Source breakdown returned.", "SourceBreakdownDto"),
       404: errorResponse("Project not found.")
     }
   },
@@ -15529,16 +15865,18 @@ var routeCatalog = [
     method: "get",
     path: "/api/v1/projects/{name}/content/targets",
     summary: "Ranked, action-typed content opportunities",
-    description: "Returns the canonical opportunity list. Each row is `{query, action, ourBestPage?, winningCompetitor?, score, scoreBreakdown, drivers[], demandSource, actionConfidence, existingAction?}`. Hides rows with in-progress actions by default; pass `?include-in-progress=true` to include them annotated.",
+    description: "Returns the canonical opportunity list. Each row is `{query, action, ourBestPage?, winningCompetitor?, score, scoreBreakdown, drivers[], demandSource, actionConfidence, existingAction?, winnabilityClass, winnability?}`. `winnabilityClass` is the deterministic winnability gate (`ownable` worth a brief, `ceded` an aggregator/editorial head term to skip). Ownable rows sort first. Hides rows with in-progress actions by default; pass `?include-in-progress=true` to include them annotated.",
     tags: ["content"],
     parameters: [
       nameParameter,
       { name: "limit", in: "query", description: "Max rows returned.", schema: stringSchema },
-      { name: "include-in-progress", in: "query", description: "Include rows with in-flight tracked actions.", schema: stringSchema }
+      { name: "include-in-progress", in: "query", description: "Include rows with in-flight tracked actions.", schema: stringSchema },
+      { name: "winnability-class", in: "query", description: 'Filter by winnability: "ownable" or "ceded".', schema: stringSchema },
+      { name: "ownable", in: "query", description: 'Convenience alias for winnability-class=ownable when "true".', schema: stringSchema }
     ],
     responses: {
       200: jsonResponse("Targets returned.", "ContentTargetsResponseDto"),
-      400: errorResponse("Invalid limit."),
+      400: errorResponse("Invalid limit or winnability-class."),
       404: errorResponse("Project not found.")
     }
   },
@@ -15645,6 +15983,65 @@ var routeCatalog = [
       503: errorResponse("No AI provider configured for this project.")
     }
   },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/content/recommendations/{targetRef}/brief",
+    summary: "Get cached structured content brief for a recommendation",
+    description: "Returns the cached structured brief (`{targetQuery, winnabilityClass, angle, whyWinnable, schemaHookup, controllableSurfaceRationale}`) for one content recommendation at the current prompt version, or 404 if none exists. Cache-only read from the dedicated recommendation_briefs table \u2014 never collides with the prose explanation. Use `POST /brief` to synthesize one.",
+    tags: ["content"],
+    parameters: [
+      nameParameter,
+      { name: "targetRef", in: "path", required: true, description: "Stable hash from ContentTargetRowDto.targetRef.", schema: stringSchema }
+    ],
+    responses: {
+      200: jsonResponse("Cached brief.", "RecommendationBriefDto"),
+      404: errorResponse("No cached brief for this targetRef yet.")
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/content/recommendations/{targetRef}/brief",
+    summary: "Synthesize (or fetch cached) a structured content brief",
+    description: "Synthesizes a STRUCTURED content brief for one recommendation, reusing the `analyze` capability tier. GATED to `ownable` targets \u2014 a `ceded` head term (cited surface dominated by aggregators/editorial) is rejected with 400 before any LLM call. Cached per (project, targetRef, promptVersion) in a dedicated table; repeat calls without `forceRefresh` return the cached row free. Pass `provider`/`model` to override.",
+    tags: ["content"],
+    parameters: [
+      nameParameter,
+      { name: "targetRef", in: "path", required: true, description: "Stable hash from ContentTargetRowDto.targetRef.", schema: stringSchema }
+    ],
+    requestBody: {
+      required: false,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              provider: stringSchema,
+              model: stringSchema,
+              forceRefresh: { type: "boolean" }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: jsonResponse("Brief synthesized or returned from cache.", "RecommendationBriefDto"),
+      400: errorResponse("Invalid request body, unknown provider, or target is ceded (not winnable)."),
+      404: errorResponse("Project not found or targetRef does not match any current recommendation."),
+      503: errorResponse("No AI provider configured for this project.")
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/content/domain-classifications",
+    summary: "List per-domain cited-surface classifications",
+    description: "Returns every cited-surface domain classification discovery has produced for the project (`{domain, competitorType, hits, updatedAt}`), ranked by recurrence. This is the read surface behind the winnabilityClass winnability gate; running discovery improves coverage.",
+    tags: ["content"],
+    parameters: [nameParameter],
+    responses: {
+      200: jsonResponse("Classifications returned.", "DomainClassificationsResponseDto"),
+      404: errorResponse("Project not found.")
+    }
+  },
   {
     method: "get",
     path: "/api/v1/projects/{name}/content/sources",
@@ -27279,6 +27676,7 @@ async function listVercelTrafficEvents(options) {
 
 // ../integration-vercel/src/drain.ts
 var MIN_SUB_WINDOW_MS = 1e3;
+var INITIAL_SUB_WINDOW_MS = 5 * 6e4;
 var FLOOR_SLICE_MAX_PAGES = 1e3;
 var FLOOR_CONGESTION_PROBE_INTERVAL = 60;
 var RETENTION_PROBE_WINDOW_MS = 6e4;
@@ -27333,7 +27731,7 @@ async function drainVercelTrafficEvents(options) {
     return { events, subWindowCount: 0, effectiveStartMs: startMs, retentionClamped: false, truncatedSliceCount: 0, truncatedSliceStartsMs: [], drainedThroughMs: startMs, deadlineReached: false };
   }
   let cursorMs = startMs;
-  let spanMs = endMs - startMs;
+  let spanMs = Math.min(endMs - startMs, INITIAL_SUB_WINDOW_MS);
   let subWindowCount = 0;
   let effectiveStartMs = startMs;
   let retentionClamped = false;
@@ -27375,7 +27773,7 @@ async function drainVercelTrafficEvents(options) {
         retentionClamped = retainedStartMs > cursorMs;
         cursorMs = retainedStartMs;
         effectiveStartMs = retainedStartMs;
-        spanMs = Math.max(endMs - cursorMs, MIN_SUB_WINDOW_MS);
+        spanMs = Math.max(Math.min(endMs - cursorMs, INITIAL_SUB_WINDOW_MS), MIN_SUB_WINDOW_MS);
         continue;
       }
       throw error;
@@ -29214,6 +29612,104 @@ var BING_AUTH_CHECKS = [
   }
 ];
 
+// ../api-routes/src/doctor/checks/content.ts
+import { eq as eq26 } from "drizzle-orm";
+var WINNABILITY_COVERAGE_WARN_THRESHOLD = 0.8;
+var UNCLASSIFIED_DOMAIN_SAMPLE_LIMIT = 10;
+function skippedNoProject() {
+  return {
+    status: CheckStatuses.skipped,
+    code: "content.winnability.no-project",
+    summary: "Project context required for content winnability checks.",
+    remediation: "Run `canonry doctor --project <name>` to scope this check to a project."
+  };
+}
+function loadProject(ctx) {
+  if (!ctx.project) return null;
+  return ctx.db.select().from(projects).where(eq26(projects.id, ctx.project.id)).get() ?? null;
+}
+function percent(value) {
+  return Math.round(value * 100);
+}
+var winnabilityCoverageCheck = {
+  id: "content.winnability.coverage",
+  category: CheckCategories.integrations,
+  scope: CheckScopes.project,
+  title: "Content winnability classification coverage",
+  run: (ctx) => {
+    if (!ctx.project) return skippedNoProject();
+    const project = loadProject(ctx);
+    if (!project) {
+      return {
+        status: CheckStatuses.fail,
+        code: "content.winnability.project-missing",
+        summary: "Project row disappeared before the content winnability check could run.",
+        remediation: "Re-run `canonry doctor --project <name>`; if this persists, inspect the local database."
+      };
+    }
+    const input = loadOrchestratorInput(ctx.db, project);
+    const citationCounts = /* @__PURE__ */ new Map();
+    for (const candidate of input.candidateQueries) {
+      for (const cited of candidate.citedSurfaceDomains) {
+        citationCounts.set(cited.domain, (citationCounts.get(cited.domain) ?? 0) + cited.citationCount);
+      }
+    }
+    const citedDomains = [...citationCounts.keys()].sort();
+    if (citedDomains.length === 0) {
+      return {
+        status: CheckStatuses.skipped,
+        code: "content.winnability.no-cited-surface",
+        summary: "No non-owned cited-surface domains in recent content evidence, so the winnability gate has nothing to classify yet.",
+        remediation: `Run \`canonry run ${ctx.project.name}\` to capture fresh answer-engine citations before checking discovery coverage.`,
+        details: {
+          citedSurfaceDomainCount: 0,
+          classifiedDomainCount: input.domainClasses.size
+        }
+      };
+    }
+    const coveredDomains = citedDomains.filter((domain) => input.domainClasses.has(domain));
+    const unclassifiedDomains = citedDomains.filter((domain) => !input.domainClasses.has(domain));
+    const coverage = coveredDomains.length / citedDomains.length;
+    const details = {
+      citedSurfaceDomainCount: citedDomains.length,
+      classifiedDomainCount: input.domainClasses.size,
+      coveredDomainCount: coveredDomains.length,
+      coverage,
+      threshold: WINNABILITY_COVERAGE_WARN_THRESHOLD,
+      unclassifiedDomains: unclassifiedDomains.slice(0, UNCLASSIFIED_DOMAIN_SAMPLE_LIMIT)
+    };
+    if (coveredDomains.length === 0) {
+      return {
+        status: CheckStatuses.warn,
+        code: "content.winnability.no-classifications",
+        summary: `0 of ${citedDomains.length} cited-surface domain(s) have discovery classifications; the winnability gate is failing open.`,
+        remediation: `Run \`canonry discover run ${ctx.project.name} --wait\` to classify cited domains before trusting ownable/ceded content targets.`,
+        details
+      };
+    }
+    if (coverage < WINNABILITY_COVERAGE_WARN_THRESHOLD) {
+      return {
+        status: CheckStatuses.warn,
+        code: "content.winnability.low-coverage",
+        summary: `${coveredDomains.length} of ${citedDomains.length} cited-surface domain(s) classified (${percent(coverage)}%); the winnability gate may miss ceded surfaces.`,
+        remediation: `Run \`canonry discover run ${ctx.project.name} --wait\` to raise classification coverage before relying on ownable/ceded content targets.`,
+        details
+      };
+    }
+    return {
+      status: CheckStatuses.ok,
+      code: "content.winnability.covered",
+      summary: `${coveredDomains.length} of ${citedDomains.length} cited-surface domain(s) classified (${percent(coverage)}%); the winnability gate is active.`,
+      remediation: null,
+      details
+    };
+  }
+};
+var CONTENT_CHECKS = [winnabilityCoverageCheck];
+var CONTENT_CHECK_BY_ID = Object.fromEntries(
+  CONTENT_CHECKS.map((check) => [check.id, check])
+);
+
 // ../api-routes/src/doctor/checks/ga-auth.ts
 async function checkServiceAccount(conn) {
   if (!conn.propertyId) {
@@ -29356,10 +29852,10 @@ var ga4ConnectionCheck = {
 var GA_AUTH_CHECKS = [ga4ConnectionCheck];
 
 // ../api-routes/src/doctor/checks/gbp-auth.ts
-import { and as and20, eq as eq26 } from "drizzle-orm";
+import { and as and20, eq as eq27 } from "drizzle-orm";
 var RECENT_SYNC_WARN_DAYS = 7;
 var RECENT_SYNC_FAIL_DAYS = 30;
-function skippedNoProject() {
+function skippedNoProject2() {
   return {
     status: CheckStatuses.skipped,
     code: "gbp.auth.no-project",
@@ -29376,7 +29872,7 @@ function storeUnavailable() {
   };
 }
 async function resolveGbpToken(ctx) {
-  if (!ctx.project) return { ok: false, output: skippedNoProject() };
+  if (!ctx.project) return { ok: false, output: skippedNoProject2() };
   const store = ctx.googleConnectionStore;
   if (!store) return { ok: false, output: storeUnavailable() };
   const auth = ctx.getGoogleAuthConfig?.() ?? {};
@@ -29454,7 +29950,7 @@ var scopesCheck = {
   scope: CheckScopes.project,
   title: "GBP granted scopes",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject();
+    if (!ctx.project) return skippedNoProject2();
     const store = ctx.googleConnectionStore;
     if (!store) return storeUnavailable();
     const conn = store.getConnection(ctx.project.canonicalDomain, "gbp");
@@ -29491,7 +29987,7 @@ var accountAccessCheck = {
   scope: CheckScopes.project,
   title: "GBP account access",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject();
+    if (!ctx.project) return skippedNoProject2();
     const store = ctx.googleConnectionStore;
     if (!store) return storeUnavailable();
     const conn = store.getConnection(ctx.project.canonicalDomain, "gbp");
@@ -29588,8 +30084,8 @@ var recentSyncCheck = {
   scope: CheckScopes.project,
   title: "GBP recent sync",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject();
-    const selected = ctx.db.select({ locationName: gbpLocations.locationName, syncedAt: gbpLocations.syncedAt }).from(gbpLocations).where(and20(eq26(gbpLocations.projectId, ctx.project.id), eq26(gbpLocations.selected, true))).all();
+    if (!ctx.project) return skippedNoProject2();
+    const selected = ctx.db.select({ locationName: gbpLocations.locationName, syncedAt: gbpLocations.syncedAt }).from(gbpLocations).where(and20(eq27(gbpLocations.projectId, ctx.project.id), eq27(gbpLocations.selected, true))).all();
     if (selected.length === 0) {
       return {
         status: CheckStatuses.skipped,
@@ -29649,7 +30145,7 @@ var GBP_AUTH_CHECK_BY_ID = Object.fromEntries(
 );
 
 // ../api-routes/src/doctor/checks/places.ts
-import { eq as eq27 } from "drizzle-orm";
+import { eq as eq28 } from "drizzle-orm";
 var apiKeyCheck = {
   id: "gbp.places.api-key",
   category: CheckCategories.auth,
@@ -29694,7 +30190,7 @@ var apiKeyCheck = {
         details: { tier: cfg.tier }
       };
     }
-    const rows = ctx.db.select({ placeId: gbpLocations.placeId, selected: gbpLocations.selected }).from(gbpLocations).where(eq27(gbpLocations.projectId, ctx.project.id)).all();
+    const rows = ctx.db.select({ placeId: gbpLocations.placeId, selected: gbpLocations.selected }).from(gbpLocations).where(eq28(gbpLocations.projectId, ctx.project.id)).all();
     const selected = rows.filter((r) => r.selected);
     const locationsWithPlaceId = selected.filter((r) => Boolean(r.placeId)).length;
     const details = {
@@ -29730,7 +30226,7 @@ var PLACES_CHECK_BY_ID = Object.fromEntries(
 var REQUIRED_GSC_SCOPES = [GSC_SCOPE, INDEXING_SCOPE];
 async function resolveAccessToken(ctx) {
   if (!ctx.project) {
-    return { ok: false, output: skippedNoProject2() };
+    return { ok: false, output: skippedNoProject3() };
   }
   const store = ctx.googleConnectionStore;
   if (!store) {
@@ -29797,7 +30293,7 @@ async function resolveAccessToken(ctx) {
     };
   }
 }
-function skippedNoProject2() {
+function skippedNoProject3() {
   return {
     status: CheckStatuses.skipped,
     code: "google.auth.no-project",
@@ -29827,7 +30323,7 @@ var propertyAccessCheck = {
   scope: CheckScopes.project,
   title: "GSC property access",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject2();
+    if (!ctx.project) return skippedNoProject3();
     const store = ctx.googleConnectionStore;
     if (!store) {
       return {
@@ -29928,7 +30424,7 @@ var redirectUriCheck = {
   scope: CheckScopes.project,
   title: "OAuth redirect URI",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject2();
+    if (!ctx.project) return skippedNoProject3();
     const auth = ctx.getGoogleAuthConfig?.() ?? {};
     if (!auth.clientId || !auth.clientSecret) {
       return {
@@ -29982,7 +30478,7 @@ var scopesCheck2 = {
   scope: CheckScopes.project,
   title: "GSC granted scopes",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject2();
+    if (!ctx.project) return skippedNoProject3();
     const store = ctx.googleConnectionStore;
     if (!store) {
       return {
@@ -30145,10 +30641,10 @@ var RUNTIME_STATE_CHECKS = [
 ];
 
 // ../api-routes/src/doctor/checks/traffic-source.ts
-import { and as and21, eq as eq28, gte as gte4, ne as ne4, sql as sql12 } from "drizzle-orm";
+import { and as and21, eq as eq29, gte as gte4, ne as ne4, sql as sql12 } from "drizzle-orm";
 var RECENT_DATA_WARN_DAYS = 7;
 var RECENT_DATA_FAIL_DAYS = 30;
-function skippedNoProject3() {
+function skippedNoProject4() {
   return {
     status: CheckStatuses.skipped,
     code: "traffic.no-project",
@@ -30160,7 +30656,7 @@ function loadProbes(ctx) {
   if (!ctx.project) return [];
   const rows = ctx.db.select().from(trafficSources).where(
     and21(
-      eq28(trafficSources.projectId, ctx.project.id),
+      eq29(trafficSources.projectId, ctx.project.id),
       ne4(trafficSources.status, TrafficSourceStatuses.archived)
     )
   ).all();
@@ -30182,7 +30678,7 @@ var sourceConnectedCheck = {
   scope: CheckScopes.project,
   title: "Traffic source connected",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -30226,7 +30722,7 @@ var recentDataCheck = {
   scope: CheckScopes.project,
   title: "Traffic source recent data",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -30241,7 +30737,7 @@ var recentDataCheck = {
     const recentCrawlers = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(
         and21(
-          eq28(crawlerEventsHourly.projectId, ctx.project.id),
+          eq29(crawlerEventsHourly.projectId, ctx.project.id),
           gte4(crawlerEventsHourly.tsHour, warnCutoff)
         )
       ).get()?.total ?? 0
@@ -30249,7 +30745,7 @@ var recentDataCheck = {
     const recentReferrals = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(
         and21(
-          eq28(aiReferralEventsHourly.projectId, ctx.project.id),
+          eq29(aiReferralEventsHourly.projectId, ctx.project.id),
           gte4(aiReferralEventsHourly.tsHour, warnCutoff)
         )
       ).get()?.total ?? 0
@@ -30265,7 +30761,7 @@ var recentDataCheck = {
     const olderCrawlers = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(
         and21(
-          eq28(crawlerEventsHourly.projectId, ctx.project.id),
+          eq29(crawlerEventsHourly.projectId, ctx.project.id),
           gte4(crawlerEventsHourly.tsHour, failCutoff)
         )
       ).get()?.total ?? 0
@@ -30273,7 +30769,7 @@ var recentDataCheck = {
     const olderReferrals = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(
         and21(
-          eq28(aiReferralEventsHourly.projectId, ctx.project.id),
+          eq29(aiReferralEventsHourly.projectId, ctx.project.id),
           gte4(aiReferralEventsHourly.tsHour, failCutoff)
         )
       ).get()?.total ?? 0
@@ -30388,7 +30884,7 @@ var credentialsCheck = {
   scope: CheckScopes.project,
   title: "Traffic source credentials",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -30417,7 +30913,7 @@ var scopesCheck3 = {
   scope: CheckScopes.project,
   title: "Traffic source scopes",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -30530,6 +31026,7 @@ var ALL_CHECKS = [
   ...GA_AUTH_CHECKS,
   ...PROVIDERS_CHECKS,
   ...TRAFFIC_SOURCE_CHECKS,
+  ...CONTENT_CHECKS,
   ...AGENT_CHECKS
 ];
 
@@ -30652,7 +31149,7 @@ async function doctorRoutes(app, opts) {
 
 // ../api-routes/src/discovery/routes.ts
 import crypto25 from "crypto";
-import { and as and22, desc as desc15, eq as eq29, gte as gte5, inArray as inArray10 } from "drizzle-orm";
+import { and as and22, desc as desc15, eq as eq30, gte as gte5, inArray as inArray10 } from "drizzle-orm";
 var MAX_INFLIGHT_DISCOVERY_AGE_MS = 2 * 60 * 60 * 1e3;
 async function discoveryRoutes(app, opts) {
   app.post("/projects/:name/discover/run", async (request, reply) => {
@@ -30685,8 +31182,8 @@ async function discoveryRoutes(app, opts) {
     const ageFloorIso = new Date(Date.now() - MAX_INFLIGHT_DISCOVERY_AGE_MS).toISOString();
     const decision = app.db.transaction((tx) => {
       const existing = tx.select({ id: discoverySessions.id, runId: discoverySessions.runId }).from(discoverySessions).where(and22(
-        eq29(discoverySessions.projectId, project.id),
-        eq29(discoverySessions.icpDescription, icpDescription),
+        eq30(discoverySessions.projectId, project.id),
+        eq30(discoverySessions.icpDescription, icpDescription),
         inArray10(discoverySessions.status, [
           DiscoverySessionStatuses.queued,
           DiscoverySessionStatuses.seeding,
@@ -30756,7 +31253,7 @@ async function discoveryRoutes(app, opts) {
       const project = resolveProject(app.db, request.params.name);
       const parsedLimit = parseInt(request.query.limit ?? "", 10);
       const limit = Number.isNaN(parsedLimit) || parsedLimit <= 0 ? 50 : parsedLimit;
-      const rows = app.db.select().from(discoverySessions).where(eq29(discoverySessions.projectId, project.id)).orderBy(desc15(discoverySessions.createdAt)).limit(limit).all();
+      const rows = app.db.select().from(discoverySessions).where(eq30(discoverySessions.projectId, project.id)).orderBy(desc15(discoverySessions.createdAt)).limit(limit).all();
       return reply.send(rows.map(serializeSession));
     }
   );
@@ -30764,11 +31261,11 @@ async function discoveryRoutes(app, opts) {
     "/projects/:name/discover/sessions/:id",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const session = app.db.select().from(discoverySessions).where(eq29(discoverySessions.id, request.params.id)).get();
+      const session = app.db.select().from(discoverySessions).where(eq30(discoverySessions.id, request.params.id)).get();
       if (!session || session.projectId !== project.id) {
         throw notFound("Discovery session", request.params.id);
       }
-      const probeRows = app.db.select().from(discoveryProbes).where(eq29(discoveryProbes.sessionId, session.id)).all();
+      const probeRows = app.db.select().from(discoveryProbes).where(eq30(discoveryProbes.sessionId, session.id)).all();
       const detail = {
         ...serializeSession(session),
         probes: probeRows.map(serializeProbe)
@@ -30780,12 +31277,12 @@ async function discoveryRoutes(app, opts) {
     "/projects/:name/discover/sessions/:id/promote",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const session = app.db.select().from(discoverySessions).where(eq29(discoverySessions.id, request.params.id)).get();
+      const session = app.db.select().from(discoverySessions).where(eq30(discoverySessions.id, request.params.id)).get();
       if (!session || session.projectId !== project.id) {
         throw notFound("Discovery session", request.params.id);
       }
-      const probeRows = app.db.select().from(discoveryProbes).where(eq29(discoveryProbes.sessionId, session.id)).all();
-      const existingCompetitors = app.db.select({ domain: competitors.domain }).from(competitors).where(eq29(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase());
+      const probeRows = app.db.select().from(discoveryProbes).where(eq30(discoveryProbes.sessionId, session.id)).all();
+      const existingCompetitors = app.db.select({ domain: competitors.domain }).from(competitors).where(eq30(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase());
       const seenCompetitors = new Set(existingCompetitors);
       const cited = /* @__PURE__ */ new Set();
       const aspirational = /* @__PURE__ */ new Set();
@@ -30814,7 +31311,7 @@ async function discoveryRoutes(app, opts) {
   );
   app.post("/projects/:name/discover/sessions/:id/promote", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const session = app.db.select().from(discoverySessions).where(eq29(discoverySessions.id, request.params.id)).get();
+    const session = app.db.select().from(discoverySessions).where(eq30(discoverySessions.id, request.params.id)).get();
     if (!session || session.projectId !== project.id) {
       throw notFound("Discovery session", request.params.id);
     }
@@ -30837,7 +31334,7 @@ async function discoveryRoutes(app, opts) {
     const bucketSet = new Set(buckets);
     const includeCompetitors = parsed.data.includeCompetitors ?? true;
     const competitorTypes = parsed.data.competitorTypes ?? DEFAULT_DISCOVERY_PROMOTE_COMPETITOR_TYPES;
-    const probeRows = app.db.select().from(discoveryProbes).where(eq29(discoveryProbes.sessionId, session.id)).all();
+    const probeRows = app.db.select().from(discoveryProbes).where(eq30(discoveryProbes.sessionId, session.id)).all();
     const candidateQueries = /* @__PURE__ */ new Set();
     for (const probe of probeRows) {
       if (!probe.bucket) continue;
@@ -30845,7 +31342,7 @@ async function discoveryRoutes(app, opts) {
       if (bucket.success && bucketSet.has(bucket.data)) candidateQueries.add(probe.query);
     }
     const existingQueries = new Set(
-      app.db.select({ query: queries.query }).from(queries).where(eq29(queries.projectId, project.id)).all().map((r) => r.query.toLowerCase())
+      app.db.select({ query: queries.query }).from(queries).where(eq30(queries.projectId, project.id)).all().map((r) => r.query.toLowerCase())
     );
     const promotedQueries = [];
     const skippedQueries = [];
@@ -30861,7 +31358,7 @@ async function discoveryRoutes(app, opts) {
     const skippedCompetitors = [];
     if (includeCompetitors) {
       const existingCompetitors = new Set(
-        app.db.select({ domain: competitors.domain }).from(competitors).where(eq29(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase())
+        app.db.select({ domain: competitors.domain }).from(competitors).where(eq30(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase())
       );
       const competitorMap = parseCompetitorMap(session.competitorMap);
       for (const entry of selectEligibleCompetitors(competitorMap, competitorTypes)) {
@@ -30964,7 +31461,7 @@ function selectEligibleCompetitors(competitorMap, competitorTypes) {
 
 // ../api-routes/src/discovery/orchestrate.ts
 import crypto26 from "crypto";
-import { eq as eq30 } from "drizzle-orm";
+import { eq as eq31 } from "drizzle-orm";
 var DEFAULT_DEDUP_THRESHOLD = 0.85;
 var DEFAULT_MAX_PROBES = 100;
 var ABSOLUTE_MAX_PROBES = 500;
@@ -31019,7 +31516,7 @@ async function executeDiscovery(opts) {
     status: DiscoverySessionStatuses.seeding,
     dedupThreshold,
     startedAt
-  }).where(eq30(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq31(discoverySessions.id, opts.sessionId)).run();
   const seedResult = await opts.deps.seed({
     project: opts.project,
     icpDescription: opts.icpDescription,
@@ -31039,7 +31536,7 @@ async function executeDiscovery(opts) {
     seedProvider: seedResult.provider,
     seedCountRaw,
     seedCount
-  }).where(eq30(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq31(discoverySessions.id, opts.sessionId)).run();
   const probeRows = [];
   const buckets = { cited: 0, aspirational: 0, "wasted-surface": 0 };
   for (const query of probedCanonicals) {
@@ -31079,7 +31576,8 @@ async function executeDiscovery(opts) {
     wastedCount: buckets["wasted-surface"],
     competitorMap,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq30(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq31(discoverySessions.id, opts.sessionId)).run();
+  upsertDomainClassifications(opts.db, opts.project.id, opts.sessionId, competitorMap);
   return {
     buckets,
     competitorMap,
@@ -31088,12 +31586,37 @@ async function executeDiscovery(opts) {
     seedProvider: seedResult.provider
   };
 }
+function upsertDomainClassifications(db, projectId, sessionId, competitorMap) {
+  if (competitorMap.length === 0) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const entry of competitorMap) {
+    const domain = normalizeDomain(entry.domain);
+    if (!domain) continue;
+    db.insert(domainClassifications).values({
+      id: crypto26.randomUUID(),
+      projectId,
+      domain,
+      competitorType: entry.competitorType,
+      hits: entry.hits,
+      sessionId,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: [domainClassifications.projectId, domainClassifications.domain],
+      set: {
+        competitorType: entry.competitorType,
+        hits: entry.hits,
+        sessionId,
+        updatedAt: now
+      }
+    }).run();
+  }
+}
 function markSessionFailed(db, sessionId, error) {
   db.update(discoverySessions).set({
     status: DiscoverySessionStatuses.failed,
     error,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq30(discoverySessions.id, sessionId)).run();
+  }).where(eq31(discoverySessions.id, sessionId)).run();
 }
 function dedupeStrings(input) {
   const seen = /* @__PURE__ */ new Set();
@@ -31190,7 +31713,11 @@ async function apiRoutes(app, opts) {
     await api.register(reportRoutes);
     await api.register(citationRoutes);
     await api.register(compositeRoutes);
-    await api.register(contentRoutes, { explainContentRecommendation: opts.explainContentRecommendation });
+    await api.register(contentRoutes, {
+      explainContentRecommendation: opts.explainContentRecommendation,
+      briefContentRecommendation: opts.briefContentRecommendation,
+      briefPromptVersion: opts.briefPromptVersion
+    });
     await api.register(settingsRoutes, {
       providerSummary: opts.providerSummary,
       providerAdapters: opts.providerAdapters,
@@ -31656,8 +32183,8 @@ var IntelligenceService = class {
   analyzeAndPersist(runId, projectId) {
     const recentRuns = this.db.select().from(runs).where(
       and23(
-        eq31(runs.projectId, projectId),
-        or5(eq31(runs.status, "completed"), eq31(runs.status, "partial")),
+        eq32(runs.projectId, projectId),
+        or5(eq32(runs.status, "completed"), eq32(runs.status, "partial")),
         // Defensive: RunCoordinator already skips probes before this is
         // called, but if a future call site invokes analyzeAndPersist
         // directly for a probe, probes still must not pollute the
@@ -31739,7 +32266,7 @@ var IntelligenceService = class {
    * Returns the persisted insights so the coordinator can count critical/high.
    */
   analyzeAndPersistGbp(runId, projectId) {
-    const runRow = this.db.select({ createdAt: runs.createdAt, startedAt: runs.startedAt, finishedAt: runs.finishedAt }).from(runs).where(eq31(runs.id, runId)).get();
+    const runRow = this.db.select({ createdAt: runs.createdAt, startedAt: runs.startedAt, finishedAt: runs.finishedAt }).from(runs).where(eq32(runs.id, runId)).get();
     if (!runRow) {
       log.info("gbp-intelligence.skip", { runId, reason: "run not found" });
       this.persistGbpInsights(runId, projectId, [], []);
@@ -31748,8 +32275,8 @@ var IntelligenceService = class {
     const windowStart = runRow.startedAt ?? runRow.createdAt;
     const windowEnd = runRow.finishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
     const selected = this.db.select().from(gbpLocations).where(and23(
-      eq31(gbpLocations.projectId, projectId),
-      eq31(gbpLocations.selected, true),
+      eq32(gbpLocations.projectId, projectId),
+      eq32(gbpLocations.selected, true),
       gte6(gbpLocations.syncedAt, windowStart),
       lte3(gbpLocations.syncedAt, windowEnd)
     )).all();
@@ -31784,10 +32311,10 @@ var IntelligenceService = class {
   }
   /** Build the per-location signal bundle the GBP analyzer consumes. */
   buildGbpLocationSignals(projectId, locationName, displayName, fallbackDate) {
-    const metricRows = this.db.select({ metric: gbpDailyMetrics.metric, date: gbpDailyMetrics.date, value: gbpDailyMetrics.value }).from(gbpDailyMetrics).where(and23(eq31(gbpDailyMetrics.projectId, projectId), eq31(gbpDailyMetrics.locationName, locationName))).all();
-    const placeActionRows = this.db.select({ placeActionType: gbpPlaceActions.placeActionType, providerType: gbpPlaceActions.providerType }).from(gbpPlaceActions).where(and23(eq31(gbpPlaceActions.projectId, projectId), eq31(gbpPlaceActions.locationName, locationName))).all();
-    const lodgingRow = this.db.select({ populatedGroupCount: gbpLodgingSnapshots.populatedGroupCount }).from(gbpLodgingSnapshots).where(and23(eq31(gbpLodgingSnapshots.projectId, projectId), eq31(gbpLodgingSnapshots.locationName, locationName))).orderBy(desc16(gbpLodgingSnapshots.syncedAt)).limit(1).get();
-    const placeRow = this.db.select({ attributes: gbpPlaceDetails.attributes }).from(gbpPlaceDetails).where(and23(eq31(gbpPlaceDetails.projectId, projectId), eq31(gbpPlaceDetails.locationName, locationName))).orderBy(desc16(gbpPlaceDetails.syncedAt)).limit(1).get();
+    const metricRows = this.db.select({ metric: gbpDailyMetrics.metric, date: gbpDailyMetrics.date, value: gbpDailyMetrics.value }).from(gbpDailyMetrics).where(and23(eq32(gbpDailyMetrics.projectId, projectId), eq32(gbpDailyMetrics.locationName, locationName))).all();
+    const placeActionRows = this.db.select({ placeActionType: gbpPlaceActions.placeActionType, providerType: gbpPlaceActions.providerType }).from(gbpPlaceActions).where(and23(eq32(gbpPlaceActions.projectId, projectId), eq32(gbpPlaceActions.locationName, locationName))).all();
+    const lodgingRow = this.db.select({ populatedGroupCount: gbpLodgingSnapshots.populatedGroupCount }).from(gbpLodgingSnapshots).where(and23(eq32(gbpLodgingSnapshots.projectId, projectId), eq32(gbpLodgingSnapshots.locationName, locationName))).orderBy(desc16(gbpLodgingSnapshots.syncedAt)).limit(1).get();
+    const placeRow = this.db.select({ attributes: gbpPlaceDetails.attributes }).from(gbpPlaceDetails).where(and23(eq32(gbpPlaceDetails.projectId, projectId), eq32(gbpPlaceDetails.locationName, locationName))).orderBy(desc16(gbpPlaceDetails.syncedAt)).limit(1).get();
     const placesAmenities = placeRow ? extractPlaceAmenities(placeRow.attributes) : [];
     const summary = buildGbpSummary({
       locationName,
@@ -31819,7 +32346,7 @@ var IntelligenceService = class {
   /** Build the month-over-month keyword series for a location from the
    *  accumulating gbp_keyword_monthly table (latest complete month vs prior). */
   buildGbpKeywordTrend(projectId, locationName) {
-    const rows = this.db.select({ month: gbpKeywordMonthly.month, keyword: gbpKeywordMonthly.keyword, valueCount: gbpKeywordMonthly.valueCount }).from(gbpKeywordMonthly).where(and23(eq31(gbpKeywordMonthly.projectId, projectId), eq31(gbpKeywordMonthly.locationName, locationName))).all();
+    const rows = this.db.select({ month: gbpKeywordMonthly.month, keyword: gbpKeywordMonthly.keyword, valueCount: gbpKeywordMonthly.valueCount }).from(gbpKeywordMonthly).where(and23(eq32(gbpKeywordMonthly.projectId, projectId), eq32(gbpKeywordMonthly.locationName, locationName))).all();
     if (rows.length === 0) return { recentMonth: null, priorMonth: null, points: [] };
     const months = [...new Set(rows.map((r) => r.month))].sort().reverse();
     const recentMonth = months[0] ?? null;
@@ -31850,7 +32377,7 @@ var IntelligenceService = class {
    */
   persistGbpInsights(runId, projectId, gbpInsights, coveredLocationNames) {
     const covered = new Set(coveredLocationNames);
-    const existing = this.db.select({ id: insights.id, dismissed: insights.dismissed }).from(insights).where(and23(eq31(insights.projectId, projectId), eq31(insights.provider, GBP_INSIGHT_PROVIDER))).all();
+    const existing = this.db.select({ id: insights.id, dismissed: insights.dismissed }).from(insights).where(and23(eq32(insights.projectId, projectId), eq32(insights.provider, GBP_INSIGHT_PROVIDER))).all();
     const staleIds = [];
     const dismissedSlots = /* @__PURE__ */ new Set();
     for (const row of existing) {
@@ -31861,7 +32388,7 @@ var IntelligenceService = class {
     }
     this.db.transaction((tx) => {
       for (const id of staleIds) {
-        tx.delete(insights).where(eq31(insights.id, id)).run();
+        tx.delete(insights).where(eq32(insights.id, id)).run();
       }
       for (const insight of gbpInsights) {
         const parsed = parseGbpInsightId(insight.id);
@@ -31939,7 +32466,7 @@ var IntelligenceService = class {
    *     create per run + aggregate). DB is left untouched.
    */
   backfill(projectName, opts, onProgress) {
-    const project = this.db.select().from(projects).where(eq31(projects.name, projectName)).get();
+    const project = this.db.select().from(projects).where(eq32(projects.name, projectName)).get();
     if (!project) {
       throw new Error(`Project "${projectName}" not found`);
     }
@@ -31953,8 +32480,8 @@ var IntelligenceService = class {
     }
     const allRuns = this.db.select().from(runs).where(
       and23(
-        eq31(runs.projectId, project.id),
-        or5(eq31(runs.status, "completed"), eq31(runs.status, "partial")),
+        eq32(runs.projectId, project.id),
+        or5(eq32(runs.status, "completed"), eq32(runs.status, "partial")),
         // Backfill must not replay probe runs as if they were real sweeps.
         ne5(runs.trigger, RunTriggers.probe)
       )
@@ -32033,7 +32560,7 @@ var IntelligenceService = class {
     return { processed, skipped, totalInsights };
   }
   loadTrackedCompetitors(projectId) {
-    return this.db.select({ domain: competitors.domain }).from(competitors).where(eq31(competitors.projectId, projectId)).all().map((r) => r.domain);
+    return this.db.select({ domain: competitors.domain }).from(competitors).where(eq32(competitors.projectId, projectId)).all().map((r) => r.domain);
   }
   /**
    * Wipe transition signals from an analysis result while keeping health.
@@ -32054,15 +32581,15 @@ var IntelligenceService = class {
   }
   persistResult(result, runId, projectId) {
     const previouslyDismissed = /* @__PURE__ */ new Set();
-    const existingInsights = this.db.select({ query: insights.query, provider: insights.provider, type: insights.type, dismissed: insights.dismissed }).from(insights).where(eq31(insights.runId, runId)).all();
+    const existingInsights = this.db.select({ query: insights.query, provider: insights.provider, type: insights.type, dismissed: insights.dismissed }).from(insights).where(eq32(insights.runId, runId)).all();
     for (const row of existingInsights) {
       if (row.dismissed) {
         previouslyDismissed.add(`${row.query}:${row.provider}:${row.type}`);
       }
     }
     this.db.transaction((tx) => {
-      tx.delete(insights).where(eq31(insights.runId, runId)).run();
-      tx.delete(healthSnapshots).where(eq31(healthSnapshots.runId, runId)).run();
+      tx.delete(insights).where(eq32(insights.runId, runId)).run();
+      tx.delete(healthSnapshots).where(eq32(healthSnapshots.runId, runId)).run();
       const now = (/* @__PURE__ */ new Date()).toISOString();
       for (const insight of result.insights) {
         const wasDismissed = previouslyDismissed.has(`${insight.query}:${insight.provider}:${insight.type}`);
@@ -32113,14 +32640,14 @@ var IntelligenceService = class {
   applySeverityTiering(rawInsights, excludeRunId, projectId) {
     const regressions = rawInsights.filter((i) => i.type === "regression");
     if (regressions.length === 0) return rawInsights;
-    const gscRows = this.db.select({ query: gscSearchData.query, impressions: gscSearchData.impressions }).from(gscSearchData).where(eq31(gscSearchData.projectId, projectId)).all();
+    const gscRows = this.db.select({ query: gscSearchData.query, impressions: gscSearchData.impressions }).from(gscSearchData).where(eq32(gscSearchData.projectId, projectId)).all();
     const gscConnected = gscRows.length > 0;
     const gscImpressionsByQuery = /* @__PURE__ */ new Map();
     for (const row of gscRows) {
       const key = row.query.toLowerCase();
       gscImpressionsByQuery.set(key, (gscImpressionsByQuery.get(key) ?? 0) + row.impressions);
     }
-    const projectRow = this.db.select({ locations: projects.locations }).from(projects).where(eq31(projects.id, projectId)).get();
+    const projectRow = this.db.select({ locations: projects.locations }).from(projects).where(eq32(projects.id, projectId)).get();
     const locationCount = Math.max(
       1,
       (projectRow?.locations ?? []).length
@@ -32128,9 +32655,9 @@ var IntelligenceService = class {
     const ROWS_PER_GROUP_BUDGET = Math.max(2, locationCount);
     const recentRunRows = this.db.select({ id: runs.id, createdAt: runs.createdAt }).from(runs).where(
       and23(
-        eq31(runs.projectId, projectId),
-        eq31(runs.kind, RunKinds["answer-visibility"]),
-        or5(eq31(runs.status, "completed"), eq31(runs.status, "partial")),
+        eq32(runs.projectId, projectId),
+        eq32(runs.kind, RunKinds["answer-visibility"]),
+        or5(eq32(runs.status, "completed"), eq32(runs.status, "partial")),
         // Defensive — see top of file.
         ne5(runs.trigger, RunTriggers.probe)
       )
@@ -32150,7 +32677,7 @@ var IntelligenceService = class {
     const haveHistory = recentRunIds.length > 0;
     const priorRegressionsByPair = /* @__PURE__ */ new Map();
     if (haveHistory) {
-      const priorRows = this.db.select({ query: insights.query, provider: insights.provider, runId: insights.runId }).from(insights).where(and23(eq31(insights.type, "regression"), inArray11(insights.runId, recentRunIds))).all();
+      const priorRows = this.db.select({ query: insights.query, provider: insights.provider, runId: insights.runId }).from(insights).where(and23(eq32(insights.type, "regression"), inArray11(insights.runId, recentRunIds))).all();
       const regressionGroups = /* @__PURE__ */ new Map();
       for (const row of priorRows) {
         if (!row.runId) continue;
@@ -32179,7 +32706,7 @@ var IntelligenceService = class {
     });
   }
   buildRunData(runId, projectId, completedAt, location = null) {
-    const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq31(projects.id, projectId)).get();
+    const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq32(projects.id, projectId)).get();
     const projectDomains = projectDomainRow ? effectiveDomains({
       canonicalDomain: projectDomainRow.canonicalDomain,
       ownedDomains: projectDomainRow.ownedDomains
@@ -32195,7 +32722,7 @@ var IntelligenceService = class {
       citedDomains: querySnapshots.citedDomains,
       competitorOverlap: querySnapshots.competitorOverlap,
       snapshotLocation: querySnapshots.location
-    }).from(querySnapshots).leftJoin(queries, eq31(querySnapshots.queryId, queries.id)).where(eq31(querySnapshots.runId, runId)).all();
+    }).from(querySnapshots).leftJoin(queries, eq32(querySnapshots.queryId, queries.id)).where(eq32(querySnapshots.runId, runId)).all();
     const snapshots = [];
     let orphanCount = 0;
     for (const r of rows) {