@ainyc/canonry 4.57.0 → 4.60.0

package/dist/chunk-4KWPOVIT.js

@@ -1,4842 +0,0 @@
-import {
-  CitationStates,
-  ContentActions,
-  RunKinds,
-  RunTriggers,
-  __export,
-  brandKeyFromText,
-  brandLabelFromDomain,
-  categorizeSourceWithCompetitors,
-  categoryLabel,
-  determineAnswerMentioned,
-  effectiveDomains,
-  normalizeProjectDomain,
-  registrableDomain
-} from "./chunk-WFVUZVJD.js";
-
-// src/intelligence-service.ts
-import { eq, desc, asc, and, ne, or, inArray } from "drizzle-orm";
-
-// ../db/src/client.ts
-import { mkdirSync } from "fs";
-import { dirname } from "path";
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-
-// ../db/src/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  agentMemory: () => agentMemory,
-  agentSessions: () => agentSessions,
-  aiReferralEventsHourly: () => aiReferralEventsHourly,
-  aiUserFetchEventsHourly: () => aiUserFetchEventsHourly,
-  apiKeys: () => apiKeys,
-  auditLog: () => auditLog,
-  backlinkDomains: () => backlinkDomains,
-  backlinkSummaries: () => backlinkSummaries,
-  bingConnections: () => bingConnections,
-  bingCoverageSnapshots: () => bingCoverageSnapshots,
-  bingKeywordStats: () => bingKeywordStats,
-  bingUrlInspections: () => bingUrlInspections,
-  ccReleaseSyncs: () => ccReleaseSyncs,
-  competitors: () => competitors,
-  contentTargetDismissals: () => contentTargetDismissals,
-  crawlerEventsHourly: () => crawlerEventsHourly,
-  discoveryProbes: () => discoveryProbes,
-  discoverySessions: () => discoverySessions,
-  gaAiReferrals: () => gaAiReferrals,
-  gaConnections: () => gaConnections,
-  gaSocialReferrals: () => gaSocialReferrals,
-  gaTrafficSnapshots: () => gaTrafficSnapshots,
-  gaTrafficSummaries: () => gaTrafficSummaries,
-  gaTrafficWindowSummaries: () => gaTrafficWindowSummaries,
-  googleConnections: () => googleConnections,
-  gscCoverageSnapshots: () => gscCoverageSnapshots,
-  gscSearchData: () => gscSearchData,
-  gscUrlInspections: () => gscUrlInspections,
-  healthSnapshots: () => healthSnapshots,
-  insights: () => insights,
-  migrationsTable: () => migrationsTable,
-  notifications: () => notifications,
-  projects: () => projects,
-  queries: () => queries,
-  querySnapshots: () => querySnapshots,
-  rawEventSamples: () => rawEventSamples,
-  recommendationExplanations: () => recommendationExplanations,
-  runs: () => runs,
-  schedules: () => schedules,
-  trafficSources: () => trafficSources,
-  usageCounters: () => usageCounters
-});
-import { index, integer, primaryKey, real, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
-var projects = sqliteTable("projects", {
-  id: text("id").primaryKey(),
-  name: text("name").notNull().unique(),
-  displayName: text("display_name").notNull(),
-  canonicalDomain: text("canonical_domain").notNull(),
-  ownedDomains: text("owned_domains", { mode: "json" }).$type().notNull().default([]),
-  aliases: text("aliases", { mode: "json" }).$type().notNull().default([]),
-  country: text("country").notNull(),
-  language: text("language").notNull(),
-  tags: text("tags", { mode: "json" }).$type().notNull().default([]),
-  labels: text("labels", { mode: "json" }).$type().notNull().default({}),
-  providers: text("providers", { mode: "json" }).$type().notNull().default([]),
-  locations: text("locations", { mode: "json" }).$type().notNull().default([]),
-  defaultLocation: text("default_location"),
-  autoExtractBacklinks: integer("auto_extract_backlinks", { mode: "boolean" }).notNull().default(false),
-  configSource: text("config_source").notNull().default("cli"),
-  configRevision: integer("config_revision").notNull().default(1),
-  icpDescription: text("icp_description"),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-});
-var queries = sqliteTable("queries", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  query: text("query").notNull(),
-  provenance: text("provenance"),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_queries_project").on(table.projectId),
-  uniqueIndex("idx_queries_project_query").on(table.projectId, table.query)
-]);
-var competitors = sqliteTable("competitors", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  domain: text("domain").notNull(),
-  provenance: text("provenance"),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_competitors_project").on(table.projectId),
-  uniqueIndex("idx_competitors_project_domain").on(table.projectId, table.domain)
-]);
-var runs = sqliteTable("runs", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  kind: text("kind").notNull().default("answer-visibility"),
-  status: text("status").notNull().default("queued"),
-  trigger: text("trigger").notNull().default("manual"),
-  location: text("location"),
-  queries: text("queries", { mode: "json" }).$type(),
-  sourceId: text("source_id"),
-  startedAt: text("started_at"),
-  finishedAt: text("finished_at"),
-  error: text("error"),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_runs_project").on(table.projectId),
-  index("idx_runs_status").on(table.status),
-  index("idx_runs_source").on(table.sourceId)
-]);
-var querySnapshots = sqliteTable("query_snapshots", {
-  id: text("id").primaryKey(),
-  runId: text("run_id").notNull().references(() => runs.id, { onDelete: "cascade" }),
-  // `query_id` is nullable + `ON DELETE SET NULL` so historical snapshots
-  // outlive their queries row. Pre-v58 this FK cascaded — deleting a tracked
-  // query (PUT /queries replace, individual delete, `canonry apply` dropping
-  // one) silently wiped the entire citation history for that query. With SET
-  // NULL the snapshot survives; `queryText` keeps it self-describing when
-  // the queries row is gone.
-  queryId: text("query_id").references(() => queries.id, { onDelete: "set null" }),
-  queryText: text("query_text"),
-  provider: text("provider").notNull().default("gemini"),
-  model: text("model"),
-  citationState: text("citation_state").notNull(),
-  answerMentioned: integer("answer_mentioned", { mode: "boolean" }),
-  answerText: text("answer_text"),
-  citedDomains: text("cited_domains", { mode: "json" }).$type().notNull().default([]),
-  competitorOverlap: text("competitor_overlap", { mode: "json" }).$type().notNull().default([]),
-  recommendedCompetitors: text("recommended_competitors", { mode: "json" }).$type().notNull().default([]),
-  location: text("location"),
-  screenshotPath: text("screenshot_path"),
-  rawResponse: text("raw_response"),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_snapshots_run").on(table.runId),
-  index("idx_snapshots_query").on(table.queryId),
-  index("idx_snapshots_citation_state").on(table.citationState),
-  index("idx_snapshots_provider_model").on(table.provider, table.model),
-  index("idx_snapshots_location").on(table.location),
-  index("idx_snapshots_created_at").on(table.createdAt)
-]);
-var auditLog = sqliteTable("audit_log", {
-  id: text("id").primaryKey(),
-  // SET NULL (not CASCADE) so deleting a project preserves its audit trail.
-  // The DELETE /projects route writes a "project.deleted" row immediately
-  // before the delete — a CASCADE here would wipe that record before any
-  // reader could see it (the deletion would erase the only evidence it
-  // happened). Detached rows surface in audit queries with project_id=NULL.
-  projectId: text("project_id").references(() => projects.id, { onDelete: "set null" }),
-  // High-level identity of the caller: 'api' for HTTP requests, 'scheduler'
-  // for cron-triggered work, 'cli' / 'agent' / 'mcp' for direct DB writes
-  // (where applicable). Coarse on purpose — narrower attribution lives in
-  // `userAgent` and `actorSession`.
-  actor: text("actor").notNull(),
-  action: text("action").notNull(),
-  entityType: text("entity_type").notNull(),
-  entityId: text("entity_id"),
-  diff: text("diff"),
-  // User-Agent header from the originating HTTP request, when available.
-  // The narrowest reliable signal for "which client did this" — distinguishes
-  // CLI (`canonry-cli/X.Y.Z`), dashboard (browser UA), MCP adapter, and
-  // external scripts. NULL for non-HTTP writes (scheduler, run-coordinator,
-  // direct CLI commands that bypass the API).
-  userAgent: text("user_agent"),
-  // Optional caller-supplied trace key for cross-request correlation —
-  // a session ID, prompt ID, batch ID, etc. The Aero agent populates this
-  // with its session id so post-mortems can group a related sequence of
-  // mutations. NULL when the caller didn't provide one.
-  actorSession: text("actor_session"),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_audit_log_project").on(table.projectId),
-  index("idx_audit_log_created").on(table.createdAt)
-]);
-var apiKeys = sqliteTable("api_keys", {
-  id: text("id").primaryKey(),
-  name: text("name").notNull(),
-  keyHash: text("key_hash").notNull().unique(),
-  keyPrefix: text("key_prefix").notNull(),
-  scopes: text("scopes", { mode: "json" }).$type().notNull().default(["*"]),
-  createdAt: text("created_at").notNull(),
-  lastUsedAt: text("last_used_at"),
-  revokedAt: text("revoked_at")
-}, (table) => [
-  index("idx_api_keys_prefix").on(table.keyPrefix)
-]);
-var schedules = sqliteTable("schedules", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  // Run kind dispatched by this schedule. Must be a value of `RunKinds` —
-  // currently 'answer-visibility' and 'traffic-sync' are user-facing schedulable kinds.
-  // Defaults to 'answer-visibility' for backward compatibility with rows
-  // created before migration 53.
-  kind: text("kind").notNull().default("answer-visibility"),
-  cronExpr: text("cron_expr").notNull(),
-  preset: text("preset"),
-  timezone: text("timezone").notNull().default("UTC"),
-  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
-  providers: text("providers", { mode: "json" }).$type().notNull().default([]),
-  /** Optional traffic-source UUID for traffic-sync schedules. Null for other kinds. */
-  sourceId: text("source_id"),
-  lastRunAt: text("last_run_at"),
-  nextRunAt: text("next_run_at"),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  uniqueIndex("idx_schedules_project_kind").on(table.projectId, table.kind)
-]);
-var notifications = sqliteTable("notifications", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  channel: text("channel").notNull(),
-  config: text("config", { mode: "json" }).$type().notNull(),
-  webhookSecret: text("webhook_secret"),
-  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  index("idx_notifications_project").on(table.projectId)
-]);
-var googleConnections = sqliteTable("google_connections", {
-  id: text("id").primaryKey(),
-  domain: text("domain").notNull(),
-  connectionType: text("connection_type").notNull(),
-  propertyId: text("property_id"),
-  sitemapUrl: text("sitemap_url"),
-  scopes: text("scopes", { mode: "json" }).$type().notNull().default([]),
-  // The project that established this connection. Used by the OAuth callback
-  // and the DELETE route to refuse cross-project takeover (a malicious caller
-  // who points another project at the same `canonicalDomain` cannot overwrite
-  // or remove an existing connection owned by the original project). Nullable
-  // for legacy rows written before the column existed — those are treated as
-  // unowned and the first connect call to claim them succeeds. See root
-  // AGENTS.md "Deployment Posture" for the broader multi-tenancy posture.
-  createdByProjectId: text("created_by_project_id").references(() => projects.id, { onDelete: "set null" }),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  uniqueIndex("idx_google_conn_domain_type").on(table.domain, table.connectionType),
-  index("idx_google_conn_project").on(table.createdByProjectId)
-]);
-var gscSearchData = sqliteTable("gsc_search_data", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  syncRunId: text("sync_run_id").notNull().references(() => runs.id, { onDelete: "cascade" }),
-  date: text("date").notNull(),
-  query: text("query").notNull(),
-  page: text("page").notNull(),
-  country: text("country"),
-  device: text("device"),
-  clicks: integer("clicks").notNull().default(0),
-  impressions: integer("impressions").notNull().default(0),
-  ctr: text("ctr").notNull().default("0"),
-  position: text("position").notNull().default("0"),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_gsc_search_project_date").on(table.projectId, table.date),
-  index("idx_gsc_search_query").on(table.query),
-  index("idx_gsc_search_run").on(table.syncRunId)
-]);
-var gscUrlInspections = sqliteTable("gsc_url_inspections", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "cascade" }),
-  url: text("url").notNull(),
-  indexingState: text("indexing_state"),
-  verdict: text("verdict"),
-  coverageState: text("coverage_state"),
-  pageFetchState: text("page_fetch_state"),
-  robotsTxtState: text("robots_txt_state"),
-  crawlTime: text("crawl_time"),
-  lastCrawlResult: text("last_crawl_result"),
-  isMobileFriendly: integer("is_mobile_friendly", { mode: "boolean" }),
-  richResults: text("rich_results", { mode: "json" }).$type().notNull().default([]),
-  referringUrls: text("referring_urls", { mode: "json" }).$type().notNull().default([]),
-  inspectedAt: text("inspected_at").notNull(),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_gsc_inspect_project_url").on(table.projectId, table.url),
-  index("idx_gsc_inspect_run").on(table.syncRunId),
-  index("idx_gsc_inspect_url_time").on(table.url, table.inspectedAt)
-]);
-var gscCoverageSnapshots = sqliteTable("gsc_coverage_snapshots", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "cascade" }),
-  date: text("date").notNull(),
-  indexed: integer("indexed").notNull().default(0),
-  notIndexed: integer("not_indexed").notNull().default(0),
-  reasonBreakdown: text("reason_breakdown", { mode: "json" }).$type().notNull().default({}),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_gsc_coverage_snap_project_date").on(table.projectId, table.date),
-  index("idx_gsc_coverage_snap_run").on(table.syncRunId)
-]);
-var bingCoverageSnapshots = sqliteTable("bing_coverage_snapshots", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "cascade" }),
-  date: text("date").notNull(),
-  indexed: integer("indexed").notNull().default(0),
-  notIndexed: integer("not_indexed").notNull().default(0),
-  unknown: integer("unknown").notNull().default(0),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  uniqueIndex("idx_bing_coverage_snap_project_date_unique").on(table.projectId, table.date),
-  index("idx_bing_coverage_snap_run").on(table.syncRunId)
-]);
-var bingConnections = sqliteTable("bing_connections", {
-  id: text("id").primaryKey(),
-  domain: text("domain").notNull(),
-  siteUrl: text("site_url"),
-  // Same takeover-prevention column as `google_connections.createdByProjectId`.
-  // The Bing connect / disconnect routes refuse cross-project writes when an
-  // existing row's owner doesn't match. Null for legacy rows (treated as
-  // unowned).
-  createdByProjectId: text("created_by_project_id").references(() => projects.id, { onDelete: "set null" }),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  uniqueIndex("idx_bing_conn_domain").on(table.domain),
-  index("idx_bing_conn_project").on(table.createdByProjectId)
-]);
-var bingUrlInspections = sqliteTable("bing_url_inspections", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  url: text("url").notNull(),
-  httpCode: integer("http_code"),
-  inIndex: integer("in_index", { mode: "boolean" }),
-  lastCrawledDate: text("last_crawled_date"),
-  inIndexDate: text("in_index_date"),
-  inspectedAt: text("inspected_at").notNull(),
-  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "cascade" }),
-  createdAt: text("created_at").notNull(),
-  documentSize: integer("document_size"),
-  anchorCount: integer("anchor_count"),
-  discoveryDate: text("discovery_date")
-}, (table) => [
-  index("idx_bing_inspect_project_url").on(table.projectId, table.url),
-  index("idx_bing_inspect_url_time").on(table.url, table.inspectedAt),
-  index("idx_bing_inspect_run").on(table.syncRunId)
-]);
-var bingKeywordStats = sqliteTable("bing_keyword_stats", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  query: text("query").notNull(),
-  impressions: integer("impressions").notNull().default(0),
-  clicks: integer("clicks").notNull().default(0),
-  ctr: text("ctr").notNull().default("0"),
-  averagePosition: text("average_position").notNull().default("0"),
-  syncedAt: text("synced_at").notNull(),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_bing_keyword_project").on(table.projectId),
-  index("idx_bing_keyword_query").on(table.query)
-]);
-var gaConnections = sqliteTable("ga_connections", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  propertyId: text("property_id").notNull(),
-  clientEmail: text("client_email").notNull(),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  uniqueIndex("idx_ga_conn_project").on(table.projectId)
-]);
-var gaTrafficSnapshots = sqliteTable("ga_traffic_snapshots", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  date: text("date").notNull(),
-  landingPage: text("landing_page").notNull(),
-  /**
-   * Canonicalized form of `landingPage` produced by `normalizeUrlPath()` in
-   * `@ainyc/canonry-contracts`. Nullable so existing rows survive migration;
-   * new GA4 sync writes populate it. Per-page aggregations should
-   * `GROUP BY COALESCE(landing_page_normalized, landing_page)` so
-   * partially-backfilled state still aggregates correctly.
-   */
-  landingPageNormalized: text("landing_page_normalized"),
-  sessions: integer("sessions").notNull().default(0),
-  organicSessions: integer("organic_sessions").notNull().default(0),
-  /**
-   * Per-page Direct channel sessions. Nullable so existing rows survive
-   * the migration; new GA4 sync writes populate it. Distinct from
-   * `sessions - organicSessions` because that residual lumps Direct
-   * together with social, referral, paid, and email.
-   */
-  directSessions: integer("direct_sessions"),
-  users: integer("users").notNull().default(0),
-  syncedAt: text("synced_at").notNull(),
-  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "cascade" })
-}, (table) => [
-  index("idx_ga_traffic_project_date").on(table.projectId, table.date),
-  index("idx_ga_traffic_page").on(table.landingPage),
-  index("idx_ga_traffic_page_normalized").on(table.projectId, table.date, table.landingPageNormalized),
-  index("idx_ga_traffic_run").on(table.syncRunId)
-]);
-var gaAiReferrals = sqliteTable("ga_ai_referrals", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  date: text("date").notNull(),
-  source: text("source").notNull(),
-  medium: text("medium").notNull(),
-  /** Which GA4 dimension produced this row: 'session' | 'first_user' | 'manual_utm' */
-  sourceDimension: text("source_dimension").notNull().default("session"),
-  /** GA4 default channel group for the session (e.g. 'Referral', 'Organic Social'). */
-  channelGroup: text("channel_group").notNull().default("(not set)"),
-  landingPage: text("landing_page").notNull().default("(not set)"),
-  landingPageNormalized: text("landing_page_normalized"),
-  sessions: integer("sessions").notNull().default(0),
-  users: integer("users").notNull().default(0),
-  syncedAt: text("synced_at").notNull(),
-  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "cascade" })
-}, (table) => [
-  index("idx_ga_ai_ref_project_date").on(table.projectId, table.date),
-  index("idx_ga_ai_ref_source").on(table.source),
-  index("idx_ga_ai_ref_landing_page").on(table.projectId, table.date, table.landingPageNormalized),
-  uniqueIndex("idx_ga_ai_ref_unique_v4").on(table.projectId, table.date, table.source, table.medium, table.sourceDimension, table.channelGroup, table.landingPage),
-  index("idx_ga_ai_ref_run").on(table.syncRunId)
-]);
-var gaSocialReferrals = sqliteTable("ga_social_referrals", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  date: text("date").notNull(),
-  source: text("source").notNull(),
-  medium: text("medium").notNull(),
-  /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: text("channel_group").notNull().default("Organic Social"),
-  sessions: integer("sessions").notNull().default(0),
-  users: integer("users").notNull().default(0),
-  syncedAt: text("synced_at").notNull(),
-  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "cascade" })
-}, (table) => [
-  index("idx_ga_social_ref_project_date").on(table.projectId, table.date),
-  index("idx_ga_social_ref_source").on(table.source),
-  uniqueIndex("idx_ga_social_ref_unique").on(table.projectId, table.date, table.source, table.medium, table.channelGroup),
-  index("idx_ga_social_ref_run").on(table.syncRunId)
-]);
-var gaTrafficSummaries = sqliteTable("ga_traffic_summaries", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  periodStart: text("period_start").notNull(),
-  periodEnd: text("period_end").notNull(),
-  totalSessions: integer("total_sessions").notNull().default(0),
-  totalOrganicSessions: integer("total_organic_sessions").notNull().default(0),
-  totalUsers: integer("total_users").notNull().default(0),
-  syncedAt: text("synced_at").notNull(),
-  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "cascade" })
-}, (table) => [
-  index("idx_ga_summary_project").on(table.projectId),
-  index("idx_ga_summary_run").on(table.syncRunId)
-]);
-var gaTrafficWindowSummaries = sqliteTable("ga_traffic_window_summaries", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  /** '7d' | '30d' | '90d' */
-  windowKey: text("window_key").notNull(),
-  periodStart: text("period_start").notNull(),
-  periodEnd: text("period_end").notNull(),
-  totalSessions: integer("total_sessions").notNull().default(0),
-  totalOrganicSessions: integer("total_organic_sessions").notNull().default(0),
-  totalDirectSessions: integer("total_direct_sessions").notNull().default(0),
-  totalUsers: integer("total_users").notNull().default(0),
-  syncedAt: text("synced_at").notNull(),
-  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "cascade" })
-}, (table) => [
-  uniqueIndex("idx_ga_window_summary_unique").on(table.projectId, table.windowKey),
-  index("idx_ga_window_summary_run").on(table.syncRunId)
-]);
-var usageCounters = sqliteTable("usage_counters", {
-  id: text("id").primaryKey(),
-  scope: text("scope").notNull(),
-  period: text("period").notNull(),
-  metric: text("metric").notNull(),
-  count: integer("count").notNull().default(0),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  uniqueIndex("idx_usage_scope_period_metric").on(table.scope, table.period, table.metric),
-  index("idx_usage_scope_period").on(table.scope, table.period)
-]);
-var insights = sqliteTable("insights", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  runId: text("run_id").references(() => runs.id, { onDelete: "cascade" }),
-  type: text("type").notNull(),
-  severity: text("severity").notNull(),
-  title: text("title").notNull(),
-  query: text("query").notNull(),
-  provider: text("provider").notNull(),
-  recommendation: text("recommendation", { mode: "json" }).$type(),
-  cause: text("cause", { mode: "json" }).$type(),
-  dismissed: integer("dismissed", { mode: "boolean" }).notNull().default(false),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_insights_project").on(table.projectId),
-  index("idx_insights_run").on(table.runId),
-  index("idx_insights_created").on(table.createdAt),
-  index("idx_insights_query_provider").on(table.query, table.provider)
-]);
-var healthSnapshots = sqliteTable("health_snapshots", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  runId: text("run_id").references(() => runs.id, { onDelete: "cascade" }),
-  overallCitedRate: text("overall_cited_rate").notNull(),
-  totalPairs: integer("total_pairs").notNull(),
-  citedPairs: integer("cited_pairs").notNull(),
-  providerBreakdown: text("provider_breakdown", { mode: "json" }).$type().notNull().default({}),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_health_snapshots_project").on(table.projectId),
-  index("idx_health_snapshots_run").on(table.runId),
-  index("idx_health_snapshots_created").on(table.createdAt)
-]);
-var agentSessions = sqliteTable("agent_sessions", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().unique().references(() => projects.id, { onDelete: "cascade" }),
-  systemPrompt: text("system_prompt").notNull(),
-  modelProvider: text("model_provider").notNull(),
-  modelId: text("model_id").notNull(),
-  messages: text("messages").notNull().default("[]"),
-  followUpQueue: text("follow_up_queue").notNull().default("[]"),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  index("idx_agent_sessions_project").on(table.projectId),
-  index("idx_agent_sessions_updated").on(table.updatedAt)
-]);
-var ccReleaseSyncs = sqliteTable("cc_release_syncs", {
-  id: text("id").primaryKey(),
-  release: text("release").notNull().unique(),
-  status: text("status").notNull(),
-  phaseDetail: text("phase_detail"),
-  vertexPath: text("vertex_path"),
-  edgesPath: text("edges_path"),
-  vertexSha256: text("vertex_sha256"),
-  edgesSha256: text("edges_sha256"),
-  vertexBytes: integer("vertex_bytes"),
-  edgesBytes: integer("edges_bytes"),
-  projectsProcessed: integer("projects_processed"),
-  domainsDiscovered: integer("domains_discovered"),
-  downloadStartedAt: text("download_started_at"),
-  downloadFinishedAt: text("download_finished_at"),
-  queryStartedAt: text("query_started_at"),
-  queryFinishedAt: text("query_finished_at"),
-  error: text("error"),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  index("idx_cc_release_syncs_status").on(table.status)
-]);
-var backlinkDomains = sqliteTable("backlink_domains", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  releaseSyncId: text("release_sync_id").notNull().references(() => ccReleaseSyncs.id, { onDelete: "cascade" }),
-  release: text("release").notNull(),
-  targetDomain: text("target_domain").notNull(),
-  linkingDomain: text("linking_domain").notNull(),
-  numHosts: integer("num_hosts").notNull(),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_backlink_domains_project").on(table.projectId),
-  index("idx_backlink_domains_release_sync").on(table.releaseSyncId),
-  index("idx_backlink_domains_project_release").on(table.projectId, table.release),
-  index("idx_backlink_domains_hosts").on(table.numHosts),
-  uniqueIndex("idx_backlink_domains_unique").on(table.projectId, table.release, table.linkingDomain)
-]);
-var backlinkSummaries = sqliteTable("backlink_summaries", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  releaseSyncId: text("release_sync_id").notNull().references(() => ccReleaseSyncs.id, { onDelete: "cascade" }),
-  release: text("release").notNull(),
-  targetDomain: text("target_domain").notNull(),
-  totalLinkingDomains: integer("total_linking_domains").notNull(),
-  totalHosts: integer("total_hosts").notNull(),
-  top10HostsShare: text("top_10_hosts_share").notNull(),
-  queriedAt: text("queried_at").notNull(),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  uniqueIndex("idx_backlink_summaries_project_release").on(table.projectId, table.release),
-  index("idx_backlink_summaries_project").on(table.projectId)
-]);
-var agentMemory = sqliteTable("agent_memory", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  key: text("key").notNull(),
-  value: text("value").notNull(),
-  source: text("source").notNull(),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  uniqueIndex("uniq_agent_memory_project_key").on(table.projectId, table.key),
-  index("idx_agent_memory_project_updated").on(table.projectId, table.updatedAt)
-]);
-var trafficSources = sqliteTable("traffic_sources", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  sourceType: text("source_type").notNull(),
-  displayName: text("display_name").notNull(),
-  status: text("status").notNull(),
-  lastSyncedAt: text("last_synced_at"),
-  lastCursor: text("last_cursor"),
-  lastError: text("last_error"),
-  // JSON-encoded array of normalized event IDs (e.g. `cloud-run:<ts>:<insertId>`)
-  // observed in the most recent successful sync. Bounded ring buffer used to
-  // dedupe across sync runs at the boundary timestamp where lastSyncedAt
-  // clamping alone leaves a small overlap window.
-  lastEventIds: text("last_event_ids", { mode: "json" }).$type(),
-  archivedAt: text("archived_at"),
-  configJson: text("config_json", { mode: "json" }).$type().notNull().default({}),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  index("idx_traffic_sources_project").on(table.projectId),
-  index("idx_traffic_sources_project_status").on(table.projectId, table.status)
-]);
-var crawlerEventsHourly = sqliteTable("crawler_events_hourly", {
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  sourceId: text("source_id").notNull().references(() => trafficSources.id, { onDelete: "cascade" }),
-  tsHour: text("ts_hour").notNull(),
-  botId: text("bot_id").notNull(),
-  operator: text("operator").notNull(),
-  verificationStatus: text("verification_status").notNull(),
-  pathNormalized: text("path_normalized").notNull(),
-  status: integer("status").notNull(),
-  hits: integer("hits").notNull().default(0),
-  sampledUserAgent: text("sampled_user_agent"),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  primaryKey({
-    columns: [
-      table.projectId,
-      table.sourceId,
-      table.tsHour,
-      table.botId,
-      table.verificationStatus,
-      table.pathNormalized,
-      table.status
-    ]
-  }),
-  index("idx_crawler_hourly_project_ts").on(table.projectId, table.tsHour),
-  index("idx_crawler_hourly_path").on(table.projectId, table.pathNormalized)
-]);
-var aiUserFetchEventsHourly = sqliteTable("ai_user_fetch_events_hourly", {
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  sourceId: text("source_id").notNull().references(() => trafficSources.id, { onDelete: "cascade" }),
-  tsHour: text("ts_hour").notNull(),
-  botId: text("bot_id").notNull(),
-  operator: text("operator").notNull(),
-  verificationStatus: text("verification_status").notNull(),
-  pathNormalized: text("path_normalized").notNull(),
-  status: integer("status").notNull(),
-  hits: integer("hits").notNull().default(0),
-  sampledUserAgent: text("sampled_user_agent"),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  primaryKey({
-    columns: [
-      table.projectId,
-      table.sourceId,
-      table.tsHour,
-      table.botId,
-      table.verificationStatus,
-      table.pathNormalized,
-      table.status
-    ]
-  }),
-  index("idx_ai_user_fetch_hourly_project_ts").on(table.projectId, table.tsHour),
-  index("idx_ai_user_fetch_hourly_path").on(table.projectId, table.pathNormalized)
-]);
-var aiReferralEventsHourly = sqliteTable("ai_referral_events_hourly", {
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  sourceId: text("source_id").notNull().references(() => trafficSources.id, { onDelete: "cascade" }),
-  tsHour: text("ts_hour").notNull(),
-  product: text("product").notNull(),
-  operator: text("operator").notNull(),
-  sourceDomain: text("source_domain").notNull(),
-  evidenceType: text("evidence_type").notNull(),
-  landingPathNormalized: text("landing_path_normalized").notNull(),
-  status: integer("status").notNull(),
-  sessionsOrHits: integer("sessions_or_hits").notNull().default(0),
-  usersEstimated: integer("users_estimated"),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  primaryKey({
-    columns: [
-      table.projectId,
-      table.sourceId,
-      table.tsHour,
-      table.product,
-      table.sourceDomain,
-      table.evidenceType,
-      table.landingPathNormalized,
-      table.status
-    ]
-  }),
-  index("idx_ai_referral_hourly_project_ts").on(table.projectId, table.tsHour),
-  index("idx_ai_referral_hourly_landing").on(table.projectId, table.landingPathNormalized)
-]);
-var rawEventSamples = sqliteTable("raw_event_samples", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  sourceId: text("source_id").notNull().references(() => trafficSources.id, { onDelete: "cascade" }),
-  ts: text("ts").notNull(),
-  eventType: text("event_type").notNull(),
-  ipHash: text("ip_hash"),
-  userAgent: text("user_agent"),
-  pathNormalized: text("path_normalized").notNull(),
-  status: integer("status"),
-  refererHost: text("referer_host"),
-  classifierDetailsJson: text("classifier_details_json", { mode: "json" }).$type().notNull().default({}),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_raw_event_samples_project_ts").on(table.projectId, table.ts),
-  index("idx_raw_event_samples_source_ts").on(table.sourceId, table.ts),
-  index("idx_raw_event_samples_event_type").on(table.eventType)
-]);
-var discoverySessions = sqliteTable("discovery_sessions", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  runId: text("run_id"),
-  status: text("status").notNull().default("queued"),
-  icpDescription: text("icp_description"),
-  seedProvider: text("seed_provider"),
-  seedCountRaw: integer("seed_count_raw"),
-  seedCount: integer("seed_count"),
-  dedupThreshold: real("dedup_threshold"),
-  probeCount: integer("probe_count"),
-  citedCount: integer("cited_count"),
-  aspirationalCount: integer("aspirational_count"),
-  wastedCount: integer("wasted_count"),
-  competitorMap: text("competitor_map", { mode: "json" }).$type().notNull().default([]),
-  error: text("error"),
-  startedAt: text("started_at"),
-  finishedAt: text("finished_at"),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_discovery_sessions_project_created").on(table.projectId, table.createdAt),
-  index("idx_discovery_sessions_run").on(table.runId)
-]);
-var discoveryProbes = sqliteTable("discovery_probes", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => discoverySessions.id, { onDelete: "cascade" }),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  query: text("query").notNull(),
-  bucket: text("bucket"),
-  citationState: text("citation_state").notNull(),
-  citedDomains: text("cited_domains", { mode: "json" }).$type().notNull().default([]),
-  rawResponse: text("raw_response"),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_discovery_probes_session").on(table.sessionId),
-  index("idx_discovery_probes_project").on(table.projectId)
-]);
-var contentTargetDismissals = sqliteTable("content_target_dismissals", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  targetRef: text("target_ref").notNull(),
-  addressedUrl: text("addressed_url"),
-  note: text("note"),
-  dismissedAt: text("dismissed_at").notNull()
-}, (table) => [
-  uniqueIndex("idx_content_target_dismissals_project_ref").on(table.projectId, table.targetRef),
-  index("idx_content_target_dismissals_project").on(table.projectId)
-]);
-var recommendationExplanations = sqliteTable("recommendation_explanations", {
-  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(),
-  responseText: text("response_text").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_explanations_unique").on(
-    table.projectId,
-    table.targetRef,
-    table.promptVersion
-  ),
-  index("idx_recommendation_explanations_project").on(table.projectId)
-]);
-var migrationsTable = sqliteTable("_migrations", {
-  version: integer("version").primaryKey(),
-  name: text("name").notNull(),
-  appliedAt: text("applied_at").notNull()
-});
-
-// ../db/src/client.ts
-function createClient(databasePath) {
-  mkdirSync(dirname(databasePath), { recursive: true });
-  const sqlite = new Database(databasePath);
-  sqlite.pragma("journal_mode = WAL");
-  sqlite.pragma("foreign_keys = ON");
-  sqlite.pragma("busy_timeout = 5000");
-  return drizzle(sqlite, { schema: schema_exports });
-}
-
-// ../db/src/json.ts
-function parseJsonColumn(value, fallback) {
-  if (value == null || value === "") return fallback;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
-
-// ../db/src/migrate.ts
-import { sql } from "drizzle-orm";
-var MIGRATION_SQL = `
-CREATE TABLE IF NOT EXISTS projects (
-  id                TEXT PRIMARY KEY,
-  name              TEXT NOT NULL UNIQUE,
-  display_name      TEXT NOT NULL,
-  canonical_domain  TEXT NOT NULL,
-  owned_domains     TEXT NOT NULL DEFAULT '[]',
-  country           TEXT NOT NULL,
-  language          TEXT NOT NULL,
-  tags              TEXT NOT NULL DEFAULT '[]',
-  labels            TEXT NOT NULL DEFAULT '{}',
-  providers         TEXT NOT NULL DEFAULT '[]',
-  config_source     TEXT NOT NULL DEFAULT 'cli',
-  config_revision   INTEGER NOT NULL DEFAULT 1,
-  created_at        TEXT NOT NULL,
-  updated_at        TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS queries (
-  id          TEXT PRIMARY KEY,
-  project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  query       TEXT NOT NULL,
-  created_at  TEXT NOT NULL,
-  UNIQUE(project_id, query)
-);
-
-CREATE TABLE IF NOT EXISTS competitors (
-  id          TEXT PRIMARY KEY,
-  project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  domain      TEXT NOT NULL,
-  created_at  TEXT NOT NULL,
-  UNIQUE(project_id, domain)
-);
-
-CREATE TABLE IF NOT EXISTS runs (
-  id          TEXT PRIMARY KEY,
-  project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  kind        TEXT NOT NULL DEFAULT 'answer-visibility',
-  status      TEXT NOT NULL DEFAULT 'queued',
-  trigger     TEXT NOT NULL DEFAULT 'manual',
-  started_at  TEXT,
-  finished_at TEXT,
-  error       TEXT,
-  created_at  TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS query_snapshots (
-  id                  TEXT PRIMARY KEY,
-  run_id              TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
-  query_id            TEXT NOT NULL REFERENCES queries(id) ON DELETE CASCADE,
-  provider            TEXT NOT NULL DEFAULT 'gemini',
-  citation_state      TEXT NOT NULL,
-  answer_text         TEXT,
-  cited_domains       TEXT NOT NULL DEFAULT '[]',
-  competitor_overlap  TEXT NOT NULL DEFAULT '[]',
-  raw_response        TEXT,
-  created_at          TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS audit_log (
-  id          TEXT PRIMARY KEY,
-  project_id  TEXT REFERENCES projects(id) ON DELETE CASCADE,
-  actor       TEXT NOT NULL,
-  action      TEXT NOT NULL,
-  entity_type TEXT NOT NULL,
-  entity_id   TEXT,
-  diff        TEXT,
-  created_at  TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS api_keys (
-  id          TEXT PRIMARY KEY,
-  name        TEXT NOT NULL,
-  key_hash    TEXT NOT NULL UNIQUE,
-  key_prefix  TEXT NOT NULL,
-  scopes      TEXT NOT NULL DEFAULT '["*"]',
-  created_at  TEXT NOT NULL,
-  last_used_at TEXT,
-  revoked_at  TEXT
-);
-
-CREATE TABLE IF NOT EXISTS usage_counters (
-  id          TEXT PRIMARY KEY,
-  scope       TEXT NOT NULL,
-  period      TEXT NOT NULL,
-  metric      TEXT NOT NULL,
-  count       INTEGER NOT NULL DEFAULT 0,
-  updated_at  TEXT NOT NULL,
-  UNIQUE(scope, period, metric)
-);
-
-CREATE INDEX IF NOT EXISTS idx_queries_project ON queries(project_id);
-CREATE INDEX IF NOT EXISTS idx_competitors_project ON competitors(project_id);
-CREATE INDEX IF NOT EXISTS idx_runs_project ON runs(project_id);
-CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
-CREATE INDEX IF NOT EXISTS idx_snapshots_run ON query_snapshots(run_id);
-CREATE INDEX IF NOT EXISTS idx_snapshots_query ON query_snapshots(query_id);
-CREATE INDEX IF NOT EXISTS idx_audit_log_project ON audit_log(project_id);
-CREATE INDEX IF NOT EXISTS idx_audit_log_created ON audit_log(created_at);
-CREATE TABLE IF NOT EXISTS schedules (
-  id          TEXT PRIMARY KEY,
-  project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  cron_expr   TEXT NOT NULL,
-  preset      TEXT,
-  timezone    TEXT NOT NULL DEFAULT 'UTC',
-  enabled     INTEGER NOT NULL DEFAULT 1,
-  providers   TEXT NOT NULL DEFAULT '[]',
-  last_run_at TEXT,
-  next_run_at TEXT,
-  created_at  TEXT NOT NULL,
-  updated_at  TEXT NOT NULL,
-  UNIQUE(project_id)
-);
-
-CREATE TABLE IF NOT EXISTS notifications (
-  id          TEXT PRIMARY KEY,
-  project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  channel     TEXT NOT NULL,
-  config      TEXT NOT NULL,
-  enabled     INTEGER NOT NULL DEFAULT 1,
-  created_at  TEXT NOT NULL,
-  updated_at  TEXT NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_api_keys_prefix ON api_keys(key_prefix);
-CREATE INDEX IF NOT EXISTS idx_usage_scope_period ON usage_counters(scope, period);
--- NOTE: the (project_id) UNIQUE INDEX that used to live here was replaced by
--- v53's (project_id, kind) index. MIGRATION_SQL re-runs on every boot, so we
--- must NOT recreate the single-column index \u2014 it would conflict with v53 and
--- break traffic-sync schedule creation.
-CREATE INDEX IF NOT EXISTS idx_notifications_project ON notifications(project_id);
-
--- Migration tracking: records which version has been applied.
--- On boot only versions > max applied version are run.
-CREATE TABLE IF NOT EXISTS _migrations (
-  version     INTEGER PRIMARY KEY,
-  name        TEXT NOT NULL,
-  applied_at  TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-`;
-var MIGRATION_VERSIONS = [
-  {
-    version: 2,
-    name: "add-providers-column",
-    statements: [
-      `ALTER TABLE projects ADD COLUMN providers TEXT NOT NULL DEFAULT '[]'`
-    ]
-  },
-  {
-    version: 3,
-    name: "add-webhook-secret",
-    statements: [
-      `ALTER TABLE notifications ADD COLUMN webhook_secret TEXT`
-    ]
-  },
-  {
-    version: 4,
-    name: "add-owned-domains",
-    statements: [
-      `ALTER TABLE projects ADD COLUMN owned_domains TEXT NOT NULL DEFAULT '[]'`
-    ]
-  },
-  {
-    version: 5,
-    name: "add-snapshot-model",
-    statements: [
-      `ALTER TABLE query_snapshots ADD COLUMN model TEXT`,
-      `UPDATE query_snapshots SET model = json_extract(raw_response, '$.model') WHERE model IS NULL AND raw_response IS NOT NULL AND json_extract(raw_response, '$.model') IS NOT NULL`
-    ]
-  },
-  {
-    version: 6,
-    name: "gsc-integration",
-    statements: [
-      // google_connections (domain-scoped)
-      // WARNING: access_token, refresh_token are authentication material; consider storing in config.yaml per CLAUDE.md
-      `CREATE TABLE IF NOT EXISTS google_connections (
-        id              TEXT PRIMARY KEY,
-        domain          TEXT NOT NULL,
-        connection_type TEXT NOT NULL,
-        property_id     TEXT,
-        access_token    TEXT,
-        refresh_token   TEXT,
-        token_expires_at TEXT,
-        scopes          TEXT NOT NULL DEFAULT '[]',
-        created_at      TEXT NOT NULL,
-        updated_at      TEXT NOT NULL
-      )`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_google_conn_domain_type ON google_connections(domain, connection_type)`,
-      // gsc_search_data
-      `CREATE TABLE IF NOT EXISTS gsc_search_data (
-        id            TEXT PRIMARY KEY,
-        project_id    TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        sync_run_id   TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
-        date          TEXT NOT NULL,
-        query         TEXT NOT NULL,
-        page          TEXT NOT NULL,
-        country       TEXT,
-        device        TEXT,
-        clicks        INTEGER NOT NULL DEFAULT 0,
-        impressions   INTEGER NOT NULL DEFAULT 0,
-        ctr           TEXT NOT NULL DEFAULT '0',
-        position      TEXT NOT NULL DEFAULT '0',
-        created_at    TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_gsc_search_project_date ON gsc_search_data(project_id, date)`,
-      `CREATE INDEX IF NOT EXISTS idx_gsc_search_query ON gsc_search_data(query)`,
-      `CREATE INDEX IF NOT EXISTS idx_gsc_search_run ON gsc_search_data(sync_run_id)`,
-      // gsc_url_inspections
-      `CREATE TABLE IF NOT EXISTS gsc_url_inspections (
-        id                TEXT PRIMARY KEY,
-        project_id        TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        sync_run_id       TEXT REFERENCES runs(id) ON DELETE CASCADE,
-        url               TEXT NOT NULL,
-        indexing_state    TEXT,
-        verdict           TEXT,
-        coverage_state    TEXT,
-        page_fetch_state  TEXT,
-        robots_txt_state  TEXT,
-        crawl_time        TEXT,
-        last_crawl_result TEXT,
-        is_mobile_friendly INTEGER,
-        rich_results      TEXT NOT NULL DEFAULT '[]',
-        referring_urls    TEXT NOT NULL DEFAULT '[]',
-        inspected_at      TEXT NOT NULL,
-        created_at        TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_gsc_inspect_project_url ON gsc_url_inspections(project_id, url)`,
-      `CREATE INDEX IF NOT EXISTS idx_gsc_inspect_run ON gsc_url_inspections(sync_run_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_gsc_inspect_url_time ON gsc_url_inspections(url, inspected_at)`
-    ]
-  },
-  {
-    version: 7,
-    name: "gsc-coverage-snapshots",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS gsc_coverage_snapshots (
-        id              TEXT PRIMARY KEY,
-        project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        sync_run_id     TEXT REFERENCES runs(id) ON DELETE CASCADE,
-        date            TEXT NOT NULL,
-        indexed         INTEGER NOT NULL DEFAULT 0,
-        not_indexed     INTEGER NOT NULL DEFAULT 0,
-        reason_breakdown TEXT NOT NULL DEFAULT '{}',
-        created_at      TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_gsc_coverage_snap_project_date ON gsc_coverage_snapshots(project_id, date)`,
-      `CREATE INDEX IF NOT EXISTS idx_gsc_coverage_snap_run ON gsc_coverage_snapshots(sync_run_id)`
-    ]
-  },
-  {
-    version: 8,
-    name: "location-aware-sweeps",
-    statements: [
-      `ALTER TABLE projects ADD COLUMN locations TEXT NOT NULL DEFAULT '[]'`,
-      `ALTER TABLE projects ADD COLUMN default_location TEXT`,
-      `ALTER TABLE query_snapshots ADD COLUMN location TEXT`
-    ]
-  },
-  {
-    version: 9,
-    name: "add-run-location",
-    statements: [
-      `ALTER TABLE runs ADD COLUMN location TEXT`
-    ]
-  },
-  {
-    version: 10,
-    name: "add-sitemap-url",
-    statements: [
-      `ALTER TABLE google_connections ADD COLUMN sitemap_url TEXT`
-    ]
-  },
-  {
-    version: 11,
-    name: "add-screenshot-path",
-    statements: [
-      `ALTER TABLE query_snapshots ADD COLUMN screenshot_path TEXT`
-    ]
-  },
-  {
-    version: 12,
-    name: "bing-wmt-integration",
-    statements: [
-      // bing_connections
-      `CREATE TABLE IF NOT EXISTS bing_connections (
-        id          TEXT PRIMARY KEY,
-        domain      TEXT NOT NULL,
-        site_url    TEXT,
-        created_at  TEXT NOT NULL,
-        updated_at  TEXT NOT NULL
-      )`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_bing_conn_domain ON bing_connections(domain)`,
-      // bing_url_inspections
-      `CREATE TABLE IF NOT EXISTS bing_url_inspections (
-        id                TEXT PRIMARY KEY,
-        project_id        TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        url               TEXT NOT NULL,
-        http_code         INTEGER,
-        in_index          INTEGER,
-        last_crawled_date TEXT,
-        in_index_date     TEXT,
-        inspected_at      TEXT NOT NULL,
-        created_at        TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_bing_inspect_project_url ON bing_url_inspections(project_id, url)`,
-      `CREATE INDEX IF NOT EXISTS idx_bing_inspect_url_time ON bing_url_inspections(url, inspected_at)`,
-      // bing_keyword_stats
-      `CREATE TABLE IF NOT EXISTS bing_keyword_stats (
-        id               TEXT PRIMARY KEY,
-        project_id       TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        query            TEXT NOT NULL,
-        impressions      INTEGER NOT NULL DEFAULT 0,
-        clicks           INTEGER NOT NULL DEFAULT 0,
-        ctr              TEXT NOT NULL DEFAULT '0',
-        average_position TEXT NOT NULL DEFAULT '0',
-        synced_at        TEXT NOT NULL,
-        created_at       TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_bing_keyword_project ON bing_keyword_stats(project_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_bing_keyword_query ON bing_keyword_stats(query)`
-    ]
-  },
-  {
-    version: 13,
-    name: "ga4-integration",
-    statements: [
-      // ga_connections
-      // WARNING: private_key is authentication material; consider storing in config.yaml per CLAUDE.md
-      `CREATE TABLE IF NOT EXISTS ga_connections (
-        id            TEXT PRIMARY KEY,
-        project_id    TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        property_id   TEXT NOT NULL,
-        client_email  TEXT NOT NULL,
-        private_key   TEXT NOT NULL,
-        created_at    TEXT NOT NULL,
-        updated_at    TEXT NOT NULL
-      )`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_conn_project ON ga_connections(project_id)`,
-      // ga_traffic_snapshots
-      `CREATE TABLE IF NOT EXISTS ga_traffic_snapshots (
-        id               TEXT PRIMARY KEY,
-        project_id       TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        date             TEXT NOT NULL,
-        landing_page     TEXT NOT NULL,
-        sessions         INTEGER NOT NULL DEFAULT 0,
-        organic_sessions INTEGER NOT NULL DEFAULT 0,
-        users            INTEGER NOT NULL DEFAULT 0,
-        synced_at        TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_traffic_project_date ON ga_traffic_snapshots(project_id, date)`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_traffic_page ON ga_traffic_snapshots(landing_page)`
-    ]
-  },
-  {
-    version: 14,
-    name: "ga4-traffic-summaries",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS ga_traffic_summaries (
-        id                     TEXT PRIMARY KEY,
-        project_id             TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        period_start           TEXT NOT NULL,
-        period_end             TEXT NOT NULL,
-        total_sessions         INTEGER NOT NULL DEFAULT 0,
-        total_organic_sessions INTEGER NOT NULL DEFAULT 0,
-        total_users            INTEGER NOT NULL DEFAULT 0,
-        synced_at              TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_summary_project ON ga_traffic_summaries(project_id)`
-    ]
-  },
-  {
-    version: 15,
-    name: "bing-inspect-columns",
-    statements: [
-      `ALTER TABLE bing_url_inspections ADD COLUMN document_size INTEGER`,
-      `ALTER TABLE bing_url_inspections ADD COLUMN anchor_count INTEGER`,
-      `ALTER TABLE bing_url_inspections ADD COLUMN discovery_date TEXT`
-    ]
-  },
-  {
-    version: 16,
-    name: "recommended-competitors",
-    statements: [
-      `ALTER TABLE query_snapshots ADD COLUMN recommended_competitors TEXT NOT NULL DEFAULT '[]'`
-    ]
-  },
-  {
-    version: 17,
-    name: "ga4-ai-referrals",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS ga_ai_referrals (
-        id          TEXT PRIMARY KEY,
-        project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        date        TEXT NOT NULL,
-        source      TEXT NOT NULL,
-        medium      TEXT NOT NULL,
-        sessions    INTEGER NOT NULL DEFAULT 0,
-        users       INTEGER NOT NULL DEFAULT 0,
-        synced_at   TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_ai_ref_project_date ON ga_ai_referrals(project_id, date)`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_ai_ref_source ON ga_ai_referrals(source)`
-    ]
-  },
-  {
-    version: 18,
-    name: "answer-mentioned",
-    statements: [
-      `ALTER TABLE query_snapshots ADD COLUMN answer_mentioned INTEGER`
-    ]
-  },
-  {
-    version: 19,
-    name: "named-unique-indexes",
-    statements: [
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_queries_project_query ON queries(project_id, query)`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_competitors_project_domain ON competitors(project_id, domain)`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_schedules_project ON schedules(project_id)`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_usage_scope_period_metric ON usage_counters(scope, period, metric)`,
-      `ALTER TABLE projects ADD COLUMN config_source TEXT NOT NULL DEFAULT 'cli'`,
-      `ALTER TABLE projects ADD COLUMN config_revision INTEGER NOT NULL DEFAULT 1`
-    ]
-  },
-  {
-    version: 20,
-    name: "ga4-source-dimension",
-    statements: [
-      // Values: 'session' (sessionSource), 'first_user' (firstUserSource), 'manual_utm' (manualSource/utm_source)
-      `ALTER TABLE ga_ai_referrals ADD COLUMN source_dimension TEXT NOT NULL DEFAULT 'session'`,
-      // Adopt the widened unique key (now including source_dimension). This
-      // version intentionally does NOT drop the prior narrow index
-      // idx_ga_ai_ref_unique — the original v17 + v20 pair did, but replaying
-      // that pair on a DB where data has since accumulated duplicates on the
-      // narrow key would crash (the bug this PR fixes). Any DB that ran the
-      // historical v20 once already has the narrow index gone; brand-new DBs
-      // never create it because v17 was rewritten to omit it. Anything else
-      // is repaired by v46, which drops idx_ga_ai_ref_unique_v2 and lands on
-      // the final (…, source_dimension, landing_page) index.
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_ai_ref_unique_v2 ON ga_ai_referrals(project_id, date, source, medium, source_dimension)`
-    ]
-  },
-  {
-    version: 21,
-    name: "snapshot-filtering-indexes",
-    statements: [
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_citation_state ON query_snapshots(citation_state)`,
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_provider_model ON query_snapshots(provider, model)`,
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_location ON query_snapshots(location)`
-    ]
-  },
-  {
-    version: 22,
-    name: "insights-table",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS insights (
-        id              TEXT PRIMARY KEY,
-        project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        type            TEXT NOT NULL,
-        severity        TEXT NOT NULL,
-        title           TEXT NOT NULL,
-        query           TEXT NOT NULL,
-        provider        TEXT NOT NULL,
-        recommendation  TEXT,
-        cause           TEXT,
-        dismissed       INTEGER NOT NULL DEFAULT 0,
-        created_at      TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_insights_project ON insights(project_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_insights_created ON insights(created_at)`,
-      `CREATE INDEX IF NOT EXISTS idx_insights_query_provider ON insights(query, provider)`
-    ]
-  },
-  {
-    version: 23,
-    name: "health-snapshots-table",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS health_snapshots (
-        id                  TEXT PRIMARY KEY,
-        project_id          TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        overall_cited_rate  TEXT NOT NULL,
-        total_pairs         INTEGER NOT NULL,
-        cited_pairs         INTEGER NOT NULL,
-        provider_breakdown  TEXT NOT NULL DEFAULT '{}',
-        created_at          TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_health_snapshots_project ON health_snapshots(project_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_health_snapshots_created ON health_snapshots(created_at)`
-    ]
-  },
-  {
-    version: 24,
-    name: "intelligence-run-id",
-    statements: [
-      `ALTER TABLE insights ADD COLUMN run_id TEXT REFERENCES runs(id) ON DELETE CASCADE`,
-      `CREATE INDEX IF NOT EXISTS idx_insights_run ON insights(run_id)`,
-      `ALTER TABLE health_snapshots ADD COLUMN run_id TEXT REFERENCES runs(id) ON DELETE CASCADE`,
-      `CREATE INDEX IF NOT EXISTS idx_health_snapshots_run ON health_snapshots(run_id)`
-    ]
-  },
-  {
-    version: 25,
-    name: "ga4-social-referrals",
-    statements: [
-      // Uses GA4's native sessionDefaultChannelGroup for social classification
-      `CREATE TABLE IF NOT EXISTS ga_social_referrals (
-        id              TEXT PRIMARY KEY,
-        project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        date            TEXT NOT NULL,
-        source          TEXT NOT NULL,
-        medium          TEXT NOT NULL,
-        channel_group   TEXT NOT NULL DEFAULT 'Organic Social',
-        sessions        INTEGER NOT NULL DEFAULT 0,
-        users           INTEGER NOT NULL DEFAULT 0,
-        synced_at       TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_social_ref_project_date ON ga_social_referrals(project_id, date)`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_social_ref_source ON ga_social_referrals(source)`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_social_ref_unique ON ga_social_referrals(project_id, date, source, medium, channel_group)`
-    ]
-  },
-  {
-    version: 26,
-    name: "bing-coverage-snapshots",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS bing_coverage_snapshots (
-        id              TEXT PRIMARY KEY,
-        project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        date            TEXT NOT NULL,
-        indexed         INTEGER NOT NULL DEFAULT 0,
-        not_indexed     INTEGER NOT NULL DEFAULT 0,
-        unknown         INTEGER NOT NULL DEFAULT 0,
-        created_at      TEXT NOT NULL
-      )`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_bing_coverage_snap_project_date ON bing_coverage_snapshots(project_id, date)`
-    ]
-  },
-  {
-    version: 27,
-    name: "credential-columns-removed-from-schema",
-    statements: [
-      // Credential columns removed from Drizzle schema — credentials now live in config.yaml.
-      // Physical columns intentionally retained for one-time migration by server.ts.
-      // No DDL statements needed.
-    ]
-  },
-  {
-    version: 28,
-    name: "sync-run-id-bing-inspect",
-    statements: [
-      `ALTER TABLE bing_url_inspections ADD COLUMN sync_run_id TEXT REFERENCES runs(id) ON DELETE CASCADE`,
-      `CREATE INDEX IF NOT EXISTS idx_bing_inspect_run ON bing_url_inspections(sync_run_id)`
-    ]
-  },
-  {
-    version: 29,
-    name: "sync-run-id-ga-traffic",
-    statements: [
-      `ALTER TABLE ga_traffic_snapshots ADD COLUMN sync_run_id TEXT REFERENCES runs(id) ON DELETE CASCADE`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_traffic_run ON ga_traffic_snapshots(sync_run_id)`
-    ]
-  },
-  {
-    version: 30,
-    name: "sync-run-id-ga-ai-ref",
-    statements: [
-      `ALTER TABLE ga_ai_referrals ADD COLUMN sync_run_id TEXT REFERENCES runs(id) ON DELETE CASCADE`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_ai_ref_run ON ga_ai_referrals(sync_run_id)`
-    ]
-  },
-  {
-    version: 31,
-    name: "sync-run-id-ga-social-ref",
-    statements: [
-      `ALTER TABLE ga_social_referrals ADD COLUMN sync_run_id TEXT REFERENCES runs(id) ON DELETE CASCADE`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_social_ref_run ON ga_social_referrals(sync_run_id)`
-    ]
-  },
-  {
-    version: 32,
-    name: "sync-run-id-ga-summary",
-    statements: [
-      `ALTER TABLE ga_traffic_summaries ADD COLUMN sync_run_id TEXT REFERENCES runs(id) ON DELETE CASCADE`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_summary_run ON ga_traffic_summaries(sync_run_id)`
-    ]
-  },
-  {
-    version: 33,
-    name: "sync-run-id-bing-coverage",
-    statements: [
-      `ALTER TABLE bing_coverage_snapshots ADD COLUMN sync_run_id TEXT REFERENCES runs(id) ON DELETE CASCADE`,
-      `CREATE INDEX IF NOT EXISTS idx_bing_coverage_snap_run ON bing_coverage_snapshots(sync_run_id)`
-    ]
-  },
-  {
-    version: 34,
-    name: "bing-coverage-index-rename",
-    statements: [
-      `DROP INDEX IF EXISTS idx_bing_coverage_snap_project_date`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_bing_coverage_snap_project_date_unique ON bing_coverage_snapshots(project_id, date)`
-    ]
-  },
-  {
-    version: 35,
-    name: "snapshot-created-at-index",
-    statements: [
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_created_at ON query_snapshots(created_at)`
-    ]
-  },
-  {
-    version: 36,
-    name: "sql-injection-review",
-    statements: [
-      // Transaction handling and SQL injection review: verified all strings
-      // use SQLite ? binding via Drizzle. No parameterization changes needed.
-    ]
-  },
-  {
-    version: 37,
-    name: "legacy-credential-cleanup",
-    statements: [
-      // The legacy credential columns (private_key on ga_connections; access_token,
-      // refresh_token, token_expires_at on google_connections) are removed by the
-      // extractLegacyCredentials / dropLegacyCredentialColumns pair.
-      // Callers read the rows, persist them to config.yaml, and only then drop
-      // the columns so a failed config write doesn't permanently lose credentials.
-      // No DDL statements here — columns are dropped via exported functions below.
-    ]
-  },
-  {
-    version: 38,
-    name: "agent-sessions",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS agent_sessions (
-        id                TEXT PRIMARY KEY,
-        project_id        TEXT NOT NULL UNIQUE REFERENCES projects(id) ON DELETE CASCADE,
-        system_prompt     TEXT NOT NULL,
-        model_provider    TEXT NOT NULL,
-        model_id          TEXT NOT NULL,
-        messages          TEXT NOT NULL DEFAULT '[]',
-        follow_up_queue   TEXT NOT NULL DEFAULT '[]',
-        created_at        TEXT NOT NULL,
-        updated_at        TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_agent_sessions_project ON agent_sessions(project_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_agent_sessions_updated ON agent_sessions(updated_at)`
-    ]
-  },
-  {
-    version: 39,
-    name: "aero-provider-rename",
-    statements: [
-      // Align Aero provider IDs with sweep naming — anthropic→claude, google→gemini.
-      // Idempotent: the UPDATE is a no-op once the rename has been applied.
-      `UPDATE agent_sessions SET model_provider = 'claude' WHERE model_provider = 'anthropic'`,
-      `UPDATE agent_sessions SET model_provider = 'gemini' WHERE model_provider = 'google'`
-    ]
-  },
-  {
-    version: 40,
-    name: "agent-memory",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS agent_memory (
-        id          TEXT PRIMARY KEY,
-        project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        key         TEXT NOT NULL,
-        value       TEXT NOT NULL,
-        source      TEXT NOT NULL,
-        created_at  TEXT NOT NULL,
-        updated_at  TEXT NOT NULL
-      )`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS uniq_agent_memory_project_key
-        ON agent_memory(project_id, key)`,
-      `CREATE INDEX IF NOT EXISTS idx_agent_memory_project_updated
-        ON agent_memory(project_id, updated_at)`
-    ]
-  },
-  {
-    version: 41,
-    name: "common-crawl-backlinks",
-    statements: [
-      // cc_release_syncs
-      `CREATE TABLE IF NOT EXISTS cc_release_syncs (
-        id                      TEXT PRIMARY KEY,
-        release                 TEXT NOT NULL UNIQUE,
-        status                  TEXT NOT NULL,
-        phase_detail            TEXT,
-        vertex_path             TEXT,
-        edges_path              TEXT,
-        vertex_sha256           TEXT,
-        edges_sha256            TEXT,
-        vertex_bytes            INTEGER,
-        edges_bytes             INTEGER,
-        projects_processed      INTEGER,
-        domains_discovered      INTEGER,
-        download_started_at     TEXT,
-        download_finished_at    TEXT,
-        query_started_at        TEXT,
-        query_finished_at       TEXT,
-        error                   TEXT,
-        created_at              TEXT NOT NULL,
-        updated_at              TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_cc_release_syncs_status ON cc_release_syncs(status)`,
-      // backlink_domains
-      `CREATE TABLE IF NOT EXISTS backlink_domains (
-        id               TEXT PRIMARY KEY,
-        project_id       TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        release_sync_id  TEXT NOT NULL REFERENCES cc_release_syncs(id) ON DELETE CASCADE,
-        release          TEXT NOT NULL,
-        target_domain    TEXT NOT NULL,
-        linking_domain   TEXT NOT NULL,
-        num_hosts        INTEGER NOT NULL,
-        created_at       TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_backlink_domains_project ON backlink_domains(project_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_backlink_domains_release_sync ON backlink_domains(release_sync_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_backlink_domains_project_release ON backlink_domains(project_id, release)`,
-      `CREATE INDEX IF NOT EXISTS idx_backlink_domains_hosts ON backlink_domains(num_hosts)`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_backlink_domains_unique ON backlink_domains(project_id, release, linking_domain)`,
-      // backlink_summaries
-      `CREATE TABLE IF NOT EXISTS backlink_summaries (
-        id                       TEXT PRIMARY KEY,
-        project_id               TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        release_sync_id          TEXT NOT NULL REFERENCES cc_release_syncs(id) ON DELETE CASCADE,
-        release                  TEXT NOT NULL,
-        target_domain            TEXT NOT NULL,
-        total_linking_domains    INTEGER NOT NULL,
-        total_hosts              INTEGER NOT NULL,
-        top_10_hosts_share       TEXT NOT NULL,
-        queried_at               TEXT NOT NULL,
-        created_at               TEXT NOT NULL
-      )`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_backlink_summaries_project_release ON backlink_summaries(project_id, release)`,
-      `CREATE INDEX IF NOT EXISTS idx_backlink_summaries_project ON backlink_summaries(project_id)`
-    ]
-  },
-  {
-    version: 42,
-    name: "auto-extract-backlinks",
-    statements: [
-      `ALTER TABLE projects ADD COLUMN auto_extract_backlinks INTEGER NOT NULL DEFAULT 0`
-    ]
-  },
-  {
-    version: 43,
-    name: "backfill-bing-in-index",
-    statements: [
-      // Backfill bing_url_inspections.in_index using the new crawl-signal
-      // decision tree. Uses a created_at cutoff so rows written by the new
-      // code (which applies a live GetCrawlIssues demotion that can't be
-      // replayed offline) are preserved.
-      `UPDATE bing_url_inspections
-       SET in_index = CASE
-         WHEN document_size IS NOT NULL AND document_size > 0 THEN 1
-         WHEN last_crawled_date IS NOT NULL AND http_code IS NOT NULL AND http_code >= 400 THEN 0
-         WHEN last_crawled_date IS NOT NULL THEN 1
-         WHEN discovery_date IS NOT NULL THEN 0
-         ELSE NULL
-       END
-       WHERE created_at < '2026-04-22T00:00:00Z'`
-    ]
-  },
-  {
-    version: 44,
-    name: "ga-traffic-landing-normalized",
-    statements: [
-      `ALTER TABLE ga_traffic_snapshots ADD COLUMN landing_page_normalized TEXT`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_traffic_page_normalized
-         ON ga_traffic_snapshots(project_id, date, landing_page_normalized)`
-    ]
-  },
-  {
-    version: 45,
-    name: "ga-traffic-direct-sessions",
-    statements: [
-      `ALTER TABLE ga_traffic_snapshots ADD COLUMN direct_sessions INTEGER`
-    ]
-  },
-  {
-    version: 46,
-    name: "ga-ai-landing-page",
-    statements: [
-      `ALTER TABLE ga_ai_referrals ADD COLUMN landing_page TEXT NOT NULL DEFAULT '(not set)'`,
-      `ALTER TABLE ga_ai_referrals ADD COLUMN landing_page_normalized TEXT`,
-      `DROP INDEX IF EXISTS idx_ga_ai_ref_unique_v2`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_ai_ref_landing_page
-         ON ga_ai_referrals(project_id, date, landing_page_normalized)`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_ai_ref_unique_v3
-         ON ga_ai_referrals(project_id, date, source, medium, source_dimension, landing_page)`
-    ]
-  },
-  {
-    version: 47,
-    name: "ga-traffic-window-summaries",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS ga_traffic_window_summaries (
-        id                       TEXT PRIMARY KEY,
-        project_id               TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        window_key               TEXT NOT NULL,
-        period_start             TEXT NOT NULL,
-        period_end               TEXT NOT NULL,
-        total_sessions           INTEGER NOT NULL DEFAULT 0,
-        total_organic_sessions   INTEGER NOT NULL DEFAULT 0,
-        total_direct_sessions    INTEGER NOT NULL DEFAULT 0,
-        total_users              INTEGER NOT NULL DEFAULT 0,
-        synced_at                TEXT NOT NULL,
-        sync_run_id              TEXT REFERENCES runs(id) ON DELETE CASCADE
-      )`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_window_summary_unique
-         ON ga_traffic_window_summaries(project_id, window_key)`,
-      `CREATE INDEX IF NOT EXISTS idx_ga_window_summary_run
-         ON ga_traffic_window_summaries(sync_run_id)`
-    ]
-  },
-  {
-    version: 48,
-    name: "rename-keywords-to-queries",
-    // The actual legacy rename runs before bootstrap SQL so existing DBs never
-    // see new-name indexes before their old columns have been renamed. This
-    // version records the schema cutover and lands the final index names.
-    statements: [
-      `DROP INDEX IF EXISTS idx_keywords_project`,
-      `DROP INDEX IF EXISTS idx_keywords_project_keyword`,
-      `DROP INDEX IF EXISTS idx_snapshots_keyword`,
-      `DROP INDEX IF EXISTS idx_insights_keyword_provider`,
-      `CREATE INDEX IF NOT EXISTS idx_queries_project ON queries(project_id)`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_queries_project_query ON queries(project_id, query)`,
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_query ON query_snapshots(query_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_insights_query_provider ON insights(query, provider)`
-    ],
-    run: (tx) => {
-      normalizeLegacyQuerySchema(tx);
-    }
-  },
-  {
-    version: 49,
-    name: "server-side-traffic-tables",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS traffic_sources (
-        id              TEXT PRIMARY KEY,
-        project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        source_type     TEXT NOT NULL,
-        display_name    TEXT NOT NULL,
-        status          TEXT NOT NULL,
-        last_synced_at  TEXT,
-        last_cursor     TEXT,
-        last_error      TEXT,
-        archived_at     TEXT,
-        config_json     TEXT NOT NULL DEFAULT '{}',
-        created_at      TEXT NOT NULL,
-        updated_at      TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_traffic_sources_project ON traffic_sources(project_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_traffic_sources_project_status ON traffic_sources(project_id, status)`,
-      `CREATE TABLE IF NOT EXISTS crawler_events_hourly (
-        project_id           TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        source_id            TEXT NOT NULL REFERENCES traffic_sources(id) ON DELETE CASCADE,
-        ts_hour              TEXT NOT NULL,
-        bot_id               TEXT NOT NULL,
-        operator             TEXT NOT NULL,
-        verification_status  TEXT NOT NULL,
-        path_normalized      TEXT NOT NULL,
-        status               INTEGER NOT NULL,
-        hits                 INTEGER NOT NULL DEFAULT 0,
-        sampled_user_agent   TEXT,
-        created_at           TEXT NOT NULL,
-        updated_at           TEXT NOT NULL,
-        PRIMARY KEY (project_id, source_id, ts_hour, bot_id, verification_status, path_normalized, status)
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_crawler_hourly_project_ts ON crawler_events_hourly(project_id, ts_hour)`,
-      `CREATE INDEX IF NOT EXISTS idx_crawler_hourly_path ON crawler_events_hourly(project_id, path_normalized)`,
-      `CREATE TABLE IF NOT EXISTS ai_referral_events_hourly (
-        project_id                 TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        source_id                  TEXT NOT NULL REFERENCES traffic_sources(id) ON DELETE CASCADE,
-        ts_hour                    TEXT NOT NULL,
-        product                    TEXT NOT NULL,
-        operator                   TEXT NOT NULL,
-        source_domain              TEXT NOT NULL,
-        evidence_type              TEXT NOT NULL,
-        landing_path_normalized    TEXT NOT NULL,
-        status                     INTEGER NOT NULL,
-        sessions_or_hits           INTEGER NOT NULL DEFAULT 0,
-        users_estimated            INTEGER,
-        created_at                 TEXT NOT NULL,
-        updated_at                 TEXT NOT NULL,
-        PRIMARY KEY (project_id, source_id, ts_hour, product, source_domain, evidence_type, landing_path_normalized, status)
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_ai_referral_hourly_project_ts ON ai_referral_events_hourly(project_id, ts_hour)`,
-      `CREATE INDEX IF NOT EXISTS idx_ai_referral_hourly_landing ON ai_referral_events_hourly(project_id, landing_path_normalized)`,
-      `CREATE TABLE IF NOT EXISTS raw_event_samples (
-        id                        TEXT PRIMARY KEY,
-        project_id                TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-        source_id                 TEXT NOT NULL REFERENCES traffic_sources(id) ON DELETE CASCADE,
-        ts                        TEXT NOT NULL,
-        event_type                TEXT NOT NULL,
-        ip_hash                   TEXT,
-        user_agent                TEXT,
-        path_normalized           TEXT NOT NULL,
-        status                    INTEGER,
-        referer_host              TEXT,
-        classifier_details_json   TEXT NOT NULL DEFAULT '{}',
-        created_at                TEXT NOT NULL
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx_raw_event_samples_project_ts ON raw_event_samples(project_id, ts)`,
-      `CREATE INDEX IF NOT EXISTS idx_raw_event_samples_source_ts ON raw_event_samples(source_id, ts)`,
-      `CREATE INDEX IF NOT EXISTS idx_raw_event_samples_event_type ON raw_event_samples(event_type)`
-    ]
-  },
-  {
-    version: 50,
-    name: "ga-ai-referral-channel-group",
-    statements: [],
-    run: (tx) => {
-      if (!tableExists(tx, "ga_ai_referrals")) return;
-      if (!columnExists(tx, "ga_ai_referrals", "channel_group")) {
-        tx.run(sql.raw(`ALTER TABLE ga_ai_referrals ADD COLUMN channel_group TEXT NOT NULL DEFAULT '(not set)'`));
-      }
-      tx.run(sql.raw(`DROP INDEX IF EXISTS idx_ga_ai_ref_unique_v3`));
-      tx.run(sql.raw(`CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_ai_ref_unique_v4
-         ON ga_ai_referrals(project_id, date, source, medium, source_dimension, channel_group, landing_page)`));
-    }
-  },
-  {
-    version: 51,
-    name: "runs-source-id",
-    statements: [
-      `ALTER TABLE runs ADD COLUMN source_id TEXT`,
-      `CREATE INDEX IF NOT EXISTS idx_runs_source ON runs(source_id)`
-    ]
-  },
-  {
-    version: 52,
-    name: "traffic-sources-last-event-ids",
-    statements: [
-      // JSON-encoded array of normalized event IDs from the previous sync,
-      // used for cross-sync boundary-window dedupe so a longer default
-      // sync window (or any overlapping re-sync) cannot double-count.
-      `ALTER TABLE traffic_sources ADD COLUMN last_event_ids TEXT`
-    ]
-  },
-  {
-    version: 53,
-    name: "schedules-kind-and-source",
-    // The legacy schedules table carries an inline `UNIQUE(project_id)`
-    // constraint (see MIGRATION_SQL). SQLite doesn't support dropping inline
-    // table constraints, so we use the canonical table-rebuild pattern:
-    // create a new table with the desired schema, copy the data, drop the
-    // old, rename. All 4 statements run inside the migration runner's
-    // single transaction so a partial failure rolls everything back.
-    statements: [
-      // (project_id, kind) uniqueness is enforced by the explicit
-      // `CREATE UNIQUE INDEX idx_schedules_project_kind` below — that's the
-      // canonical drizzle-side index name (see schema.ts), so don't duplicate
-      // it as an inline UNIQUE() in CREATE TABLE.
-      `CREATE TABLE IF NOT EXISTS schedules_v53 (
-         id          TEXT PRIMARY KEY,
-         project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-         kind        TEXT NOT NULL DEFAULT 'answer-visibility',
-         cron_expr   TEXT NOT NULL,
-         preset      TEXT,
-         timezone    TEXT NOT NULL DEFAULT 'UTC',
-         enabled     INTEGER NOT NULL DEFAULT 1,
-         providers   TEXT NOT NULL DEFAULT '[]',
-         source_id   TEXT,
-         last_run_at TEXT,
-         next_run_at TEXT,
-         created_at  TEXT NOT NULL,
-         updated_at  TEXT NOT NULL
-       )`,
-      `INSERT INTO schedules_v53 (
-         id, project_id, kind, cron_expr, preset, timezone, enabled,
-         providers, source_id, last_run_at, next_run_at, created_at, updated_at
-       )
-       SELECT id, project_id, 'answer-visibility', cron_expr, preset, timezone, enabled,
-              providers, NULL, last_run_at, next_run_at, created_at, updated_at
-       FROM schedules`,
-      `DROP TABLE schedules`,
-      `ALTER TABLE schedules_v53 RENAME TO schedules`,
-      // The legacy single-column unique index doesn't survive the table
-      // rename, but explicitly DROP IF EXISTS to keep the migration
-      // idempotent across edge-case re-runs.
-      `DROP INDEX IF EXISTS idx_schedules_project`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_schedules_project_kind ON schedules(project_id, kind)`
-    ]
-  },
-  {
-    version: 54,
-    name: "drop-resurrected-schedules-project-index",
-    // v53 dropped `idx_schedules_project`, but `MIGRATION_SQL` (which runs on
-    // every boot, before versioned migrations) was still creating it. On any
-    // boot AFTER the one that applied v53, Phase 1 re-created the legacy
-    // single-column UNIQUE index, which then collided with the new
-    // (project_id, kind) semantics and broke traffic-sync schedule creation
-    // (`UNIQUE constraint failed: schedules.project_id`). MIGRATION_SQL no
-    // longer creates that index; this migration removes it from any DB that
-    // already booted past v53 with the resurrected index.
-    statements: [
-      `DROP INDEX IF EXISTS idx_schedules_project`
-    ]
-  },
-  {
-    version: 55,
-    name: "discovery-foundation",
-    // Adds the three-ring discovery foundation: per-project ICP, query/competitor
-    // provenance (so we can trace adopted basket entries back to a discovery
-    // session), and the two tables that hold a discovery session's research
-    // output. No UNIQUE(session_id, query) on discovery_probes — v2 will probe
-    // the same query across multiple providers in the same session.
-    //
-    // `competitor_map` defaults to '[]' (JSON array) — see DTO
-    // `discoveryCompetitorMapEntrySchema` for the entry shape `{domain, hits}`.
-    // Backfill of `provenance='cli'` runs once: existing pre-v55 rows are
-    // attributed to manual CLI entry so a future NULL distinctly means
-    // "post-v55 row missing provenance" (a bug to catch in review).
-    statements: [
-      `ALTER TABLE projects ADD COLUMN icp_description TEXT`,
-      `ALTER TABLE queries ADD COLUMN provenance TEXT`,
-      `ALTER TABLE competitors ADD COLUMN provenance TEXT`,
-      `UPDATE queries SET provenance = 'cli' WHERE provenance IS NULL`,
-      `UPDATE competitors SET provenance = 'cli' WHERE provenance IS NULL`,
-      `CREATE TABLE IF NOT EXISTS discovery_sessions (
-         id                  TEXT PRIMARY KEY,
-         project_id          TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-         status              TEXT NOT NULL DEFAULT 'queued',
-         icp_description     TEXT,
-         seed_provider       TEXT,
-         seed_count_raw      INTEGER,
-         seed_count          INTEGER,
-         dedup_threshold     REAL,
-         probe_count         INTEGER,
-         cited_count         INTEGER,
-         aspirational_count  INTEGER,
-         wasted_count        INTEGER,
-         competitor_map      TEXT NOT NULL DEFAULT '[]',
-         error               TEXT,
-         started_at          TEXT,
-         finished_at         TEXT,
-         created_at          TEXT NOT NULL
-       )`,
-      // "Latest session per project" is the access pattern; SQLite walks the
-      // composite index backwards for ORDER BY created_at DESC.
-      `CREATE INDEX IF NOT EXISTS idx_discovery_sessions_project_created ON discovery_sessions(project_id, created_at)`,
-      `CREATE TABLE IF NOT EXISTS discovery_probes (
-         id              TEXT PRIMARY KEY,
-         session_id      TEXT NOT NULL REFERENCES discovery_sessions(id) ON DELETE CASCADE,
-         project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-         query           TEXT NOT NULL,
-         bucket          TEXT,
-         citation_state  TEXT NOT NULL,
-         cited_domains   TEXT NOT NULL DEFAULT '[]',
-         raw_response    TEXT,
-         created_at      TEXT NOT NULL
-       )`,
-      `CREATE INDEX IF NOT EXISTS idx_discovery_probes_session ON discovery_probes(session_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_discovery_probes_project ON discovery_probes(project_id)`
-    ]
-  },
-  {
-    version: 56,
-    name: "discovery-sessions-run-id",
-    // Links a discovery_sessions row back to the runs row that drove it. Without
-    // this column the run-coordinator can't tell two concurrent discovery
-    // sessions apart for the same project — it would fall back to "latest
-    // non-queued session" and surface the wrong bucket counts to Aero.
-    statements: [
-      `ALTER TABLE discovery_sessions ADD COLUMN run_id TEXT`,
-      `CREATE INDEX IF NOT EXISTS idx_discovery_sessions_run ON discovery_sessions(run_id)`
-    ]
-  },
-  {
-    version: 57,
-    name: "runs-scoped-queries",
-    // Persists an optional subset of tracked queries to sweep on a per-run
-    // basis. NULL = full sweep (the default and only behavior pre-v57); a JSON
-    // array of query strings = scope. The job runner reads this to filter the
-    // query fetch via `inArray`.
-    statements: [
-      `ALTER TABLE runs ADD COLUMN queries TEXT`
-    ]
-  },
-  {
-    version: 58,
-    name: "snapshots-preserve-on-query-delete",
-    // The legacy `query_snapshots.query_id` FK was `ON DELETE CASCADE`, so a
-    // routine basket edit (PUT /queries replace, individual delete, `canonry
-    // apply` dropping a query) silently destroyed every historical citation
-    // snapshot for the removed queries — the regression history, transitions,
-    // and competitor-overlap evidence that are canonry's whole value.
-    //
-    // Fix: rebuild `query_snapshots` with `query_id` nullable + `ON DELETE
-    // SET NULL`, and add a denormalized `query_text` column populated from
-    // `queries.query` via the join. SQLite can't change FK or NOT NULL in
-    // place — same canonical table-rebuild pattern v53 used. All statements
-    // run inside the migration runner's single transaction.
-    //
-    // `run_id` keeps `ON DELETE CASCADE` — deleting a run legitimately
-    // removes its snapshots. Indexes are recreated on the renamed table.
-    statements: [
-      `CREATE TABLE IF NOT EXISTS query_snapshots_v58 (
-         id                       TEXT PRIMARY KEY,
-         run_id                   TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
-         query_id                 TEXT REFERENCES queries(id) ON DELETE SET NULL,
-         query_text               TEXT,
-         provider                 TEXT NOT NULL DEFAULT 'gemini',
-         model                    TEXT,
-         citation_state           TEXT NOT NULL,
-         answer_mentioned         INTEGER,
-         answer_text              TEXT,
-         cited_domains            TEXT NOT NULL DEFAULT '[]',
-         competitor_overlap       TEXT NOT NULL DEFAULT '[]',
-         recommended_competitors  TEXT NOT NULL DEFAULT '[]',
-         location                 TEXT,
-         screenshot_path          TEXT,
-         raw_response             TEXT,
-         created_at               TEXT NOT NULL
-       )`,
-      // Backfill `query_text` from joined queries.query so existing snapshots
-      // stay readable even if their query is later deleted.
-      //
-      // IMPORTANT: we use `q.id` (the JOINED queries.id), not `qs.query_id`.
-      // Production DBs may already contain snapshots whose `qs.query_id`
-      // dangles — a queries row was hard-deleted at some point without
-      // cascading (PRAGMA foreign_keys was OFF, or pre-FK schema). Copying
-      // `qs.query_id` directly would re-introduce those dangling refs into
-      // the new table, which now validates them at INSERT (the new FK still
-      // requires query_id values to match queries.id when non-null). Reading
-      // through the LEFT JOIN forces every value to be either a valid `q.id`
-      // or NULL — pre-existing orphans land with NULL `query_id` / NULL
-      // `query_text`, preserving the snapshot row instead of failing the
-      // migration. The May 2026 azcoatings DB had 459 such pre-existing
-      // orphans; without this guard, migrate() throws SQLITE_CONSTRAINT_FOREIGNKEY.
-      `INSERT INTO query_snapshots_v58 (
-         id, run_id, query_id, query_text, provider, model, citation_state,
-         answer_mentioned, answer_text, cited_domains, competitor_overlap,
-         recommended_competitors, location, screenshot_path, raw_response,
-         created_at
-       )
-       SELECT qs.id, qs.run_id, q.id, q.query, qs.provider, qs.model,
-              qs.citation_state, qs.answer_mentioned, qs.answer_text,
-              qs.cited_domains, qs.competitor_overlap, qs.recommended_competitors,
-              qs.location, qs.screenshot_path, qs.raw_response, qs.created_at
-       FROM query_snapshots qs
-       LEFT JOIN queries q ON q.id = qs.query_id`,
-      `DROP TABLE query_snapshots`,
-      `ALTER TABLE query_snapshots_v58 RENAME TO query_snapshots`,
-      // Recreate the indexes that didn't survive the rename.
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_run ON query_snapshots(run_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_query ON query_snapshots(query_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_citation_state ON query_snapshots(citation_state)`,
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_provider_model ON query_snapshots(provider, model)`,
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_location ON query_snapshots(location)`,
-      `CREATE INDEX IF NOT EXISTS idx_snapshots_created_at ON query_snapshots(created_at)`
-    ]
-  },
-  {
-    version: 59,
-    name: "projects-aliases",
-    statements: [
-      `ALTER TABLE projects ADD COLUMN aliases TEXT NOT NULL DEFAULT '[]'`
-    ]
-  },
-  {
-    version: 60,
-    name: "audit-log-preserve-on-project-delete",
-    // The legacy `audit_log.project_id` FK was `ON DELETE CASCADE`, so any
-    // `DELETE /projects/:name` call cascade-wiped every audit row for that
-    // project — including the `project.deleted` row the route handler had
-    // just written in the same path. The deletion erased the only record
-    // that the deletion happened, defeating the entire purpose of the
-    // audit log.
-    //
-    // Fix: rebuild `audit_log` with `project_id` as `ON DELETE SET NULL`.
-    // Existing rows survive verbatim; future deletions detach audit rows
-    // from the project (project_id=NULL) instead of erasing them. SQLite
-    // can't change FK behavior in place — same canonical table-rebuild
-    // pattern v58 used for `query_snapshots`.
-    statements: [
-      `CREATE TABLE IF NOT EXISTS audit_log_v60 (
-         id           TEXT PRIMARY KEY,
-         project_id   TEXT REFERENCES projects(id) ON DELETE SET NULL,
-         actor        TEXT NOT NULL,
-         action       TEXT NOT NULL,
-         entity_type  TEXT NOT NULL,
-         entity_id    TEXT,
-         diff         TEXT,
-         created_at   TEXT NOT NULL
-       )`,
-      // LEFT JOIN guard mirrors v58: if a pre-existing row carries a
-      // dangling project_id (from a pre-FK era or a write with
-      // PRAGMA foreign_keys=OFF), the join nulls it out rather than
-      // failing the migration on the new FK validation.
-      `INSERT INTO audit_log_v60 (
-         id, project_id, actor, action, entity_type, entity_id, diff, created_at
-       )
-       SELECT a.id, p.id, a.actor, a.action, a.entity_type, a.entity_id, a.diff, a.created_at
-       FROM audit_log a
-       LEFT JOIN projects p ON p.id = a.project_id`,
-      `DROP TABLE audit_log`,
-      `ALTER TABLE audit_log_v60 RENAME TO audit_log`,
-      `CREATE INDEX IF NOT EXISTS idx_audit_log_project ON audit_log(project_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_audit_log_created ON audit_log(created_at)`
-    ]
-  },
-  {
-    version: 61,
-    name: "content-target-dismissals",
-    // Persistent per-recommendation dismissal so users can mark a content
-    // opportunity "addressed" after they ship the page. The orchestrator
-    // recomputes opportunities on every report load from live GSC / GA
-    // inventory; without persistent dismissal, a recommendation lingers
-    // until the next sync surfaces the new page (days–weeks of lag).
-    //
-    // Keyed by `(project_id, target_ref)` where `target_ref` is the stable
-    // hash that `computeTargetRef()` already produces — same value the
-    // ContentTargetRowDto exposes, so the client passes back the ref it
-    // sees.
-    statements: [
-      `CREATE TABLE IF NOT EXISTS content_target_dismissals (
-         id             TEXT PRIMARY KEY,
-         project_id     TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-         target_ref     TEXT NOT NULL,
-         addressed_url  TEXT,
-         note           TEXT,
-         dismissed_at   TEXT NOT NULL
-       )`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_content_target_dismissals_project_ref ON content_target_dismissals(project_id, target_ref)`,
-      `CREATE INDEX IF NOT EXISTS idx_content_target_dismissals_project ON content_target_dismissals(project_id)`
-    ]
-  },
-  {
-    version: 62,
-    name: "recommendation-explanations",
-    // LLM-generated rationale for content recommendations. Cached per
-    // (project, target_ref, prompt_version) so repeat clicks are free.
-    // Bumping the prompt version invalidates the cache forward without
-    // touching the table.
-    statements: [
-      `CREATE TABLE IF NOT EXISTS recommendation_explanations (
-         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,
-         response_text   TEXT NOT NULL,
-         cost_millicents INTEGER NOT NULL DEFAULT 0,
-         generated_at    TEXT NOT NULL
-       )`,
-      `CREATE UNIQUE INDEX IF NOT EXISTS idx_recommendation_explanations_unique ON recommendation_explanations(project_id, target_ref, prompt_version)`,
-      `CREATE INDEX IF NOT EXISTS idx_recommendation_explanations_project ON recommendation_explanations(project_id)`
-    ]
-  },
-  {
-    version: 63,
-    name: "audit-log-attribution-columns",
-    // Adds `user_agent` and `actor_session` to `audit_log` so post-mortems
-    // can attribute destructive events (like the 2026-05-15 azcoatings
-    // queries.replaced incident — see PR #593) to a specific caller.
-    // Without these columns, every mutation rides as `actor='api'` with no
-    // narrower identity, so it's impossible to tell whether a destructive
-    // event came from CLI, dashboard, MCP, an agent, or an external script.
-    //
-    // Both columns nullable — the audit log accepts writes from sources
-    // that don't have an HTTP request context (scheduler, run-coordinator,
-    // direct DB writes from CLI commands).
-    statements: [
-      `ALTER TABLE audit_log ADD COLUMN user_agent TEXT`,
-      `ALTER TABLE audit_log ADD COLUMN actor_session TEXT`
-    ]
-  },
-  {
-    version: 64,
-    name: "ai-user-fetch-events-hourly",
-    // Splits per-user fetches (ChatGPT-User, Perplexity-User) out of
-    // crawler_events_hourly so the dashboard / API can distinguish bulk
-    // machine crawl from human-in-the-loop fetch. Bot IDs are pinned to the
-    // two `purpose: 'user-agent'` rules that existed before this change —
-    // future user-fetch UAs land in the new table directly via the
-    // refactored classifier and never need a backfill.
-    //
-    // Statements are idempotent: CREATE/INDEX are IF NOT EXISTS; the
-    // INSERT … SELECT uses ON CONFLICT DO NOTHING (composite PK rows
-    // already moved skip silently); the DELETE keys on `bot_id`, so a
-    // second run is a no-op after the first DELETE drains the source.
-    statements: [
-      `CREATE TABLE IF NOT EXISTS ai_user_fetch_events_hourly (
-         project_id           TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-         source_id            TEXT NOT NULL REFERENCES traffic_sources(id) ON DELETE CASCADE,
-         ts_hour              TEXT NOT NULL,
-         bot_id               TEXT NOT NULL,
-         operator             TEXT NOT NULL,
-         verification_status  TEXT NOT NULL,
-         path_normalized      TEXT NOT NULL,
-         status               INTEGER NOT NULL,
-         hits                 INTEGER NOT NULL DEFAULT 0,
-         sampled_user_agent   TEXT,
-         created_at           TEXT NOT NULL,
-         updated_at           TEXT NOT NULL,
-         PRIMARY KEY (project_id, source_id, ts_hour, bot_id, verification_status, path_normalized, status)
-       )`,
-      `CREATE INDEX IF NOT EXISTS idx_ai_user_fetch_hourly_project_ts ON ai_user_fetch_events_hourly(project_id, ts_hour)`,
-      `CREATE INDEX IF NOT EXISTS idx_ai_user_fetch_hourly_path ON ai_user_fetch_events_hourly(project_id, path_normalized)`,
-      `INSERT INTO ai_user_fetch_events_hourly
-         (project_id, source_id, ts_hour, bot_id, operator, verification_status, path_normalized, status, hits, sampled_user_agent, created_at, updated_at)
-       SELECT project_id, source_id, ts_hour, bot_id, operator, verification_status, path_normalized, status, hits, sampled_user_agent, created_at, updated_at
-         FROM crawler_events_hourly
-        WHERE bot_id IN ('openai-chatgpt-user', 'perplexity-user')
-       ON CONFLICT DO NOTHING`,
-      `DELETE FROM crawler_events_hourly WHERE bot_id IN ('openai-chatgpt-user', 'perplexity-user')`
-    ]
-  },
-  {
-    version: 65,
-    name: "split-mistral-ai-rule",
-    // The pre-existing `mistral-ai` rule matched both `MistralAI-User/*`
-    // (per-user fetch) and `MistralBot/*` (bulk crawl) under one id, so
-    // every historical row landed in crawler_events_hourly with
-    // bot_id='mistral-ai'. The rule is now split into `mistral-ai-user`
-    // (purpose: 'user-agent') and `mistral-bot` (purpose: 'crawl'); this
-    // migration best-effort routes the legacy rows using the bucket's
-    // representative sampled_user_agent.
-    //
-    // Mixed-UA buckets (where a single (project, source, hour, path,
-    // status) accumulated both UAs under the old shared id) are routed
-    // by whichever UA happened to be sampled — the bucket-key granularity
-    // doesn't preserve per-event UAs, so any heuristic has the same
-    // limitation. Going forward the split rules write to disjoint tables.
-    //
-    // Idempotent: the INSERT…SELECT uses ON CONFLICT DO NOTHING; the
-    // UPDATE and DELETE both filter on bot_id='mistral-ai', so a second
-    // run finds no rows after the first apply.
-    statements: [
-      `INSERT INTO ai_user_fetch_events_hourly
-         (project_id, source_id, ts_hour, bot_id, operator, verification_status, path_normalized, status, hits, sampled_user_agent, created_at, updated_at)
-       SELECT project_id, source_id, ts_hour, 'mistral-ai-user', operator, verification_status, path_normalized, status, hits, sampled_user_agent, created_at, updated_at
-         FROM crawler_events_hourly
-        WHERE bot_id = 'mistral-ai' AND sampled_user_agent LIKE '%MistralAI-User%'
-       ON CONFLICT DO NOTHING`,
-      `DELETE FROM crawler_events_hourly WHERE bot_id = 'mistral-ai' AND sampled_user_agent LIKE '%MistralAI-User%'`,
-      `UPDATE crawler_events_hourly SET bot_id = 'mistral-bot' WHERE bot_id = 'mistral-ai'`
-    ]
-  },
-  {
-    version: 66,
-    name: "oauth-connections-track-owning-project",
-    // Cross-project OAuth takeover defense. Before this column, the OAuth
-    // callback for Google and the connect route for Bing keyed everything on
-    // `domain` alone — an attacker who created a project pointed at a victim's
-    // canonical domain could complete OAuth from their own Google/Bing account
-    // and silently overwrite the legitimate refresh token under that domain
-    // key. The new `created_by_project_id` column records the project that
-    // first established each connection; the callback and DELETE routes refuse
-    // cross-project writes when it doesn't match.
-    //
-    // Backfill: for each existing connection row, set the owner to the project
-    // whose `canonical_domain` matches AND whose `created_at` is oldest (the
-    // most likely original owner in a 1:N domain-shared install). Rows with no
-    // matching project stay NULL — treated as "unowned" so a future legitimate
-    // connect from any project can claim them.
-    //
-    // Uses the `run` hook so the schema-edit + backfill only fire when the
-    // target tables exist. The legacy-keyword test scenario seeds a DB at v46
-    // without google_connections / bing_connections (they're created in v6 but
-    // the test bypasses the bootstrap) — without the guard, this version's
-    // ALTER fails with "no such table".
-    //
-    // Idempotent: column-existence guard means re-running this version is a
-    // no-op; the backfill UPDATE only writes rows where the column is NULL.
-    statements: [],
-    run: (db) => {
-      if (tableExists(db, "google_connections") && !columnExists(db, "google_connections", "created_by_project_id")) {
-        db.run(sql.raw(
-          `ALTER TABLE google_connections ADD COLUMN created_by_project_id TEXT REFERENCES projects(id) ON DELETE SET NULL`
-        ));
-        db.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_google_conn_project ON google_connections(created_by_project_id)`));
-        db.run(sql.raw(
-          `UPDATE google_connections
-              SET created_by_project_id = (
-                SELECT p.id FROM projects p
-                 WHERE LOWER(p.canonical_domain) = LOWER(google_connections.domain)
-                 ORDER BY p.created_at ASC
-                 LIMIT 1
-              )
-            WHERE created_by_project_id IS NULL`
-        ));
-      }
-      if (tableExists(db, "bing_connections") && !columnExists(db, "bing_connections", "created_by_project_id")) {
-        db.run(sql.raw(
-          `ALTER TABLE bing_connections ADD COLUMN created_by_project_id TEXT REFERENCES projects(id) ON DELETE SET NULL`
-        ));
-        db.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_bing_conn_project ON bing_connections(created_by_project_id)`));
-        db.run(sql.raw(
-          `UPDATE bing_connections
-              SET created_by_project_id = (
-                SELECT p.id FROM projects p
-                 WHERE LOWER(p.canonical_domain) = LOWER(bing_connections.domain)
-                 ORDER BY p.created_at ASC
-                 LIMIT 1
-              )
-            WHERE created_by_project_id IS NULL`
-        ));
-      }
-    }
-  }
-];
-function isDuplicateColumnError(err) {
-  if (!(err instanceof Error)) return false;
-  if (err.message.includes("duplicate column name")) return true;
-  if (err.cause instanceof Error && err.cause.message.includes("duplicate column name")) return true;
-  return false;
-}
-function columnExists(db, table, column) {
-  const rows = db.all(sql.raw(
-    `SELECT COUNT(*) as c FROM pragma_table_info('${table}') WHERE name = '${column}'`
-  ));
-  return (rows[0]?.c ?? 0) > 0;
-}
-function tableExists(db, table) {
-  const rows = db.all(sql.raw(
-    `SELECT COUNT(*) as c FROM sqlite_master WHERE type = 'table' AND name = '${table}'`
-  ));
-  return (rows[0]?.c ?? 0) > 0;
-}
-function tableIsEmpty(db, table) {
-  const rows = db.all(sql.raw(`SELECT COUNT(*) as c FROM ${table}`));
-  return (rows[0]?.c ?? 0) === 0;
-}
-function hasLegacyQuerySchema(db) {
-  return tableExists(db, "keywords") || columnExists(db, "query_snapshots", "keyword_id") || columnExists(db, "insights", "keyword");
-}
-function normalizeLegacyQuerySchema(db) {
-  if (!hasLegacyQuerySchema(db)) return;
-  if (tableExists(db, "keywords") && tableExists(db, "queries")) {
-    if (!tableIsEmpty(db, "queries")) {
-      throw new Error("Cannot migrate keywords to queries because both tables contain data");
-    }
-    db.run(sql.raw(`DROP TABLE queries`));
-  }
-  db.run(sql.raw(`DROP INDEX IF EXISTS idx_keywords_project`));
-  db.run(sql.raw(`DROP INDEX IF EXISTS idx_keywords_project_keyword`));
-  db.run(sql.raw(`DROP INDEX IF EXISTS idx_snapshots_keyword`));
-  db.run(sql.raw(`DROP INDEX IF EXISTS idx_insights_keyword_provider`));
-  if (tableExists(db, "keywords")) {
-    db.run(sql.raw(`ALTER TABLE keywords RENAME TO queries`));
-  }
-  if (columnExists(db, "queries", "keyword")) {
-    db.run(sql.raw(`ALTER TABLE queries RENAME COLUMN keyword TO query`));
-  }
-  if (columnExists(db, "query_snapshots", "keyword_id")) {
-    db.run(sql.raw(`ALTER TABLE query_snapshots RENAME COLUMN keyword_id TO query_id`));
-  }
-  if (columnExists(db, "insights", "keyword")) {
-    db.run(sql.raw(`ALTER TABLE insights RENAME COLUMN keyword TO query`));
-  }
-}
-function dropColumnIfExists(db, table, column) {
-  try {
-    db.run(sql.raw(`ALTER TABLE ${table} DROP COLUMN ${column}`));
-  } catch (err) {
-    if (!(err instanceof Error)) throw err;
-    const msg = err.message;
-    const causeMsg = err.cause instanceof Error ? err.cause.message : "";
-    const expected = `no such column: "${column}"`;
-    const expectedAlt = `no such column: ${column}`;
-    if (msg.includes(expected) || msg.includes(expectedAlt)) return;
-    if (causeMsg.includes(expected) || causeMsg.includes(expectedAlt)) return;
-    throw err;
-  }
-}
-function extractLegacyCredentials(db) {
-  const out = { google: [], ga4: [] };
-  if (columnExists(db, "google_connections", "access_token")) {
-    const rows = db.all(sql.raw(
-      `SELECT domain, connection_type, property_id, sitemap_url, access_token, refresh_token, token_expires_at, scopes, created_at, updated_at
-       FROM google_connections
-       WHERE refresh_token IS NOT NULL AND refresh_token != ''`
-    ));
-    for (const row of rows) {
-      out.google.push({
-        domain: row.domain,
-        connectionType: row.connection_type,
-        propertyId: row.property_id,
-        sitemapUrl: row.sitemap_url,
-        accessToken: row.access_token,
-        refreshToken: row.refresh_token,
-        tokenExpiresAt: row.token_expires_at,
-        scopes: parseJsonColumn(row.scopes, []),
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      });
-    }
-  }
-  if (columnExists(db, "ga_connections", "private_key")) {
-    const rows = db.all(sql.raw(
-      `SELECT p.name AS project_name, ga.property_id, ga.client_email, ga.private_key, ga.created_at, ga.updated_at
-       FROM ga_connections ga
-       INNER JOIN projects p ON p.id = ga.project_id
-       WHERE ga.private_key IS NOT NULL AND ga.private_key != ''`
-    ));
-    for (const row of rows) {
-      out.ga4.push({
-        projectName: row.project_name,
-        propertyId: row.property_id,
-        clientEmail: row.client_email,
-        privateKey: row.private_key,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      });
-    }
-  }
-  return out;
-}
-function dropLegacyCredentialColumns(db) {
-  if (columnExists(db, "google_connections", "access_token")) {
-    dropColumnIfExists(db, "google_connections", "access_token");
-  }
-  if (columnExists(db, "google_connections", "refresh_token")) {
-    dropColumnIfExists(db, "google_connections", "refresh_token");
-  }
-  if (columnExists(db, "google_connections", "token_expires_at")) {
-    dropColumnIfExists(db, "google_connections", "token_expires_at");
-  }
-  if (columnExists(db, "ga_connections", "private_key")) {
-    dropColumnIfExists(db, "ga_connections", "private_key");
-  }
-}
-function getAppliedVersion(db) {
-  const rows = db.all(sql`SELECT MAX(version) as max_version FROM _migrations`);
-  return rows[0]?.max_version ?? 0;
-}
-function recordMigration(db, version, name) {
-  db.run(sql`INSERT OR IGNORE INTO _migrations (version, name) VALUES (${version}, ${name})`);
-}
-function migrate(db) {
-  db.transaction((tx) => {
-    normalizeLegacyQuerySchema(tx);
-  });
-  const statements = MIGRATION_SQL.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
-  for (const statement of statements) {
-    db.run(sql.raw(statement));
-  }
-  const appliedVersion = getAppliedVersion(db);
-  for (const mv of MIGRATION_VERSIONS) {
-    if (mv.version <= appliedVersion) continue;
-    db.transaction((tx) => {
-      for (const statement of mv.statements) {
-        try {
-          tx.run(sql.raw(statement));
-        } catch (err) {
-          if (isDuplicateColumnError(err)) continue;
-          throw err;
-        }
-      }
-      mv.run?.(tx);
-      recordMigration(tx, mv.version, mv.name);
-    });
-  }
-}
-
-// ../db/src/run-helpers.ts
-function groupRunsByCreatedAt(rows) {
-  const groups = [];
-  let current = [];
-  let currentCreatedAt = null;
-  for (const row of rows) {
-    if (row.createdAt === currentCreatedAt) {
-      current.push(row);
-    } else {
-      if (current.length > 0) groups.push(current);
-      current = [row];
-      currentCreatedAt = row.createdAt;
-    }
-  }
-  if (current.length > 0) groups.push(current);
-  return groups;
-}
-function pickGroupRepresentative(group) {
-  if (group.length === 0) return null;
-  let best = group[0];
-  for (let i = 1; i < group.length; i++) {
-    const candidate = group[i];
-    if (candidate.id > best.id) best = candidate;
-  }
-  return best;
-}
-
-// ../db/src/snapshot-helpers.ts
-function filterTrackedSnapshots(rows) {
-  return rows.filter((r) => r.queryId !== null);
-}
-
-// ../intelligence/src/regressions.ts
-function snapshotKey(snap) {
-  const loc = snap.location ?? "__none__";
-  return JSON.stringify([snap.query, snap.provider, loc]);
-}
-function detectRegressions(currentRun, previousRun) {
-  if ((currentRun.location ?? null) !== (previousRun.location ?? null)) {
-    return [];
-  }
-  const regressions = [];
-  const previousCited = /* @__PURE__ */ new Map();
-  for (const snap of previousRun.snapshots) {
-    if (snap.cited) {
-      previousCited.set(snapshotKey(snap), {
-        citationUrl: snap.citationUrl,
-        position: snap.position
-      });
-    }
-  }
-  for (const snap of currentRun.snapshots) {
-    const key = snapshotKey(snap);
-    if (!snap.cited && previousCited.has(key)) {
-      const prev = previousCited.get(key);
-      regressions.push({
-        query: snap.query,
-        provider: snap.provider,
-        previousCitationUrl: prev.citationUrl,
-        previousPosition: prev.position,
-        currentRunId: currentRun.runId,
-        previousRunId: previousRun.runId
-      });
-    }
-  }
-  return regressions;
-}
-
-// ../intelligence/src/gains.ts
-function snapshotKey2(snap) {
-  const loc = snap.location ?? "__none__";
-  return JSON.stringify([snap.query, snap.provider, loc]);
-}
-function detectGains(currentRun, previousRun) {
-  if ((currentRun.location ?? null) !== (previousRun.location ?? null)) {
-    return [];
-  }
-  const gains = [];
-  const previousCited = /* @__PURE__ */ new Set();
-  for (const snap of previousRun.snapshots) {
-    if (snap.cited) {
-      previousCited.add(snapshotKey2(snap));
-    }
-  }
-  for (const snap of currentRun.snapshots) {
-    const key = snapshotKey2(snap);
-    if (snap.cited && !previousCited.has(key)) {
-      gains.push({
-        query: snap.query,
-        provider: snap.provider,
-        citationUrl: snap.citationUrl,
-        position: snap.position,
-        snippet: snap.snippet,
-        runId: currentRun.runId
-      });
-    }
-  }
-  return gains;
-}
-
-// ../intelligence/src/health.ts
-function computeHealth(run) {
-  const providerStats = /* @__PURE__ */ new Map();
-  let totalPairs = 0;
-  let citedPairs = 0;
-  for (const snap of run.snapshots) {
-    totalPairs++;
-    if (snap.cited) citedPairs++;
-    const stats = providerStats.get(snap.provider) ?? { cited: 0, total: 0 };
-    stats.total++;
-    if (snap.cited) stats.cited++;
-    providerStats.set(snap.provider, stats);
-  }
-  const providerBreakdown = {};
-  for (const [provider, stats] of providerStats) {
-    providerBreakdown[provider] = {
-      citedRate: stats.total > 0 ? stats.cited / stats.total : 0,
-      cited: stats.cited,
-      total: stats.total
-    };
-  }
-  return {
-    overallCitedRate: totalPairs > 0 ? citedPairs / totalPairs : 0,
-    totalPairs,
-    citedPairs,
-    providerBreakdown
-  };
-}
-function computeHealthTrend(runs2) {
-  if (runs2.length === 0) {
-    return { current: 0, previous: 0, delta: 0 };
-  }
-  const current = computeHealth(runs2[runs2.length - 1]).overallCitedRate;
-  if (runs2.length === 1) {
-    return { current, previous: 0, delta: current };
-  }
-  const previous = computeHealth(runs2[runs2.length - 2]).overallCitedRate;
-  return {
-    current,
-    previous,
-    delta: current - previous
-  };
-}
-
-// ../intelligence/src/causes.ts
-function analyzeCause(regression, currentSnapshots) {
-  const matchingSnaps = currentSnapshots.filter(
-    (s) => s.query === regression.query && s.provider === regression.provider && !s.cited
-  );
-  const withCompetitor = matchingSnaps.find((s) => s.competitorDomains?.length);
-  if (withCompetitor) {
-    const competitor = withCompetitor.competitorDomains[0];
-    return {
-      cause: "competitor_gain",
-      competitorDomain: competitor,
-      details: `Competitor ${competitor} now cited for "${regression.query}" on ${regression.provider}`
-    };
-  }
-  const withCited = matchingSnaps.find((s) => s.citedDomains?.length);
-  if (withCited) {
-    const top = withCited.citedDomains.slice(0, 3);
-    return {
-      cause: "third_party_displacement",
-      details: `${regression.provider} now grounds on ${top.join(", ")} for "${regression.query}" \u2014 none are tracked competitors.`
-    };
-  }
-  return {
-    cause: "unknown",
-    details: `No specific cause identified for loss of "${regression.query}" on ${regression.provider}`
-  };
-}
-
-// ../intelligence/src/insights.ts
-import { randomUUID } from "crypto";
-var QUERY_LEVEL_PROVIDER = "all";
-function generateInsights(input) {
-  const insights2 = [];
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const id = () => `ins_${randomUUID().slice(0, 8)}`;
-  for (const reg of input.regressions) {
-    const cause = input.causes.get(`${reg.query}:${reg.provider}`);
-    insights2.push({
-      id: id(),
-      type: "regression",
-      severity: "high",
-      title: `Lost ${reg.provider} citation for "${reg.query}"`,
-      query: reg.query,
-      provider: reg.provider,
-      recommendation: {
-        action: "audit",
-        target: reg.previousCitationUrl,
-        reason: `Page was previously cited at position ${reg.previousPosition ?? "unknown"}. Run aeo-audit to check for content or schema issues.`
-      },
-      cause,
-      createdAt: now
-    });
-  }
-  for (const gain of input.gains) {
-    insights2.push({
-      id: id(),
-      type: "gain",
-      severity: "low",
-      title: `New ${gain.provider} citation for "${gain.query}"`,
-      query: gain.query,
-      provider: gain.provider,
-      recommendation: {
-        action: "monitor",
-        target: gain.citationUrl,
-        reason: `New citation appeared at position ${gain.position ?? "unknown"}. Monitor to confirm it persists.`
-      },
-      createdAt: now
-    });
-  }
-  for (const fc of input.firstCitations) {
-    insights2.push({
-      id: id(),
-      type: "first-citation",
-      severity: "medium",
-      title: `First citation for "${fc.query}" on ${fc.provider}`,
-      query: fc.query,
-      provider: fc.provider,
-      recommendation: {
-        action: "monitor",
-        target: fc.citationUrl,
-        reason: `"${fc.query}" had not been cited by any provider before this run. Monitor to confirm the citation persists.`
-      },
-      createdAt: now
-    });
-  }
-  for (const pp of input.providerPickups) {
-    insights2.push({
-      id: id(),
-      type: "provider-pickup",
-      severity: "low",
-      title: `${pp.provider} picked up "${pp.query}"`,
-      query: pp.query,
-      provider: pp.provider,
-      recommendation: {
-        action: "monitor",
-        target: pp.citationUrl,
-        reason: `${pp.provider} started citing "${pp.query}" alongside other providers. Monitor to confirm the citation persists.`
-      },
-      createdAt: now
-    });
-  }
-  for (const gap of input.persistentGaps) {
-    insights2.push({
-      id: id(),
-      type: "persistent-gap",
-      severity: "medium",
-      title: `"${gap.query}" uncited for ${gap.streak} runs`,
-      query: gap.query,
-      provider: QUERY_LEVEL_PROVIDER,
-      recommendation: {
-        action: "audit",
-        reason: `No provider has cited "${gap.query}" for ${gap.streak} consecutive runs. Audit content and schema for this topic.`
-      },
-      createdAt: now
-    });
-  }
-  for (const cg of input.competitorGains) {
-    insights2.push({
-      id: id(),
-      type: "competitor-gained",
-      severity: "medium",
-      title: `${cg.competitorDomain} appeared on "${cg.query}"`,
-      query: cg.query,
-      provider: QUERY_LEVEL_PROVIDER,
-      cause: {
-        cause: "competitor_gain",
-        competitorDomain: cg.competitorDomain,
-        details: `Tracked competitor ${cg.competitorDomain} just got cited on "${cg.query}".`
-      },
-      recommendation: {
-        action: "audit",
-        reason: `Investigate ${cg.competitorDomain}'s content for "${cg.query}" \u2014 they just earned a citation here.`
-      },
-      createdAt: now
-    });
-  }
-  for (const cl of input.competitorLosses) {
-    insights2.push({
-      id: id(),
-      type: "competitor-lost",
-      severity: "low",
-      title: `${cl.competitorDomain} dropped from "${cl.query}"`,
-      query: cl.query,
-      provider: QUERY_LEVEL_PROVIDER,
-      cause: {
-        cause: "competitor_loss",
-        competitorDomain: cl.competitorDomain,
-        details: `Tracked competitor ${cl.competitorDomain} lost their citation on "${cl.query}".`
-      },
-      recommendation: {
-        action: "monitor",
-        reason: `Opportunity: ${cl.competitorDomain} just lost "${cl.query}". Tighten your own coverage to fill the gap.`
-      },
-      createdAt: now
-    });
-  }
-  return insights2;
-}
-
-// ../intelligence/src/first-citations.ts
-function detectFirstCitations(currentRun, previousRun) {
-  const previousCitedQueries = /* @__PURE__ */ new Set();
-  for (const snap of previousRun.snapshots) {
-    if (snap.cited) previousCitedQueries.add(snap.query);
-  }
-  const result = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const snap of currentRun.snapshots) {
-    if (!snap.cited) continue;
-    if (previousCitedQueries.has(snap.query)) continue;
-    const key = `${snap.query}:${snap.provider}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    result.push({
-      query: snap.query,
-      provider: snap.provider,
-      citationUrl: snap.citationUrl,
-      position: snap.position,
-      runId: currentRun.runId
-    });
-  }
-  return result;
-}
-
-// ../intelligence/src/provider-pickups.ts
-function detectProviderPickups(currentRun, previousRun) {
-  const previousCitedQueries = /* @__PURE__ */ new Set();
-  const previousCitedPairs = /* @__PURE__ */ new Set();
-  for (const snap of previousRun.snapshots) {
-    if (!snap.cited) continue;
-    previousCitedQueries.add(snap.query);
-    previousCitedPairs.add(`${snap.query}:${snap.provider}`);
-  }
-  const result = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const snap of currentRun.snapshots) {
-    if (!snap.cited) continue;
-    if (!previousCitedQueries.has(snap.query)) continue;
-    const key = `${snap.query}:${snap.provider}`;
-    if (previousCitedPairs.has(key)) continue;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    result.push({
-      query: snap.query,
-      provider: snap.provider,
-      citationUrl: snap.citationUrl,
-      position: snap.position,
-      runId: currentRun.runId
-    });
-  }
-  return result;
-}
-
-// ../intelligence/src/persistent-gaps.ts
-var PERSISTENT_GAP_THRESHOLD = 3;
-function detectPersistentGaps(runs2, threshold = PERSISTENT_GAP_THRESHOLD) {
-  if (runs2.length < threshold) return [];
-  const queries2 = /* @__PURE__ */ new Set();
-  for (const run of runs2) {
-    for (const snap of run.snapshots) {
-      if (snap.query) queries2.add(snap.query);
-    }
-  }
-  const result = [];
-  for (const query of queries2) {
-    let streak = 0;
-    for (let i = runs2.length - 1; i >= 0; i--) {
-      const run = runs2[i];
-      const snaps = run.snapshots.filter((s) => s.query === query);
-      if (snaps.length === 0) break;
-      const anyCited = snaps.some((s) => s.cited);
-      if (anyCited) break;
-      streak++;
-    }
-    if (streak >= threshold) {
-      result.push({ query, streak, threshold });
-    }
-  }
-  return result;
-}
-
-// ../intelligence/src/competitor-changes.ts
-function buildCompetitorQueryMap(run, tracked) {
-  const result = /* @__PURE__ */ new Map();
-  for (const snap of run.snapshots) {
-    if (!snap.query || !snap.competitorDomains || snap.competitorDomains.length === 0) continue;
-    for (const domain of snap.competitorDomains) {
-      if (!tracked.has(domain)) continue;
-      const existing = result.get(domain) ?? /* @__PURE__ */ new Set();
-      existing.add(snap.query);
-      result.set(domain, existing);
-    }
-  }
-  return result;
-}
-function detectCompetitorGains(currentRun, previousRun, opts) {
-  const tracked = new Set(opts.trackedCompetitors);
-  if (tracked.size === 0) return [];
-  const currentMap = buildCompetitorQueryMap(currentRun, tracked);
-  const previousMap = buildCompetitorQueryMap(previousRun, tracked);
-  const result = [];
-  for (const competitorDomain of tracked) {
-    const currentQs = currentMap.get(competitorDomain) ?? /* @__PURE__ */ new Set();
-    const previousQs = previousMap.get(competitorDomain) ?? /* @__PURE__ */ new Set();
-    for (const query of currentQs) {
-      if (previousQs.has(query)) continue;
-      result.push({ query, competitorDomain });
-    }
-  }
-  return result;
-}
-function detectCompetitorLosses(currentRun, previousRun, opts) {
-  const tracked = new Set(opts.trackedCompetitors);
-  if (tracked.size === 0) return [];
-  const currentMap = buildCompetitorQueryMap(currentRun, tracked);
-  const previousMap = buildCompetitorQueryMap(previousRun, tracked);
-  const result = [];
-  for (const competitorDomain of tracked) {
-    const currentQs = currentMap.get(competitorDomain) ?? /* @__PURE__ */ new Set();
-    const previousQs = previousMap.get(competitorDomain) ?? /* @__PURE__ */ new Set();
-    for (const query of previousQs) {
-      if (currentQs.has(query)) continue;
-      result.push({ query, competitorDomain });
-    }
-  }
-  return result;
-}
-
-// ../intelligence/src/analyzer.ts
-function analyzeRuns(currentRun, previousRun, opts = {}) {
-  const trackedCompetitors = opts.trackedCompetitors ?? [];
-  const history = opts.history ?? [];
-  const persistentGapThreshold = opts.persistentGapThreshold ?? PERSISTENT_GAP_THRESHOLD;
-  const regressions = detectRegressions(currentRun, previousRun);
-  const gains = detectGains(currentRun, previousRun);
-  const firstCitations = detectFirstCitations(currentRun, previousRun);
-  const providerPickups = detectProviderPickups(currentRun, previousRun);
-  const competitorGains = detectCompetitorGains(currentRun, previousRun, { trackedCompetitors });
-  const competitorLosses = detectCompetitorLosses(currentRun, previousRun, { trackedCompetitors });
-  const persistentGaps = history.length >= persistentGapThreshold ? detectPersistentGaps(history, persistentGapThreshold) : [];
-  const health = computeHealth(currentRun);
-  const trend = history.length > 0 ? computeHealthTrend(history) : void 0;
-  const causes = /* @__PURE__ */ new Map();
-  for (const reg of regressions) {
-    const cause = analyzeCause(reg, currentRun.snapshots);
-    causes.set(`${reg.query}:${reg.provider}`, cause);
-  }
-  const insights2 = generateInsights({
-    regressions,
-    gains,
-    firstCitations,
-    providerPickups,
-    persistentGaps,
-    competitorGains,
-    competitorLosses,
-    health,
-    causes
-  });
-  return {
-    regressions,
-    gains,
-    firstCitations,
-    providerPickups,
-    persistentGaps,
-    competitorGains,
-    competitorLosses,
-    health,
-    trend,
-    insights: insights2
-  };
-}
-
-// ../intelligence/src/query-shape.ts
-var TRANSACTIONAL = /\b(?:buy|price|pricing|cost|cheap|discount|coupon|deal|sale|trial|plan)\b/i;
-var NAVIGATIONAL = /\b(?:login|sign[- ]?in|contact|support|help|download|app|homepage)\b|\.(?:com|io|net|org|app|ai)\b/i;
-function isBlogShapedQuery(query) {
-  const trimmed = query.trim();
-  if (!trimmed) return false;
-  if (TRANSACTIONAL.test(trimmed)) return false;
-  if (NAVIGATIONAL.test(trimmed)) return false;
-  return true;
-}
-
-// ../intelligence/src/site-inventory.ts
-var BLOG_SHAPED_PATH_PREFIXES = [
-  "/blog/",
-  "/posts/",
-  "/articles/",
-  "/guides/",
-  "/learn/",
-  "/resources/",
-  "/glossary/"
-];
-function buildInventory(input) {
-  const map = /* @__PURE__ */ new Map();
-  const addPage = (rawUrl, source) => {
-    const path = extractPath(rawUrl);
-    if (!path) return;
-    if (!isBlogShaped(path)) return;
-    let sources = map.get(path);
-    if (!sources) {
-      sources = /* @__PURE__ */ new Set();
-      map.set(path, sources);
-    }
-    sources.add(source);
-  };
-  for (const url of input.gscPages) addPage(url, "gsc");
-  for (const url of input.ga4LandingPages) addPage(url, "ga4");
-  for (const url of input.sitemapUrls) addPage(url, "sitemap");
-  for (const url of input.wpPosts) addPage(url, "wp");
-  return Array.from(map.entries()).map(([url, sources]) => ({
-    url,
-    sources: Array.from(sources)
-  }));
-}
-function extractPath(url) {
-  const trimmed = url.trim();
-  if (!trimmed) return "";
-  let path;
-  try {
-    path = new URL(trimmed).pathname;
-  } catch {
-    path = trimmed;
-  }
-  const stripped = path.replace(/\/+$/, "");
-  return stripped || "/";
-}
-function isBlogShaped(path) {
-  return BLOG_SHAPED_PATH_PREFIXES.some((prefix) => path.startsWith(prefix));
-}
-
-// ../intelligence/src/content-classifier.ts
-var SEO_STRONG_THRESHOLD = 10;
-var SEO_WEAK_THRESHOLD = 30;
-function isHomepageOnly(url) {
-  if (url === "/" || url === "") return true;
-  const stripped = url.split("?")[0].replace(/\/+$/, "");
-  return stripped === "" || stripped === "/";
-}
-function classifyContentAction(input) {
-  const { ourPage, ourPageInGroundingSources, ourPageHasSchema } = input;
-  if (!ourPage) return "create";
-  if (isHomepageOnly(ourPage.url)) return "create";
-  if (ourPageInGroundingSources) {
-    if (ourPageHasSchema === false) return "add-schema";
-    return null;
-  }
-  if (ourPage.position <= SEO_STRONG_THRESHOLD) return "refresh";
-  if (ourPage.position <= SEO_WEAK_THRESHOLD) return "expand";
-  return "create";
-}
-
-// ../intelligence/src/content-scorer.ts
-var SEVERITY_BY_ACTION = {
-  create: 1,
-  "add-schema": 0.7,
-  expand: 0.6,
-  refresh: 0.4
-};
-function scoreContentTarget(input) {
-  const demand = computeDemandComponent(input.gscImpressions, input.aiReferralFactor);
-  const competitor = computeCompetitorComponent(
-    input.competitorCount,
-    input.recentMissRate,
-    input.citationCount
-  );
-  const absence = clamp01(1 - input.ourCitedRate);
-  const gapSeverity = input.action ? SEVERITY_BY_ACTION[input.action] : 0;
-  const score = (demand + competitor) * absence * gapSeverity;
-  return {
-    score,
-    scoreBreakdown: { demand, competitor, absence, gapSeverity },
-    drivers: buildDrivers(input),
-    demandSource: classifyDemandSource(input.gscImpressions, input.competitorCount)
-  };
-}
-function computeDemandComponent(gscImpressions, aiReferralFactor) {
-  const logImpressions = Math.log(Math.max(gscImpressions, 0) + 1);
-  const aiBoost = 1 + Math.max(aiReferralFactor, 0);
-  return logImpressions * aiBoost;
-}
-function computeCompetitorComponent(competitorCount, recentMissRate, citationCount) {
-  if (competitorCount <= 0) return 0;
-  const logCompetitors = Math.log(competitorCount + 1);
-  return logCompetitors * clamp01(recentMissRate) * Math.max(citationCount, 0);
-}
-function classifyDemandSource(gscImpressions, competitorCount) {
-  const hasGsc = gscImpressions > 0;
-  const hasCompetitor = competitorCount > 0;
-  if (hasGsc && hasCompetitor) return "both";
-  if (hasCompetitor) return "competitor-evidence";
-  return "gsc";
-}
-function clamp01(value) {
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
-function buildDrivers(input) {
-  const drivers = [];
-  if (input.competitorCount > 0) {
-    const noun = input.competitorCount === 1 ? "competitor" : "competitors";
-    drivers.push(`${input.competitorCount} ${noun} cited`);
-  }
-  if (input.gscImpressions > 0) {
-    drivers.push(`${formatImpressions(input.gscImpressions)} GSC impressions`);
-  }
-  if (input.recentMissRate >= 0.5 && input.competitorCount > 0) {
-    const pct = Math.round(clamp01(input.recentMissRate) * 100);
-    drivers.push(`missed in ${pct}% of recent runs`);
-  }
-  if (input.action === "create" && input.position === null) {
-    drivers.push("no existing page");
-  }
-  if (input.position !== null) {
-    const positionDisplay = Math.round(input.position);
-    if (input.position > 30) {
-      drivers.push(`page ranks #${positionDisplay} (effectively invisible)`);
-    } else if (input.position > 10) {
-      drivers.push(`page ranks #${positionDisplay}`);
-    }
-  }
-  if (input.action === "add-schema") {
-    drivers.push("cited by LLMs but lacks structured data");
-  }
-  return drivers;
-}
-function formatImpressions(impressions) {
-  if (impressions >= 1e3) {
-    return `${Math.round(impressions / 100) / 10}k`;
-  }
-  return String(impressions);
-}
-
-// ../intelligence/src/content-confidence.ts
-var GSC_DENSE_IMPRESSIONS_THRESHOLD = 100;
-var RUN_HISTORY_HIGH_CONFIDENCE_THRESHOLD = 3;
-function calculateActionConfidence(input) {
-  const gscDense = input.hasGsc && input.gscImpressions >= GSC_DENSE_IMPRESSIONS_THRESHOLD;
-  const historyDeep = input.runsOfHistory >= RUN_HISTORY_HIGH_CONFIDENCE_THRESHOLD;
-  if (gscDense && historyDeep) return "high";
-  if (!input.hasGsc && !input.hasInventoryMatch) {
-    return "low";
-  }
-  return "medium";
-}
-
-// ../intelligence/src/content-targets.ts
-function buildContentTargetRows(input) {
-  const rows = [];
-  for (const cq of input.candidateQueries) {
-    const ourPage = resolveOurPage(cq, input.inventory);
-    const ourPageInGroundingSources = cq.ourCitedInLatestRun;
-    const ourPageHasSchema = ourPage ? input.wpSchemaAudit.get(ourPage.url) ?? null : null;
-    const action = classifyContentAction({
-      ourPage,
-      ourPageInGroundingSources,
-      ourPageHasSchema
-    });
-    if (!action) continue;
-    const hasGsc = cq.gscImpressions > 0;
-    const hasCompetitor = cq.competitorDomains.length > 0;
-    if (!hasGsc && !hasCompetitor && !cq.ourCitedInLatestRun) continue;
-    const aiReferralFactor = computeAiReferralFactor(
-      input.totalAiReferralSessions,
-      cq.competitorCitationCount
-    );
-    const scoring = scoreContentTarget({
-      gscImpressions: cq.gscImpressions,
-      aiReferralFactor,
-      competitorCount: cq.competitorDomains.length,
-      recentMissRate: cq.recentMissRate,
-      citationCount: cq.competitorCitationCount,
-      ourCitedRate: cq.ourCitedRate,
-      action,
-      position: ourPage?.position ?? null
-    });
-    const actionConfidence = calculateActionConfidence({
-      hasGsc: cq.gscPage !== null,
-      gscImpressions: cq.gscImpressions,
-      runsOfHistory: cq.runsOfHistory,
-      hasCompetitorEvidence: cq.competitorDomains.length > 0,
-      hasInventoryMatch: ourPage?.source === "inventory"
-    });
-    const targetRef = computeTargetRef({
-      projectId: input.projectId,
-      query: cq.query,
-      action
-    });
-    const winningCompetitor = pickTopCompetitor(cq.competitorGroundingUrls);
-    const ourBestPage = ourPage ? {
-      url: ourPage.url,
-      gscImpressions: cq.gscImpressions,
-      gscClicks: cq.gscClicks,
-      gscAvgPosition: cq.gscPosition,
-      organicSessions: input.gaTrafficByPage.get(ourPage.url) ?? 0
-    } : null;
-    rows.push({
-      targetRef,
-      query: cq.query,
-      action,
-      ourBestPage,
-      winningCompetitor,
-      score: scoring.score,
-      scoreBreakdown: scoring.scoreBreakdown,
-      drivers: scoring.drivers,
-      demandSource: scoring.demandSource,
-      actionConfidence,
-      existingAction: input.inProgressActions.get(targetRef) ?? null
-    });
-  }
-  return dedupeByIntent(
-    rows.sort((a, b) => b.score - a.score),
-    input.queryIntentModifiers ?? []
-  );
-}
-function buildContentSourceRows(input) {
-  return input.candidateQueries.map((cq) => ({
-    query: cq.query,
-    groundingSources: [
-      ...cq.ourGroundingUrls.map((g) => ({
-        uri: g.uri,
-        title: g.title,
-        domain: g.domain,
-        isOurDomain: true,
-        isCompetitor: false,
-        citationCount: g.citationCount,
-        providers: g.providers
-      })),
-      ...cq.competitorGroundingUrls.map((g) => ({
-        uri: g.uri,
-        title: g.title,
-        domain: g.domain,
-        isOurDomain: false,
-        isCompetitor: true,
-        citationCount: g.citationCount,
-        providers: g.providers
-      }))
-    ]
-  }));
-}
-function buildContentGapRows(input) {
-  const gaps = [];
-  for (const cq of input.candidateQueries) {
-    if (cq.competitorDomains.length === 0) continue;
-    if (cq.ourCitedRate >= 1) continue;
-    gaps.push({
-      query: cq.query,
-      competitorDomains: cq.competitorDomains,
-      competitorCount: cq.competitorDomains.length,
-      missRate: clamp012(cq.recentMissRate),
-      lastSeenInRunId: input.latestRunId
-    });
-  }
-  return gaps.sort((a, b) => {
-    if (b.missRate !== a.missRate) return b.missRate - a.missRate;
-    return b.competitorCount - a.competitorCount;
-  });
-}
-function resolveOurPage(cq, inventory) {
-  if (cq.gscPage && cq.gscPosition !== null) {
-    return { url: cq.gscPage, position: cq.gscPosition, source: "gsc" };
-  }
-  for (const page of inventory) {
-    if (slugMatchesQuery(page.url, cq.query)) {
-      return { url: page.url, position: 100, source: "inventory" };
-    }
-  }
-  return null;
-}
-function slugMatchesQuery(url, query) {
-  const slug = url.toLowerCase();
-  const queryAsSlug = query.toLowerCase().trim().replace(/\s+/g, "-");
-  if (slug.includes(queryAsSlug)) return true;
-  const queryTokens = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
-  const slugTokens = new Set(slug.split(/[/\s\-_.]+/));
-  const overlap = queryTokens.filter((t) => slugTokens.has(t)).length;
-  return overlap >= 2;
-}
-function computeAiReferralFactor(totalAiReferralSessions, competitorCount) {
-  if (totalAiReferralSessions <= 0) return 0;
-  const baseline = Math.min(totalAiReferralSessions / 1e3, 0.5);
-  const competitorBoost = competitorCount > 0 ? 0.1 : 0;
-  return Math.min(baseline + competitorBoost, 1);
-}
-var QUERY_INTENT_STOPWORDS = /* @__PURE__ */ new Set([
-  "a",
-  "an",
-  "and",
-  "at",
-  "by",
-  "for",
-  "from",
-  "in",
-  "near",
-  "of",
-  "on",
-  "or",
-  "the",
-  "to"
-]);
-function dedupeByIntent(rows, modifiers) {
-  if (rows.length <= 1 || modifiers.length === 0) return rows;
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  const modifierTokens = new Set(
-    modifiers.flatMap(tokenizeQuery).map(normalizeToken).filter(Boolean)
-  );
-  for (const row of rows) {
-    const key = intentKey(row.query, modifierTokens);
-    if (!key || seen.has(key)) continue;
-    seen.add(key);
-    result.push(row);
-  }
-  return result;
-}
-function intentKey(query, modifierTokens) {
-  const tokens = tokenizeQuery(query).map(normalizeToken).filter(Boolean).filter((token) => !QUERY_INTENT_STOPWORDS.has(token)).filter((token) => !modifierTokens.has(token));
-  return [...new Set(tokens)].sort().join(" ");
-}
-function tokenizeQuery(value) {
-  return value.toLowerCase().match(/[a-z0-9]+/g) ?? [];
-}
-function normalizeToken(token) {
-  if (token.length > 4 && token.endsWith("ies")) return `${token.slice(0, -3)}y`;
-  if (token.length > 4 && token.endsWith("s") && !token.endsWith("ss")) return token.slice(0, -1);
-  return token;
-}
-function pickTopCompetitor(competitors2) {
-  if (competitors2.length === 0) return null;
-  const top = [...competitors2].sort((a, b) => b.citationCount - a.citationCount)[0];
-  return {
-    domain: top.domain,
-    url: top.uri,
-    title: top.title,
-    citationCount: top.citationCount
-  };
-}
-function computeTargetRef(input) {
-  const key = [input.projectId, input.query, input.action].join("|");
-  let hash = 0;
-  for (let i = 0; i < key.length; i++) {
-    hash = (hash << 5) - hash + key.charCodeAt(i) | 0;
-  }
-  return `tgt_${(hash >>> 0).toString(36)}`;
-}
-function clamp012(value) {
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
-
-// ../intelligence/src/next-steps.ts
-var TOP_N = 5;
-var IMMEDIATE_HORIZON = 3;
-var ACTION_TITLE = {
-  [ContentActions.create]: (q) => `Create a page targeting "${q}"`,
-  [ContentActions.refresh]: (q) => `Refresh the page targeting "${q}"`,
-  [ContentActions.expand]: (q) => `Expand coverage of "${q}"`,
-  [ContentActions["add-schema"]]: (q) => `Add structured data to the page targeting "${q}"`
-};
-function mapOpportunitiesToNextSteps(opportunities, existing) {
-  if (existing.length > 0) return existing;
-  if (opportunities.length === 0) return [];
-  return opportunities.slice(0, TOP_N).map((opp, idx) => ({
-    horizon: idx < IMMEDIATE_HORIZON ? "immediate" : "short-term",
-    title: ACTION_TITLE[opp.action](opp.query),
-    rationale: `Score ${Math.round(opp.score)} \xB7 demand ${opp.demandSource} \xB7 ${opp.actionConfidence} confidence.`
-  }));
-}
-
-// ../intelligence/src/insight-severity.ts
-var SEVERITY_THRESHOLDS = {
-  highTrafficImpressions: 100,
-  recurrenceCount: 2,
-  mediumTrafficImpressions: 10
-};
-function classifyRegressionSeverity(signals) {
-  const { gscImpressions, recurrenceCount } = signals;
-  if (gscImpressions === void 0 && recurrenceCount === void 0) return "high";
-  const isHighTraffic = gscImpressions !== void 0 && gscImpressions >= SEVERITY_THRESHOLDS.highTrafficImpressions;
-  const isRecurring = recurrenceCount !== void 0 && recurrenceCount >= SEVERITY_THRESHOLDS.recurrenceCount;
-  const isModerateTraffic = gscImpressions !== void 0 && gscImpressions >= SEVERITY_THRESHOLDS.mediumTrafficImpressions;
-  if (isHighTraffic && isRecurring) return "critical";
-  if (isHighTraffic || isRecurring) return "high";
-  if (isModerateTraffic) return "medium";
-  return "low";
-}
-
-// ../intelligence/src/insight-grouping.ts
-function groupInsights(insights2, keyFn = (i) => JSON.stringify([i.query, i.provider, i.type])) {
-  const order = [];
-  const buckets = /* @__PURE__ */ new Map();
-  for (const i of insights2) {
-    const key = keyFn(i);
-    const bucket = buckets.get(key);
-    if (bucket) {
-      bucket.push(i);
-    } else {
-      buckets.set(key, [i]);
-      order.push(key);
-    }
-  }
-  return order.map((key) => {
-    const sorted = [...buckets.get(key)].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-    const representative = sorted[sorted.length - 1];
-    return {
-      representative,
-      count: sorted.length,
-      instances: sorted,
-      latest: representative.createdAt
-    };
-  });
-}
-
-// ../intelligence/src/query-categorize.ts
-var TRANSACTIONAL_RE = /\b(?:buy|price|pricing|cost|hire|near me|services?|agency|consultant|company)\b/i;
-var INFORMATIONAL_RE = /\b(?:what|how|why|when|guide|tutorial|vs|versus|alternatives?|examples?|definition)\b/i;
-var MIN_BRAND_TOKEN_LENGTH = 3;
-function compact(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
-}
-function buildBrandTokens(canonicalDomain, brandNames = []) {
-  const seen = /* @__PURE__ */ new Set();
-  const stem = canonicalDomain.toLowerCase().replace(/\.[a-z]{2,}$/, "");
-  const stemCompact = compact(stem);
-  if (stemCompact.length >= MIN_BRAND_TOKEN_LENGTH) seen.add(stemCompact);
-  for (const name of brandNames) {
-    if (!name) continue;
-    const nameCompact = compact(name);
-    if (nameCompact.length >= MIN_BRAND_TOKEN_LENGTH) seen.add(nameCompact);
-  }
-  return [...seen];
-}
-function categorizeQueryByIntent(query, brandTokens) {
-  const compactQuery = compact(query);
-  if (brandTokens.length > 0 && brandTokens.some((t) => compactQuery.includes(t))) {
-    return "brand";
-  }
-  if (TRANSACTIONAL_RE.test(query)) return "lead-gen";
-  if (INFORMATIONAL_RE.test(query)) return "industry";
-  return "other";
-}
-
-// ../intelligence/src/trend-stability.ts
-var MIN_TREND_POINTS = 4;
-function isTrendBaseline(points) {
-  return points.length < MIN_TREND_POINTS;
-}
-
-// ../intelligence/src/citation-scorecard.ts
-function buildCitationScorecard(snapshots, queryLookup) {
-  if (snapshots.length === 0) {
-    return { queries: [], providers: [], matrix: [], providerRates: [] };
-  }
-  const querySet = /* @__PURE__ */ new Set();
-  const providerSet = /* @__PURE__ */ new Set();
-  for (const snap of snapshots) {
-    const q = queryLookup.byId.get(snap.queryId);
-    if (!q) continue;
-    querySet.add(q);
-    providerSet.add(snap.provider);
-  }
-  const queryList = [...querySet].sort();
-  const providerList = [...providerSet].sort();
-  const matrix = queryList.map(
-    () => providerList.map(() => null)
-  );
-  const providerCounts = /* @__PURE__ */ new Map();
-  for (const snap of snapshots) {
-    const q = queryLookup.byId.get(snap.queryId);
-    if (!q) continue;
-    const qi = queryList.indexOf(q);
-    const pi = providerList.indexOf(snap.provider);
-    if (qi < 0 || pi < 0) continue;
-    matrix[qi][pi] = {
-      citationState: snap.citationState === CitationStates.cited ? "cited" : "not-cited",
-      answerMentioned: snap.answerMentioned ?? null,
-      model: snap.model
-    };
-    const counts = providerCounts.get(snap.provider) ?? { cited: 0, total: 0 };
-    counts.total++;
-    if (snap.citationState === CitationStates.cited) counts.cited++;
-    providerCounts.set(snap.provider, counts);
-  }
-  const providerRates = providerList.map((provider) => {
-    const counts = providerCounts.get(provider) ?? { cited: 0, total: 0 };
-    const citationRate = counts.total > 0 ? Math.round(counts.cited / counts.total * 100) : 0;
-    return {
-      provider,
-      citedCount: counts.cited,
-      totalCount: counts.total,
-      citationRate
-    };
-  });
-  return { queries: queryList, providers: providerList, matrix, providerRates };
-}
-
-// ../intelligence/src/domain-matching.ts
-function citedDomainBelongsToProject(citedDomain, projectDomains) {
-  const candidate = normalizeProjectDomain(citedDomain);
-  for (const domain of projectDomains) {
-    const normalized = normalizeProjectDomain(domain);
-    if (candidate === normalized || candidate.endsWith(`.${normalized}`)) return true;
-  }
-  return false;
-}
-
-// ../intelligence/src/competitor-landscape.ts
-function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains, queryLookup) {
-  let projectCitationCount = 0;
-  const competitorMap = /* @__PURE__ */ new Map();
-  for (const c of competitorDomains) {
-    competitorMap.set(c, { count: 0, queries: /* @__PURE__ */ new Set(), pages: /* @__PURE__ */ new Map() });
-  }
-  for (const snap of snapshots) {
-    const q = queryLookup.byId.get(snap.queryId);
-    const allDomains = [...snap.citedDomains, ...snap.competitorOverlap];
-    if (allDomains.some((d) => citedDomainBelongsToProject(d, projectDomains))) {
-      projectCitationCount++;
-    }
-    for (const competitor of competitorDomains) {
-      if (allDomains.some((d) => citedDomainBelongsToProject(d, [competitor]))) {
-        const entry = competitorMap.get(competitor);
-        entry.count++;
-        if (q) entry.queries.add(q);
-      }
-      const competitorNorm = normalizeUrlDomain(competitor);
-      for (const gs of snap.groundingSources) {
-        const host = normalizeUrlDomain(extractHostFromUri(gs.uri));
-        if (!host) continue;
-        if (host === competitorNorm || host.endsWith(`.${competitorNorm}`)) {
-          const entry = competitorMap.get(competitor);
-          const pageQueries = entry.pages.get(gs.uri) ?? /* @__PURE__ */ new Set();
-          if (q) pageQueries.add(q);
-          entry.pages.set(gs.uri, pageQueries);
-        }
-      }
-    }
-  }
-  const totalCitedSlots = projectCitationCount + [...competitorMap.values()].reduce((sum, v) => sum + v.count, 0);
-  const competitorRows = [...competitorMap.entries()].map(([domain, data]) => {
-    const total = snapshots.length;
-    const ratio = total > 0 ? data.count / total : 0;
-    let pressureLabel = "None";
-    if (data.count > 0) {
-      if (ratio >= 0.5) pressureLabel = "High";
-      else if (ratio >= 0.2) pressureLabel = "Moderate";
-      else pressureLabel = "Low";
-    }
-    const sharePct = totalCitedSlots > 0 ? Math.round(data.count / totalCitedSlots * 100) : 0;
-    const theirCitedPages = [...data.pages.entries()].map(([url, qs]) => ({ url, citedFor: [...qs].sort() })).sort((a, b) => b.citedFor.length - a.citedFor.length);
-    return {
-      domain,
-      citationCount: data.count,
-      totalCount: total,
-      pressureLabel,
-      citedQueries: [...data.queries].sort(),
-      sharePct,
-      theirCitedPages
-    };
-  });
-  competitorRows.sort((a, b) => b.citationCount - a.citationCount);
-  return { projectCitationCount, competitors: competitorRows };
-}
-function normalizeUrlDomain(domain) {
-  return domain.toLowerCase().replace(/^https?:\/\//, "").replace(/^www\./, "").replace(/\/$/, "");
-}
-function extractHostFromUri(uri) {
-  try {
-    return new URL(uri).hostname;
-  } catch {
-    return "";
-  }
-}
-
-// ../intelligence/src/mention-landscape.ts
-function buildMentionLandscape(snapshots, competitorDomains, projectBrandNames, projectDomains, queryLookup) {
-  let projectMentionCount = 0;
-  let totalAnswerSnapshots = 0;
-  const competitorMap = /* @__PURE__ */ new Map();
-  for (const c of competitorDomains) {
-    competitorMap.set(c, { count: 0, queries: /* @__PURE__ */ new Set() });
-  }
-  for (const snap of snapshots) {
-    const text2 = snap.answerText;
-    if (!text2) continue;
-    totalAnswerSnapshots++;
-    const q = queryLookup.byId.get(snap.queryId);
-    const projectMentioned = snap.answerMentioned ?? determineAnswerMentioned(
-      text2,
-      [...projectBrandNames],
-      [...projectDomains]
-    );
-    if (projectMentioned) projectMentionCount++;
-    for (const competitor of competitorDomains) {
-      const brand = brandLabelFromDomain(competitor);
-      const mentioned = determineAnswerMentioned(text2, brand ? [brand] : [], [competitor]);
-      if (mentioned) {
-        const entry = competitorMap.get(competitor);
-        entry.count++;
-        if (q) entry.queries.add(q);
-      }
-    }
-  }
-  const totalMentionedSlots = projectMentionCount + [...competitorMap.values()].reduce((sum, v) => sum + v.count, 0);
-  const competitorRows = [...competitorMap.entries()].map(([domain, data]) => {
-    const ratio = totalAnswerSnapshots > 0 ? data.count / totalAnswerSnapshots : 0;
-    let pressureLabel = "None";
-    if (data.count > 0) {
-      if (ratio >= 0.5) pressureLabel = "High";
-      else if (ratio >= 0.2) pressureLabel = "Moderate";
-      else pressureLabel = "Low";
-    }
-    const sharePct = totalMentionedSlots > 0 ? Math.round(data.count / totalMentionedSlots * 100) : 0;
-    return {
-      domain,
-      mentionCount: data.count,
-      totalCount: totalAnswerSnapshots,
-      pressureLabel,
-      mentionedQueries: [...data.queries].sort(),
-      sharePct
-    };
-  });
-  competitorRows.sort((a, b) => b.mentionCount - a.mentionCount);
-  return { projectMentionCount, totalAnswerSnapshots, competitors: competitorRows };
-}
-
-// ../intelligence/src/ai-source-origin.ts
-var DEFAULT_TOP_SOURCE_DOMAINS_LIMIT = 20;
-function buildAiSourceOrigin(snapshots, projectDomains, competitorDomains, topDomainsLimit = DEFAULT_TOP_SOURCE_DOMAINS_LIMIT) {
-  const categoryCounts = /* @__PURE__ */ new Map();
-  const domainCounts = /* @__PURE__ */ new Map();
-  let totalCitations = 0;
-  for (const snap of snapshots) {
-    for (const raw of snap.citedDomains) {
-      if (citedDomainBelongsToProject(raw, projectDomains)) continue;
-      const { category, domain } = categorizeSourceWithCompetitors(
-        raw,
-        competitorDomains,
-        citedDomainBelongsToProject
-      );
-      const bucketLabel = categoryLabel(category);
-      const cat = categoryCounts.get(category) ?? { label: bucketLabel, count: 0 };
-      cat.count++;
-      categoryCounts.set(category, cat);
-      domainCounts.set(domain, (domainCounts.get(domain) ?? 0) + 1);
-      totalCitations++;
-    }
-  }
-  const categories = [...categoryCounts.entries()].map(([category, { label, count }]) => ({
-    category,
-    label,
-    count,
-    sharePct: totalCitations > 0 ? Math.round(count / totalCitations * 100) : 0
-  })).sort((a, b) => b.count - a.count);
-  const topDomains = [...domainCounts.entries()].map(([domain, count]) => ({
-    domain,
-    count,
-    isCompetitor: citedDomainBelongsToProject(domain, competitorDomains)
-  })).sort((a, b) => b.count - a.count).slice(0, topDomainsLimit);
-  return { categories, topDomains };
-}
-
-// ../intelligence/src/movement-summary.ts
-function buildMovementSummary(currentSnapshots, previousSnapshots, options = {}) {
-  if (previousSnapshots.length === 0) {
-    const citedIds = collectCitedQueryIds(currentSnapshots);
-    const citedCount = citedIds.size;
-    const tone2 = citedCount > 0 ? "positive" : "neutral";
-    return withQueryLists(
-      { gained: citedCount, lost: 0, tone: tone2, hasPreviousRun: false },
-      citedIds,
-      /* @__PURE__ */ new Set(),
-      options.queryLookup
-    );
-  }
-  const latestCited = collectCitedQueryIds(currentSnapshots);
-  const previousCited = collectCitedQueryIds(previousSnapshots);
-  const gainedIds = /* @__PURE__ */ new Set();
-  const lostIds = /* @__PURE__ */ new Set();
-  for (const id of latestCited) {
-    if (!previousCited.has(id)) gainedIds.add(id);
-  }
-  for (const id of previousCited) {
-    if (!latestCited.has(id)) lostIds.add(id);
-  }
-  const tone = lostIds.size > gainedIds.size ? "negative" : gainedIds.size > lostIds.size ? "positive" : "neutral";
-  return withQueryLists(
-    { gained: gainedIds.size, lost: lostIds.size, tone, hasPreviousRun: true },
-    gainedIds,
-    lostIds,
-    options.queryLookup
-  );
-}
-function withQueryLists(base, gainedIds, lostIds, lookup) {
-  if (!lookup) return base;
-  return {
-    ...base,
-    gainedQueries: resolveQueryTexts(gainedIds, lookup),
-    lostQueries: resolveQueryTexts(lostIds, lookup)
-  };
-}
-function resolveQueryTexts(ids, lookup) {
-  const out = [];
-  for (const id of ids) {
-    const text2 = lookup.get(id);
-    if (text2) out.push(text2);
-  }
-  return out.sort();
-}
-function collectCitedQueryIds(snapshots) {
-  const cited = /* @__PURE__ */ new Set();
-  for (const s of snapshots) {
-    if (s.citationState === CitationStates.cited && s.queryId) cited.add(s.queryId);
-  }
-  return cited;
-}
-
-// ../intelligence/src/score-tones.ts
-function scoreTone(score) {
-  if (score >= 70) return "positive";
-  if (score >= 40) return "caution";
-  return "negative";
-}
-function pressureTone(label) {
-  if (label === "High") return "negative";
-  if (label === "Moderate") return "caution";
-  return "neutral";
-}
-function gapTone(gapCount, totalCount) {
-  if (gapCount === 0) return "positive";
-  const ratio = totalCount > 0 ? gapCount / totalCount : 0;
-  if (ratio >= 0.3) return "negative";
-  return "caution";
-}
-
-// ../intelligence/src/visibility-score.ts
-function buildVisibilityScore(snapshots, options) {
-  const tooltip = "An LLM used a page on your domain as a source for its answer.";
-  if (snapshots.length === 0) {
-    return {
-      label: "Citation Coverage",
-      value: "No data",
-      delta: "Run a sweep first",
-      tone: "neutral",
-      description: "No citation data yet. Trigger a run to start tracking.",
-      tooltip,
-      trend: []
-    };
-  }
-  const queryCited = /* @__PURE__ */ new Map();
-  for (const snap of snapshots) {
-    if (!queryCited.has(snap.queryId)) queryCited.set(snap.queryId, false);
-    if (snap.citationState === CitationStates.cited) queryCited.set(snap.queryId, true);
-  }
-  const totalCount = queryCited.size;
-  const citedCount = [...queryCited.values()].filter(Boolean).length;
-  const score = totalCount > 0 ? Math.round(citedCount / totalCount * 100) : 0;
-  const runProviders = new Set(snapshots.map((s) => s.provider));
-  const runApiProviderCount = options.configuredApiProviders.filter((p) => runProviders.has(p)).length;
-  const isPartialProviderRun = options.configuredApiProviders.length > 1 && runApiProviderCount < options.configuredApiProviders.length;
-  return {
-    label: "Citation Coverage",
-    value: `${score}`,
-    delta: `${citedCount} of ${totalCount} queries cited`,
-    tone: isPartialProviderRun ? "caution" : scoreTone(score),
-    description: `${citedCount} of ${totalCount} tracked queries found your domain in at least one AI answer engine.`,
-    tooltip,
-    trend: [],
-    progress: score,
-    providerCoverage: isPartialProviderRun ? `${runApiProviderCount} of ${options.configuredApiProviders.length} providers` : void 0
-  };
-}
-
-// ../intelligence/src/mention-coverage.ts
-function buildMentionCoverage(snapshots, options) {
-  const tooltip = "Your domain or company name was in the answer returned by the LLM.";
-  if (snapshots.length === 0) {
-    return {
-      label: "Mention Coverage",
-      value: "No data",
-      delta: "Run a sweep first",
-      tone: "neutral",
-      description: "No mention data yet. Trigger a run to start tracking.",
-      tooltip,
-      trend: []
-    };
-  }
-  const queryMentioned = /* @__PURE__ */ new Map();
-  for (const snap of snapshots) {
-    if (!queryMentioned.has(snap.queryId)) queryMentioned.set(snap.queryId, false);
-    if (snap.answerMentioned === true) queryMentioned.set(snap.queryId, true);
-  }
-  const totalCount = queryMentioned.size;
-  const mentionedCount = [...queryMentioned.values()].filter(Boolean).length;
-  const score = totalCount > 0 ? Math.round(mentionedCount / totalCount * 100) : 0;
-  const runProviders = new Set(snapshots.map((s) => s.provider));
-  const runApiProviderCount = options.configuredApiProviders.filter((p) => runProviders.has(p)).length;
-  const isPartialProviderRun = options.configuredApiProviders.length > 1 && runApiProviderCount < options.configuredApiProviders.length;
-  return {
-    label: "Mention Coverage",
-    value: `${score}`,
-    delta: `${mentionedCount} of ${totalCount} queries mentioned`,
-    tone: isPartialProviderRun ? "caution" : scoreTone(score),
-    description: `${mentionedCount} of ${totalCount} tracked queries had your brand or domain in the AI answer text.`,
-    tooltip,
-    trend: [],
-    progress: score,
-    providerCoverage: isPartialProviderRun ? `${runApiProviderCount} of ${options.configuredApiProviders.length} providers` : void 0
-  };
-}
-
-// ../intelligence/src/gap-query-score.ts
-function buildGapQueryScore(snapshots) {
-  const tooltip = "Tracked queries where a competitor is cited in the latest run but your domain is not.";
-  if (snapshots.length === 0) {
-    return {
-      label: "Gap Queries",
-      value: "No data",
-      delta: "Run a sweep first",
-      tone: "neutral",
-      description: "Run a visibility sweep to identify queries where competitors are cited and your domain is not.",
-      tooltip,
-      trend: []
-    };
-  }
-  const byQuery = /* @__PURE__ */ new Map();
-  for (const snap of snapshots) {
-    const key = snap.queryId;
-    const current = byQuery.get(key) ?? { cited: false, competitorOverlap: /* @__PURE__ */ new Set() };
-    if (snap.citationState === CitationStates.cited) current.cited = true;
-    for (const domain of snap.competitorOverlap) current.competitorOverlap.add(domain);
-    byQuery.set(key, current);
-  }
-  const totalCount = byQuery.size;
-  const gapCount = [...byQuery.values()].filter(
-    (entry) => !entry.cited && entry.competitorOverlap.size > 0
-  ).length;
-  const gapQueryLabel = gapCount === 1 ? "query" : "queries";
-  return {
-    label: "Citation Gaps",
-    value: `${gapCount}`,
-    delta: `${gapCount} of ${totalCount} queries at risk`,
-    tone: gapTone(gapCount, totalCount),
-    description: gapCount > 0 ? `${gapCount} tracked ${gapQueryLabel} currently cite competitors without citing your domain.` : "No competitive citation gaps detected in the latest visibility run.",
-    tooltip,
-    trend: [],
-    progress: totalCount > 0 ? Math.round(gapCount / totalCount * 100) : 0
-  };
-}
-function buildMentionGapScore(snapshots) {
-  const tooltip = "Tracked queries where a competitor surfaces in the latest run but your brand / domain is not mentioned in the answer text.";
-  if (snapshots.length === 0) {
-    return {
-      label: "Mention Gaps",
-      value: "No data",
-      delta: "Run a sweep first",
-      tone: "neutral",
-      description: "Run a visibility sweep to identify queries where competitors are mentioned and your brand is not.",
-      tooltip,
-      trend: []
-    };
-  }
-  const byQuery = /* @__PURE__ */ new Map();
-  for (const snap of snapshots) {
-    const key = snap.queryId;
-    const current = byQuery.get(key) ?? { mentioned: false, competitorOverlap: /* @__PURE__ */ new Set() };
-    if (snap.answerMentioned === true) current.mentioned = true;
-    for (const domain of snap.competitorOverlap) current.competitorOverlap.add(domain);
-    byQuery.set(key, current);
-  }
-  const totalCount = byQuery.size;
-  const gapCount = [...byQuery.values()].filter(
-    (entry) => !entry.mentioned && entry.competitorOverlap.size > 0
-  ).length;
-  const gapQueryLabel = gapCount === 1 ? "query" : "queries";
-  return {
-    label: "Mention Gaps",
-    value: `${gapCount}`,
-    delta: `${gapCount} of ${totalCount} queries at risk`,
-    tone: gapTone(gapCount, totalCount),
-    description: gapCount > 0 ? `${gapCount} tracked ${gapQueryLabel} mention competitors but never your brand.` : "No competitive mention gaps detected in the latest visibility run.",
-    tooltip,
-    trend: [],
-    progress: totalCount > 0 ? Math.round(gapCount / totalCount * 100) : 0
-  };
-}
-
-// ../intelligence/src/competitor-pressure-score.ts
-function buildCompetitorPressureScore(snapshots, competitorDomains, totalTrackedCompetitors) {
-  const tooltip = "How often competitor domains appear alongside yours in AI answers. High pressure means competitors are frequently cited for the same queries.";
-  const description = totalTrackedCompetitors > 0 ? `${totalTrackedCompetitors} competitor${totalTrackedCompetitors > 1 ? "s" : ""} tracked.` : "No competitors configured.";
-  if (snapshots.length === 0 || competitorDomains.length === 0) {
-    return {
-      label: "Competitor Pressure",
-      value: "None",
-      delta: "No overlap detected",
-      tone: pressureTone("None"),
-      description,
-      tooltip,
-      trend: []
-    };
-  }
-  const competitorSet = new Set(competitorDomains);
-  let overlapCount = 0;
-  for (const snap of snapshots) {
-    if (snap.competitorOverlap.some((d) => competitorSet.has(d))) {
-      overlapCount++;
-    }
-  }
-  const ratio = overlapCount / snapshots.length;
-  const label = ratio >= 0.5 ? "High" : ratio >= 0.2 ? "Moderate" : overlapCount > 0 ? "Low" : "None";
-  return {
-    label: "Competitor Pressure",
-    value: label,
-    delta: overlapCount > 0 ? `${overlapCount} overlapping citations` : "No overlap detected",
-    tone: pressureTone(label),
-    description,
-    tooltip,
-    trend: []
-  };
-}
-function buildOverviewCompetitors(snapshots, competitors2, queryLookup) {
-  const uniqueQueries = /* @__PURE__ */ new Set();
-  for (const snap of snapshots) {
-    if (snap.queryId) uniqueQueries.add(snap.queryId);
-  }
-  const renderQuery = (queryId) => queryLookup?.byId.get(queryId) ?? queryId;
-  return competitors2.map((competitor, index2) => {
-    const citedQuerySet = /* @__PURE__ */ new Set();
-    for (const snap of snapshots) {
-      if (snap.competitorOverlap.includes(competitor.domain) || snap.citedDomains.includes(competitor.domain)) {
-        if (snap.queryId) citedQuerySet.add(snap.queryId);
-      }
-    }
-    const citedQueries = [...citedQuerySet].map(renderQuery).sort();
-    const ratio = uniqueQueries.size > 0 ? citedQuerySet.size / uniqueQueries.size : 0;
-    const pressureLabel = ratio >= 0.5 ? "High" : ratio >= 0.2 ? "Moderate" : citedQuerySet.size > 0 ? "Low" : "None";
-    return {
-      id: competitor.id || `comp_${index2}`,
-      domain: competitor.domain,
-      citationCount: citedQuerySet.size,
-      totalQueries: uniqueQueries.size,
-      pressureLabel,
-      citedQueries
-    };
-  });
-}
-
-// ../intelligence/src/provider-scores.ts
-function buildProviderScores(snapshots) {
-  const modelGroups = /* @__PURE__ */ new Map();
-  for (const snap of snapshots) {
-    const provider = snap.provider;
-    const model = snap.model ?? null;
-    const key = `${provider}::${model ?? "unknown"}`;
-    const group = modelGroups.get(key) ?? { provider, model, cited: 0, total: 0 };
-    group.total++;
-    if (snap.citationState === CitationStates.cited) group.cited++;
-    modelGroups.set(key, group);
-  }
-  return [...modelGroups.values()].sort(
-    (a, b) => a.provider.localeCompare(b.provider) || (a.model ?? "").localeCompare(b.model ?? "")
-  ).map(({ provider, model, cited, total }) => ({
-    provider,
-    model,
-    score: total > 0 ? Math.round(cited / total * 100) : 0,
-    cited,
-    total
-  }));
-}
-
-// ../intelligence/src/run-history.ts
-var DEFAULT_RUN_HISTORY_LIMIT = 12;
-function buildRunHistory(runs2, snapshotsByRunId, limit = DEFAULT_RUN_HISTORY_LIMIT) {
-  const recent = [...runs2].sort((a, b) => b.createdAt.localeCompare(a.createdAt)).slice(0, limit).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-  return recent.map((run) => {
-    const snapshots = snapshotsByRunId.get(run.id) ?? [];
-    const queryCited = /* @__PURE__ */ new Map();
-    for (const snap of snapshots) {
-      if (!queryCited.has(snap.queryId)) queryCited.set(snap.queryId, false);
-      if (snap.citationState === CitationStates.cited) queryCited.set(snap.queryId, true);
-    }
-    const totalCount = queryCited.size;
-    const citedCount = [...queryCited.values()].filter(Boolean).length;
-    const citationRate = totalCount > 0 ? Math.round(citedCount / totalCount * 100) : 0;
-    return {
-      runId: run.id,
-      createdAt: run.createdAt,
-      citedCount,
-      totalCount,
-      citationRate,
-      status: run.status
-    };
-  });
-}
-
-// ../intelligence/src/provider-trends.ts
-function buildProviderTrends(runs2, snapshotsByRunId, limit = 12) {
-  const recent = [...runs2].sort((a, b) => b.createdAt.localeCompare(a.createdAt)).slice(0, limit).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-  const keys = collectProviderKeys(snapshotsByRunId.values());
-  const result = /* @__PURE__ */ new Map();
-  for (const key of keys) result.set(key, []);
-  for (const run of recent) {
-    const snaps = snapshotsByRunId.get(run.id) ?? [];
-    const perKey = /* @__PURE__ */ new Map();
-    for (const snap of snaps) {
-      const key = providerKey(snap.provider, snap.model);
-      const queryMap = perKey.get(key) ?? /* @__PURE__ */ new Map();
-      if (!queryMap.has(snap.queryId)) queryMap.set(snap.queryId, false);
-      if (snap.citationState === CitationStates.cited) queryMap.set(snap.queryId, true);
-      perKey.set(key, queryMap);
-    }
-    for (const key of keys) {
-      const queryMap = perKey.get(key);
-      const rate = queryMap && queryMap.size > 0 ? Math.round([...queryMap.values()].filter(Boolean).length / queryMap.size * 100) : 0;
-      result.get(key).push({ rate, createdAt: run.createdAt });
-    }
-  }
-  return result;
-}
-function providerKey(provider, model) {
-  return `${provider}::${model ?? "unknown"}`;
-}
-function collectProviderKeys(perRun) {
-  const keys = /* @__PURE__ */ new Set();
-  for (const snaps of perRun) {
-    for (const snap of snaps) {
-      keys.add(providerKey(snap.provider, snap.model));
-    }
-  }
-  return keys;
-}
-
-// ../intelligence/src/mention-share.ts
-function buildMentionShare(snapshots, options) {
-  const tooltip = 'When AI answers your tracked queries and names a brand, the % of brand-name-drops that are you vs your tracked competitors. Cleaner than Citation Coverage for "am I winning the conversation".';
-  const emptyBreakdown = {
-    projectMentionSnapshots: 0,
-    competitorMentionSnapshots: 0,
-    perCompetitor: [],
-    snapshotsWithAnswerText: 0,
-    snapshotsTotal: snapshots.length
-  };
-  if (snapshots.length === 0) {
-    return {
-      label: "Mention Share",
-      value: "No data",
-      delta: "Run a sweep first",
-      tone: "neutral",
-      description: "No mention share data yet. Trigger a run to start tracking.",
-      tooltip,
-      trend: [],
-      breakdown: emptyBreakdown
-    };
-  }
-  if (options.competitors.length === 0) {
-    return {
-      label: "Mention Share",
-      value: "Add competitors",
-      delta: "No competitors configured",
-      tone: "neutral",
-      description: "Mention Share is a head-to-head competitive metric \u2014 add tracked competitors to compare brand mention rates.",
-      tooltip,
-      trend: [],
-      breakdown: emptyBreakdown
-    };
-  }
-  let projectMentionSnapshots = 0;
-  let snapshotsWithAnswerText = 0;
-  const competitorCounts = /* @__PURE__ */ new Map();
-  for (const c of options.competitors) competitorCounts.set(c.domain, 0);
-  for (const snap of snapshots) {
-    const text2 = snap.answerText ?? "";
-    if (text2.length === 0) continue;
-    snapshotsWithAnswerText++;
-    if (snap.projectMentioned) projectMentionSnapshots++;
-    const answerBrandKey = brandKeyFromText(text2);
-    for (const competitor of options.competitors) {
-      if (competitorMentioned(text2, answerBrandKey, competitor.brandTokens)) {
-        competitorCounts.set(competitor.domain, (competitorCounts.get(competitor.domain) ?? 0) + 1);
-      }
-    }
-  }
-  const competitorMentionSnapshots = [...competitorCounts.values()].reduce((a, b) => a + b, 0);
-  const denom = projectMentionSnapshots + competitorMentionSnapshots;
-  const score = denom > 0 ? Math.round(projectMentionSnapshots / denom * 100) : 0;
-  const perCompetitor = options.competitors.map((c) => ({
-    domain: c.domain,
-    mentionSnapshots: competitorCounts.get(c.domain) ?? 0,
-    shareOfCompetitiveTotal: competitorMentionSnapshots > 0 ? Math.round((competitorCounts.get(c.domain) ?? 0) / competitorMentionSnapshots * 1e3) / 10 : 0
-  })).filter((row) => row.mentionSnapshots > 0).sort((a, b) => b.mentionSnapshots - a.mentionSnapshots);
-  const breakdown = {
-    projectMentionSnapshots,
-    competitorMentionSnapshots,
-    perCompetitor,
-    snapshotsWithAnswerText,
-    snapshotsTotal: snapshots.length
-  };
-  const description = describe({
-    score,
-    projectMentionSnapshots,
-    competitorMentionSnapshots,
-    perCompetitor
-  });
-  return {
-    label: "Mention Share",
-    value: denom > 0 ? `${score}` : "0",
-    delta: denom > 0 ? `${projectMentionSnapshots} of ${denom} brand mentions` : "No brand mentions in this run",
-    tone: denom > 0 ? mentionShareTone(score) : "neutral",
-    description,
-    tooltip,
-    trend: [],
-    progress: denom > 0 ? score : 0,
-    breakdown
-  };
-}
-function mentionShareTone(score) {
-  if (score >= 50) return "positive";
-  if (score >= 25) return "caution";
-  return "negative";
-}
-function competitorMentioned(text2, answerBrandKey, brandTokens) {
-  for (const token of brandTokens) {
-    if (token.length < 3) continue;
-    const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    if (new RegExp(`\\b${escaped}\\b`, "i").test(text2)) return true;
-    const tokenBrandKey = brandKeyFromText(token);
-    if (tokenBrandKey.length >= 3 && answerBrandKey.includes(tokenBrandKey)) return true;
-  }
-  return false;
-}
-function describe(parts) {
-  const { score, projectMentionSnapshots, competitorMentionSnapshots, perCompetitor } = parts;
-  if (projectMentionSnapshots === 0 && competitorMentionSnapshots === 0) {
-    return "No brand mentions detected for you or your tracked competitors in this run.";
-  }
-  if (competitorMentionSnapshots === 0) {
-    return `${projectMentionSnapshots} brand mentions of you, zero competitor mentions \u2014 you own the conversation.`;
-  }
-  const top = perCompetitor[0];
-  if (!top) {
-    return `${score}% of brand mentions are you (${projectMentionSnapshots} of ${projectMentionSnapshots + competitorMentionSnapshots}).`;
-  }
-  return `${score}% of brand mentions are you. Top competitor: ${top.domain} (${top.mentionSnapshots} mentions).`;
-}
-
-// ../intelligence/src/suggested-queries.ts
-var DEFAULT_MIN_IMPRESSIONS = 10;
-var DEFAULT_LIMIT = 10;
-function buildSuggestedQueries(gscRows, options) {
-  const minImpressions = options.minImpressions ?? DEFAULT_MIN_IMPRESSIONS;
-  const limit = options.limit ?? DEFAULT_LIMIT;
-  const trackedSet = new Set(options.trackedQueries.map(normalizeQuery));
-  let skippedAlreadyTracked = 0;
-  const candidates = [];
-  for (const row of gscRows) {
-    if (row.impressions < minImpressions) continue;
-    const normalized = normalizeQuery(row.query);
-    if (normalized.length === 0) continue;
-    if (trackedSet.has(normalized)) {
-      skippedAlreadyTracked++;
-      continue;
-    }
-    candidates.push({
-      query: row.query,
-      impressions: row.impressions,
-      clicks: row.clicks,
-      avgPosition: row.avgPosition,
-      reason: buildReason(row)
-    });
-  }
-  candidates.sort((a, b) => b.impressions - a.impressions);
-  const rows = candidates.slice(0, limit);
-  return {
-    rows,
-    totalCandidates: candidates.length,
-    skippedAlreadyTracked
-  };
-}
-function normalizeQuery(value) {
-  return value.trim().toLowerCase();
-}
-function buildReason(row) {
-  const impressionsLabel = formatImpressions2(row.impressions);
-  if (row.avgPosition <= 10) {
-    return `${impressionsLabel} impressions \xB7 ranks #${Math.round(row.avgPosition)} on Google`;
-  }
-  if (row.avgPosition <= 20) {
-    return `${impressionsLabel} impressions \xB7 ranks #${Math.round(row.avgPosition)} \u2014 close to top 10`;
-  }
-  return `${impressionsLabel} impressions \xB7 ranks #${Math.round(row.avgPosition)}`;
-}
-function formatImpressions2(value) {
-  if (value >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
-  if (value >= 1e4) return `${Math.round(value / 1e3)}K`;
-  if (value >= 1e3) return `${(value / 1e3).toFixed(1)}K`;
-  return value.toString();
-}
-
-// ../intelligence/src/smoothed-delta.ts
-var SMOOTHED_RUN_DELTA_MAX_WINDOW = 3;
-function smoothedRunDelta(points, valueFn, maxWindow = SMOOTHED_RUN_DELTA_MAX_WINDOW) {
-  if (points.length < 2) return null;
-  const window = Math.min(maxWindow, Math.floor(points.length / 2));
-  const tail = points.slice(-window);
-  const prior = points.slice(-window * 2, -window);
-  const sum = (arr) => arr.reduce((s, p) => s + valueFn(p), 0);
-  const currentAvg = sum(tail) / tail.length;
-  const priorAvg = sum(prior) / prior.length;
-  return {
-    current: roundTo1Decimal(currentAvg),
-    prior: roundTo1Decimal(priorAvg),
-    deltaAbs: currentAvg - priorAvg,
-    window
-  };
-}
-function roundTo1Decimal(value) {
-  return Math.round(value * 10) / 10;
-}
-
-// src/intelligence-service.ts
-import crypto from "crypto";
-
-// src/logger.ts
-var IS_TTY = process.stdout.isTTY === true;
-function formatTTY(entry) {
-  const { ts, level, module, action, msg, ...ctx } = entry;
-  const time = ts.slice(11, 19);
-  const levelTag = level === "error" ? "\x1B[31mERR\x1B[0m" : level === "warn" ? "\x1B[33mWRN\x1B[0m" : "\x1B[36mINF\x1B[0m";
-  const ctxParts = Object.entries(ctx).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
-  const msgPart = msg ? ` ${msg}` : "";
-  const ctxPart = ctxParts ? ` ${ctxParts}` : "";
-  return `${time} ${levelTag} [${module}] ${action}${msgPart}${ctxPart}`;
-}
-function emit(entry) {
-  const stream = entry.level === "error" ? process.stderr : process.stdout;
-  if (IS_TTY) {
-    stream.write(formatTTY(entry) + "\n");
-  } else {
-    stream.write(JSON.stringify(entry) + "\n");
-  }
-}
-function createLogger(module) {
-  function log2(level, action, ctx) {
-    const entry = {
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      level,
-      module,
-      action,
-      ...ctx
-    };
-    emit(entry);
-  }
-  return {
-    info: (action, ctx) => log2("info", action, ctx),
-    warn: (action, ctx) => log2("warn", action, ctx),
-    error: (action, ctx) => log2("error", action, ctx)
-  };
-}
-
-// src/citation-utils.ts
-function domainMatches(domain, canonicalDomain) {
-  const normalized = normalizeProjectDomain(canonicalDomain);
-  const d = normalizeProjectDomain(domain);
-  return d === normalized || d.endsWith(`.${normalized}`);
-}
-function pickProjectCitedDomain(citedDomains, projectDomains) {
-  for (const cited of citedDomains) {
-    if (projectDomains.some((pd) => domainMatches(cited, pd))) return cited;
-  }
-  return void 0;
-}
-function determineCitationState(normalized, domains) {
-  for (const canonicalDomain of domains) {
-    const bareDomain = normalizeProjectDomain(canonicalDomain);
-    if (normalized.citedDomains.some((d) => domainMatches(d, bareDomain))) {
-      return "cited";
-    }
-    const lowerDomain = bareDomain.toLowerCase();
-    for (const source of normalized.groundingSources) {
-      try {
-        const uri = source.uri.toLowerCase();
-        if (lowerDomain.includes(".") && uri.includes(lowerDomain)) {
-          return "cited";
-        }
-      } catch {
-      }
-      if (source.title) {
-        const titleLower = source.title.toLowerCase().replace(/^www\./, "");
-        if (titleLower === lowerDomain || titleLower.endsWith(`.${lowerDomain}`)) {
-          return "cited";
-        }
-      }
-    }
-  }
-  return "not-cited";
-}
-function computeCompetitorOverlap(normalized, competitorDomains) {
-  const overlapSet = /* @__PURE__ */ new Set();
-  for (const d of normalized.citedDomains) {
-    for (const cd of competitorDomains) {
-      if (domainMatches(d, cd)) {
-        overlapSet.add(cd);
-      }
-    }
-  }
-  for (const source of normalized.groundingSources) {
-    const uri = source.uri.toLowerCase();
-    for (const cd of competitorDomains) {
-      if (uri.includes(cd.toLowerCase())) {
-        overlapSet.add(cd);
-      }
-    }
-  }
-  if (normalized.answerText) {
-    const lowerAnswer = normalized.answerText.toLowerCase();
-    for (const cd of competitorDomains) {
-      if (lowerAnswer.includes(cd.toLowerCase())) {
-        overlapSet.add(cd);
-      }
-      const brand = brandLabelFromDomain(cd);
-      if (brand.length >= 4 && new RegExp(`\\b${escapeRegExp(brand)}\\b`, "i").test(lowerAnswer)) {
-        overlapSet.add(cd);
-      }
-    }
-  }
-  return [...overlapSet];
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function extractRecommendedCompetitors(answerText, ownDomains, citedDomains, competitorDomains, ownBrandNames = []) {
-  if (!answerText || answerText.length < 20) return [];
-  const ownBrandKeys = new Set(
-    ownDomains.flatMap((domain) => collectBrandKeysFromDomain(domain))
-  );
-  for (const name of ownBrandNames) {
-    const key = brandKeyFromText(name);
-    if (key.length >= 4) ownBrandKeys.add(key);
-  }
-  const knownCompetitorKeys = new Set(
-    [...citedDomains, ...competitorDomains].flatMap((domain) => collectBrandKeysFromDomain(domain)).filter((key) => !ownBrandKeys.has(key))
-  );
-  if (knownCompetitorKeys.size === 0) return [];
-  const candidatePatterns = [
-    /^\s*(?:[-*]|\d+\.)\s+(?:\*\*)?([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50}?)(?:\*\*)?\s*[:\u2014\u2013-]/gm,
-    /\*\*([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50})\*\*/g,
-    /^#{1,4}\s+(?:\d+\.\s+)?(?:\*\*)?([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50}?)(?:\*\*)?$/gm,
-    /\[([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50})\]\(https?:\/\/[^\s)]+\)/g
-  ];
-  const genericKeys = /* @__PURE__ */ new Set([
-    "additional",
-    "best",
-    "benefits",
-    "bottomline",
-    "comparison",
-    "conclusion",
-    "directorylisting",
-    "example",
-    "expertise",
-    "features",
-    "finalthoughts",
-    "howitworks",
-    "important",
-    "keybenefits",
-    "keyfeatures",
-    "major",
-    "note",
-    "notable",
-    "option",
-    "other",
-    "overview",
-    "pricing",
-    "pros",
-    "reviews",
-    "step",
-    "summary",
-    "top",
-    "verdict",
-    "whattolookfor",
-    "whyitmatters",
-    "whyitstandsout",
-    "whywechoseit"
-  ]);
-  const seen = /* @__PURE__ */ new Map();
-  for (const pattern of candidatePatterns) {
-    let match;
-    while ((match = pattern.exec(answerText)) !== null) {
-      const candidate = cleanCandidateName(match[1] ?? "");
-      const candidateKey = brandKeyFromText(candidate);
-      if (!candidateKey) continue;
-      if (genericKeys.has(candidateKey)) continue;
-      if (candidate.split(/\s+/).length > 6) continue;
-      if (matchesBrandKey(candidateKey, ownBrandKeys)) continue;
-      if (!matchesBrandKey(candidateKey, knownCompetitorKeys)) continue;
-      if (!seen.has(candidateKey)) seen.set(candidateKey, candidate);
-    }
-  }
-  return [...seen.values()].slice(0, 10);
-}
-function cleanCandidateName(candidate) {
-  return candidate.replace(/^[\s"'`]+|[\s"'`.,:;!?]+$/g, "").replace(/\s+/g, " ").trim();
-}
-function collectBrandKeysFromDomain(domain) {
-  const reg = registrableDomain(domain);
-  if (!reg) {
-    const hostname = normalizeProjectDomain(domain).split("/")[0] ?? "";
-    const fallback = hostname.replace(/[^a-z0-9]/gi, "").toLowerCase();
-    return fallback.length >= 4 ? [fallback] : [];
-  }
-  const keys = /* @__PURE__ */ new Set();
-  const fullKey = reg.replace(/[^a-z0-9]/gi, "").toLowerCase();
-  if (fullKey.length >= 4) keys.add(fullKey);
-  const brand = brandLabelFromDomain(reg).replace(/[^a-z0-9]/gi, "").toLowerCase();
-  if (brand.length >= 4) keys.add(brand);
-  return [...keys];
-}
-function matchesBrandKey(candidateKey, brandKeys) {
-  for (const brandKey of brandKeys) {
-    if (candidateKey === brandKey) return true;
-    if (candidateKey.startsWith(brandKey) || candidateKey.endsWith(brandKey)) return true;
-    if (brandKey.startsWith(candidateKey) || brandKey.endsWith(candidateKey)) return true;
-  }
-  return false;
-}
-
-// src/intelligence-service.ts
-var RECURRENCE_LOOKBACK_RUNS = 5;
-var HISTORY_WINDOW_RUNS = Math.max(PERSISTENT_GAP_THRESHOLD, 5);
-var log = createLogger("IntelligenceService");
-var IntelligenceService = class {
-  constructor(db) {
-    this.db = db;
-  }
-  /**
-   * Analyze a completed run and persist insights + health snapshot.
-   * Idempotent: deletes prior results for the same runId before inserting.
-   * Returns the analysis result for the coordinator to inspect (e.g. for webhook dispatch).
-   */
-  analyzeAndPersist(runId, projectId) {
-    const recentRuns = this.db.select().from(runs).where(
-      and(
-        eq(runs.projectId, projectId),
-        or(eq(runs.status, "completed"), eq(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
-        // intelligence window.
-        ne(runs.trigger, RunTriggers.probe)
-      )
-    ).orderBy(desc(runs.finishedAt), desc(runs.createdAt)).limit(HISTORY_WINDOW_RUNS).all();
-    if (recentRuns.length === 0) {
-      log.info("intelligence.skip", { runId, reason: "no completed runs" });
-      return null;
-    }
-    const currentRunRecord = recentRuns.find((r) => r.id === runId);
-    if (!currentRunRecord) {
-      log.info("intelligence.skip", { runId, reason: "run not in recent completed list" });
-      return null;
-    }
-    const currentRun = this.buildRunData(
-      runId,
-      projectId,
-      currentRunRecord.finishedAt ?? currentRunRecord.createdAt,
-      currentRunRecord.location ?? null
-    );
-    if (currentRun.snapshots.length === 0) {
-      log.info("intelligence.skip", { runId, reason: "no snapshots" });
-      return null;
-    }
-    const orderedRecent = [...recentRuns].reverse();
-    const currentLocation = currentRunRecord.location ?? null;
-    const sameLocationOrdered = orderedRecent.filter((r) => (r.location ?? null) === currentLocation);
-    const currentLocIdx = sameLocationOrdered.findIndex((r) => r.id === runId);
-    const previousRunRecord = currentLocIdx > 0 ? sameLocationOrdered[currentLocIdx - 1] : null;
-    const previousRun = previousRunRecord ? this.buildRunData(
-      previousRunRecord.id,
-      projectId,
-      previousRunRecord.finishedAt ?? previousRunRecord.createdAt,
-      previousRunRecord.location ?? null
-    ) : null;
-    const trackedCompetitors = this.loadTrackedCompetitors(projectId);
-    const history = sameLocationOrdered.slice(0, currentLocIdx + 1).map((r) => r.id === runId ? currentRun : this.buildRunData(r.id, projectId, r.finishedAt ?? r.createdAt, r.location ?? null));
-    if (!previousRun) {
-      const result2 = analyzeRuns(currentRun, currentRun, { trackedCompetitors, history });
-      log.info("intelligence.analyzed", {
-        runId,
-        regressions: 0,
-        gains: 0,
-        citedRate: result2.health.overallCitedRate,
-        insights: 0
-      });
-      this.persistResult(this.emptyAnalysisResult(result2), runId, projectId);
-      return result2;
-    }
-    const result = analyzeRuns(currentRun, previousRun, { trackedCompetitors, history });
-    log.info("intelligence.analyzed", {
-      runId,
-      regressions: result.regressions.length,
-      gains: result.gains.length,
-      firstCitations: result.firstCitations.length,
-      providerPickups: result.providerPickups.length,
-      persistentGaps: result.persistentGaps.length,
-      competitorGains: result.competitorGains.length,
-      competitorLosses: result.competitorLosses.length,
-      citedRate: result.health.overallCitedRate,
-      insights: result.insights.length
-    });
-    const tieredResult = this.tierResult(result, runId, projectId);
-    this.persistResult(tieredResult, runId, projectId);
-    return tieredResult;
-  }
-  /**
-   * Analyze a single run given an explicit previous run (or null for first run).
-   * Used by backfill where we control the run ordering.
-   *
-   * `dryRun: true` skips the DB write — `persistResult` is not called and
-   * dismissed flags / health rows are untouched. Callers receive the same
-   * AnalysisResult they would have, suitable for previewing what a write
-   * would have produced.
-   */
-  analyzeRunWithPrevious(runRecord, previousRunRecord, historyRecords, opts) {
-    const currentRun = this.buildRunData(
-      runRecord.id,
-      runRecord.projectId,
-      runRecord.finishedAt ?? runRecord.createdAt,
-      runRecord.location ?? null
-    );
-    if (currentRun.snapshots.length === 0) {
-      return null;
-    }
-    const previousRun = previousRunRecord ? this.buildRunData(
-      previousRunRecord.id,
-      previousRunRecord.projectId,
-      previousRunRecord.finishedAt ?? previousRunRecord.createdAt,
-      previousRunRecord.location ?? null
-    ) : null;
-    const trackedCompetitors = this.loadTrackedCompetitors(runRecord.projectId);
-    const history = (historyRecords ?? []).map((r) => r.id === runRecord.id ? currentRun : this.buildRunData(r.id, r.projectId, r.finishedAt ?? r.createdAt, r.location ?? null));
-    if (!previousRun) {
-      const result2 = analyzeRuns(currentRun, currentRun, { trackedCompetitors, history });
-      const emptyResult = this.emptyAnalysisResult(result2);
-      if (!opts?.dryRun) this.persistResult(emptyResult, runRecord.id, runRecord.projectId);
-      return result2;
-    }
-    const result = analyzeRuns(currentRun, previousRun, { trackedCompetitors, history });
-    const tieredResult = this.tierResult(result, runRecord.id, runRecord.projectId);
-    if (!opts?.dryRun) this.persistResult(tieredResult, runRecord.id, runRecord.projectId);
-    return tieredResult;
-  }
-  /**
-   * Backfill intelligence for all completed/partial runs of a project.
-   * Processes runs in chronological order so each run compares against its predecessor.
-   *
-   * Scoping options:
-   *   - `fromRunId` / `toRunId`: bound the target range by exact run ID.
-   *   - `since`: bound the target range by `finishedAt >= <date>`. Accepts
-   *     any string that `Date.parse` understands (ISO 8601, `YYYY-MM-DD`,
-   *     etc.). Runs before the cutoff are *not* re-processed but stay
-   *     available for predecessor lookup, so transition detection at the
-   *     boundary stays correct. Composes with `fromRunId` / `toRunId` —
-   *     all three filters intersect.
-   *   - `dryRun`: compute the analysis without writing. The return value
-   *     includes a `delta` describing what would change (rows to delete vs
-   *     create per run + aggregate). DB is left untouched.
-   */
-  backfill(projectName, opts, onProgress) {
-    const project = this.db.select().from(projects).where(eq(projects.name, projectName)).get();
-    if (!project) {
-      throw new Error(`Project "${projectName}" not found`);
-    }
-    let sinceTimestamp = null;
-    if (opts?.since !== void 0) {
-      const parsed = Date.parse(opts.since);
-      if (Number.isNaN(parsed)) {
-        throw new Error(`Invalid --since value "${opts.since}": expected a parseable date (ISO 8601 or YYYY-MM-DD)`);
-      }
-      sinceTimestamp = parsed;
-    }
-    const allRuns = this.db.select().from(runs).where(
-      and(
-        eq(runs.projectId, project.id),
-        or(eq(runs.status, "completed"), eq(runs.status, "partial")),
-        // Backfill must not replay probe runs as if they were real sweeps.
-        ne(runs.trigger, RunTriggers.probe)
-      )
-    ).orderBy(asc(runs.finishedAt)).all();
-    let startIdx = 0;
-    let endIdx = allRuns.length;
-    if (opts?.fromRunId) {
-      const idx = allRuns.findIndex((r) => r.id === opts.fromRunId);
-      if (idx === -1) throw new Error(`Run "${opts.fromRunId}" not found in project`);
-      startIdx = idx;
-    }
-    if (opts?.toRunId) {
-      const idx = allRuns.findIndex((r) => r.id === opts.toRunId);
-      if (idx === -1) throw new Error(`Run "${opts.toRunId}" not found in project`);
-      endIdx = idx + 1;
-    }
-    let targetRuns = allRuns.slice(startIdx, endIdx);
-    if (sinceTimestamp !== null) {
-      targetRuns = targetRuns.filter((r) => {
-        const ts = r.finishedAt ?? r.createdAt;
-        const t = Date.parse(ts);
-        return !Number.isNaN(t) && t >= sinceTimestamp;
-      });
-    }
-    let processed = 0;
-    let skipped = 0;
-    let totalInsights = 0;
-    const isDryRun = opts?.dryRun === true;
-    const perRunDelta = [];
-    let wouldDeleteTotal = 0;
-    const existingByRunId = /* @__PURE__ */ new Map();
-    if (isDryRun && targetRuns.length > 0) {
-      const rows = this.db.select({ runId: insights.runId }).from(insights).where(inArray(insights.runId, targetRuns.map((r) => r.id))).all();
-      for (const r of rows) {
-        if (r.runId == null) continue;
-        existingByRunId.set(r.runId, (existingByRunId.get(r.runId) ?? 0) + 1);
-      }
-    }
-    for (let i = 0; i < targetRuns.length; i++) {
-      const run = targetRuns[i];
-      const runLocation = run.location ?? null;
-      const sameLocationRuns = allRuns.filter((r) => (r.location ?? null) === runLocation);
-      const sameLocIdx = sameLocationRuns.indexOf(run);
-      const previousRun = sameLocIdx > 0 ? sameLocationRuns[sameLocIdx - 1] : null;
-      const historyStart = Math.max(0, sameLocIdx - (HISTORY_WINDOW_RUNS - 1));
-      const historyRecords = sameLocationRuns.slice(historyStart, sameLocIdx + 1);
-      const result = this.analyzeRunWithPrevious(run, previousRun, historyRecords, { dryRun: isDryRun });
-      if (result) {
-        processed++;
-        totalInsights += result.insights.length;
-        if (isDryRun) {
-          const existing = existingByRunId.get(run.id) ?? 0;
-          wouldDeleteTotal += existing;
-          perRunDelta.push({ runId: run.id, existingInsights: existing, newInsights: result.insights.length });
-        }
-        onProgress?.({ runId: run.id, index: i + 1, total: targetRuns.length, insights: result.insights.length });
-      } else {
-        skipped++;
-        onProgress?.({ runId: run.id, index: i + 1, total: targetRuns.length, insights: 0 });
-      }
-    }
-    if (isDryRun) {
-      return {
-        processed,
-        skipped,
-        totalInsights,
-        dryRun: true,
-        delta: {
-          wouldDelete: wouldDeleteTotal,
-          wouldCreate: totalInsights,
-          netChange: totalInsights - wouldDeleteTotal,
-          perRun: perRunDelta
-        }
-      };
-    }
-    return { processed, skipped, totalInsights };
-  }
-  loadTrackedCompetitors(projectId) {
-    return this.db.select({ domain: competitors.domain }).from(competitors).where(eq(competitors.projectId, projectId)).all().map((r) => r.domain);
-  }
-  /**
-   * Wipe transition signals from an analysis result while keeping health.
-   * Used when there's no baseline (first run) to avoid emitting false transitions.
-   */
-  emptyAnalysisResult(result) {
-    return {
-      ...result,
-      insights: [],
-      regressions: [],
-      gains: [],
-      firstCitations: [],
-      providerPickups: [],
-      persistentGaps: [],
-      competitorGains: [],
-      competitorLosses: []
-    };
-  }
-  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(eq(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(eq(insights.runId, runId)).run();
-      tx.delete(healthSnapshots).where(eq(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}`);
-        tx.insert(insights).values({
-          id: insight.id,
-          projectId,
-          runId,
-          type: insight.type,
-          severity: insight.severity,
-          title: insight.title,
-          query: insight.query,
-          provider: insight.provider,
-          recommendation: insight.recommendation ?? null,
-          cause: insight.cause ?? null,
-          dismissed: wasDismissed,
-          createdAt: insight.createdAt
-        }).run();
-      }
-      tx.insert(healthSnapshots).values({
-        id: crypto.randomUUID(),
-        projectId,
-        runId,
-        overallCitedRate: String(result.health.overallCitedRate),
-        totalPairs: result.health.totalPairs,
-        citedPairs: result.health.citedPairs,
-        providerBreakdown: result.health.providerBreakdown,
-        createdAt: now
-      }).run();
-    });
-    log.info("intelligence.persisted", { runId, insights: result.insights.length });
-  }
-  /**
-   * Apply severity tiering to the insights of an AnalysisResult and return a
-   * new result. Wraps `applySeverityTiering` so callers (analyzeAndPersist,
-   * analyzeRunWithPrevious) can pass the same tiered shape both into the DB
-   * write and back to the RunCoordinator / webhook dispatcher.
-   */
-  tierResult(result, runId, projectId) {
-    if (result.insights.length === 0) return result;
-    return { ...result, insights: this.applySeverityTiering(result.insights, runId, projectId) };
-  }
-  /**
-   * Re-classify each regression insight's severity using GSC traffic +
-   * recurrence signals via the pure `classifyRegressionSeverity` primitive
-   * in @ainyc/canonry-intelligence. Non-regression insights are returned
-   * untouched.
-   */
-  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(eq(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(eq(projects.id, projectId)).get();
-    const locationCount = Math.max(
-      1,
-      (projectRow?.locations ?? []).length
-    );
-    const ROWS_PER_GROUP_BUDGET = Math.max(2, locationCount);
-    const recentRunRows = this.db.select({ id: runs.id, createdAt: runs.createdAt }).from(runs).where(
-      and(
-        eq(runs.projectId, projectId),
-        eq(runs.kind, RunKinds["answer-visibility"]),
-        or(eq(runs.status, "completed"), eq(runs.status, "partial")),
-        // Defensive — see top of file.
-        ne(runs.trigger, RunTriggers.probe)
-      )
-    ).orderBy(desc(runs.createdAt), desc(runs.id)).limit((RECURRENCE_LOOKBACK_RUNS + 1) * ROWS_PER_GROUP_BUDGET).all();
-    const recentGroups = groupRunsByCreatedAt(recentRunRows);
-    const recentRunIds = [];
-    const recentRunIdToCreatedAt = /* @__PURE__ */ new Map();
-    let consumedGroups = 0;
-    for (const group of recentGroups) {
-      const groupIds = group.map((r) => r.id);
-      if (groupIds.includes(excludeRunId)) continue;
-      for (const r of group) recentRunIdToCreatedAt.set(r.id, r.createdAt);
-      recentRunIds.push(...groupIds);
-      consumedGroups++;
-      if (consumedGroups >= RECURRENCE_LOOKBACK_RUNS) break;
-    }
-    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(and(eq(insights.type, "regression"), inArray(insights.runId, recentRunIds))).all();
-      const regressionGroups = /* @__PURE__ */ new Map();
-      for (const row of priorRows) {
-        if (!row.runId) continue;
-        const key = `${row.query}:${row.provider}`;
-        const groupKey = recentRunIdToCreatedAt.get(row.runId) ?? row.runId;
-        let groups = regressionGroups.get(key);
-        if (!groups) {
-          groups = /* @__PURE__ */ new Set();
-          regressionGroups.set(key, groups);
-        }
-        groups.add(groupKey);
-      }
-      for (const [key, groups] of regressionGroups) {
-        priorRegressionsByPair.set(key, groups.size);
-      }
-    }
-    return rawInsights.map((insight) => {
-      if (insight.type !== "regression") return insight;
-      const gscImpressions = gscConnected ? gscImpressionsByQuery.get(insight.query.toLowerCase()) ?? 0 : void 0;
-      const recurrenceCount = haveHistory ? priorRegressionsByPair.get(`${insight.query}:${insight.provider}`) ?? 0 : void 0;
-      const severity = classifyRegressionSeverity({
-        gscImpressions,
-        recurrenceCount
-      });
-      return { ...insight, severity };
-    });
-  }
-  buildRunData(runId, projectId, completedAt, location = null) {
-    const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq(projects.id, projectId)).get();
-    const projectDomains = projectDomainRow ? effectiveDomains({
-      canonicalDomain: projectDomainRow.canonicalDomain,
-      ownedDomains: projectDomainRow.ownedDomains
-    }) : [];
-    const rows = this.db.select({
-      query: queries.query,
-      // Denormalized query text persisted by v58 — the fallback when the
-      // joined queries.query has been hard-deleted (or the query_id was
-      // nulled by the v58 dangling-FK cleanup).
-      queryText: querySnapshots.queryText,
-      provider: querySnapshots.provider,
-      citationState: querySnapshots.citationState,
-      citedDomains: querySnapshots.citedDomains,
-      competitorOverlap: querySnapshots.competitorOverlap,
-      snapshotLocation: querySnapshots.location
-    }).from(querySnapshots).leftJoin(queries, eq(querySnapshots.queryId, queries.id)).where(eq(querySnapshots.runId, runId)).all();
-    const snapshots = [];
-    let orphanCount = 0;
-    for (const r of rows) {
-      const resolvedQuery = r.query ?? r.queryText ?? null;
-      if (!resolvedQuery) {
-        orphanCount++;
-        continue;
-      }
-      const domains = r.citedDomains;
-      const competitors2 = r.competitorOverlap;
-      snapshots.push({
-        query: resolvedQuery,
-        provider: r.provider,
-        cited: r.citationState === CitationStates.cited,
-        // The project's OWN cited domain — never a co-cited competitor that
-        // happens to sort first in the full citedDomains set.
-        citationUrl: pickProjectCitedDomain(domains, projectDomains),
-        // Snapshots carry their own location for downstream detectors. In
-        // practice every snapshot in a single runId shares the run's
-        // location; the per-row column is the same value duplicated, but
-        // we read it from the snapshot row so a stale runs.location can't
-        // mask snapshot truth.
-        location: r.snapshotLocation ?? location ?? null,
-        competitorDomains: competitors2,
-        // citedDomains is the FULL set (tracked competitors + third-party
-        // sources). Cause analysis uses it to name the displacing source
-        // when no tracked competitor appears in the response.
-        citedDomains: domains
-      });
-    }
-    if (orphanCount > 0) {
-      log.warn("snapshot.orphan-skip", { runId, projectId, orphanCount });
-    }
-    return { runId, projectId, completedAt, location, snapshots };
-  }
-};
-
-export {
-  projects,
-  queries,
-  competitors,
-  runs,
-  querySnapshots,
-  auditLog,
-  apiKeys,
-  schedules,
-  notifications,
-  gscSearchData,
-  gscUrlInspections,
-  gscCoverageSnapshots,
-  bingCoverageSnapshots,
-  bingUrlInspections,
-  gaTrafficSnapshots,
-  gaAiReferrals,
-  gaSocialReferrals,
-  gaTrafficSummaries,
-  gaTrafficWindowSummaries,
-  usageCounters,
-  insights,
-  healthSnapshots,
-  agentSessions,
-  ccReleaseSyncs,
-  backlinkDomains,
-  backlinkSummaries,
-  agentMemory,
-  trafficSources,
-  crawlerEventsHourly,
-  aiUserFetchEventsHourly,
-  aiReferralEventsHourly,
-  rawEventSamples,
-  discoverySessions,
-  discoveryProbes,
-  contentTargetDismissals,
-  recommendationExplanations,
-  createClient,
-  parseJsonColumn,
-  extractLegacyCredentials,
-  dropLegacyCredentialColumns,
-  migrate,
-  groupRunsByCreatedAt,
-  pickGroupRepresentative,
-  filterTrackedSnapshots,
-  determineCitationState,
-  computeCompetitorOverlap,
-  extractRecommendedCompetitors,
-  isBlogShapedQuery,
-  buildInventory,
-  buildContentTargetRows,
-  buildContentSourceRows,
-  buildContentGapRows,
-  mapOpportunitiesToNextSteps,
-  groupInsights,
-  buildBrandTokens,
-  categorizeQueryByIntent,
-  MIN_TREND_POINTS,
-  isTrendBaseline,
-  buildCitationScorecard,
-  buildCompetitorLandscape,
-  buildMentionLandscape,
-  buildAiSourceOrigin,
-  buildMovementSummary,
-  buildVisibilityScore,
-  buildMentionCoverage,
-  buildGapQueryScore,
-  buildMentionGapScore,
-  buildCompetitorPressureScore,
-  buildOverviewCompetitors,
-  buildProviderScores,
-  DEFAULT_RUN_HISTORY_LIMIT,
-  buildRunHistory,
-  buildProviderTrends,
-  providerKey,
-  buildMentionShare,
-  buildSuggestedQueries,
-  smoothedRunDelta,
-  createLogger,
-  IntelligenceService
-};