@ainyc/canonry 1.39.4 → 1.40.0

package/dist/{chunk-H6FO4LHC.js → chunk-FXHVGU5S.js}

@@ -1,8 +1,27 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  IntelligenceService,
+  apiKeys,
+  auditLog,
+  bingUrlInspections,
+  competitors,
+  createLogger,
+  gaAiReferrals,
+  gaTrafficSnapshots,
+  gaTrafficSummaries,
+  gscCoverageSnapshots,
+  gscSearchData,
+  gscUrlInspections,
+  healthSnapshots,
+  insights,
+  keywords,
+  notifications,
+  parseJsonColumn,
+  projects,
+  querySnapshots,
+  runs,
+  schedules,
+  usageCounters
+} from "./chunk-FOWWBLXD.js";
 
 // src/config.ts
 import fs from "fs";
@@ -243,11 +262,11 @@ function trackEvent(event, properties) {
 
 // src/server.ts
 import { createRequire as createRequire2 } from "module";
-import crypto23 from "crypto";
+import crypto22 from "crypto";
 import fs5 from "fs";
 import path6 from "path";
 import { fileURLToPath } from "url";
-import { eq as eq24 } from "drizzle-orm";
+import { eq as eq23 } from "drizzle-orm";
 import Fastify from "fastify";
 
 // ../contracts/src/config-schema.ts
@@ -260,6 +279,14 @@ var providerQuotaPolicySchema = z.object({
   maxRequestsPerMinute: z.number().int().positive(),
   maxRequestsPerDay: z.number().int().positive()
 });
+var ProviderNames = {
+  gemini: "gemini",
+  openai: "openai",
+  claude: "claude",
+  perplexity: "perplexity",
+  local: "local",
+  cdpChatgpt: "cdp:chatgpt"
+};
 var providerNameSchema = z.string().min(1);
 var apiProviderNameSchema = z.string().min(1);
 function isBrowserProvider(name) {
@@ -1206,783 +1233,6 @@ function escapeRegExp(value) {
 // ../api-routes/src/auth.ts
 import crypto2 from "crypto";
 import { eq } 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, {
-  apiKeys: () => apiKeys,
-  auditLog: () => auditLog,
-  bingConnections: () => bingConnections,
-  bingKeywordStats: () => bingKeywordStats,
-  bingUrlInspections: () => bingUrlInspections,
-  competitors: () => competitors,
-  gaAiReferrals: () => gaAiReferrals,
-  gaConnections: () => gaConnections,
-  gaTrafficSnapshots: () => gaTrafficSnapshots,
-  gaTrafficSummaries: () => gaTrafficSummaries,
-  googleConnections: () => googleConnections,
-  gscCoverageSnapshots: () => gscCoverageSnapshots,
-  gscSearchData: () => gscSearchData,
-  gscUrlInspections: () => gscUrlInspections,
-  healthSnapshots: () => healthSnapshots,
-  insights: () => insights,
-  keywords: () => keywords,
-  notifications: () => notifications,
-  projects: () => projects,
-  querySnapshots: () => querySnapshots,
-  runs: () => runs,
-  schedules: () => schedules,
-  usageCounters: () => usageCounters
-});
-import { index, integer, 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").notNull().default("[]"),
-  country: text("country").notNull(),
-  language: text("language").notNull(),
-  tags: text("tags").notNull().default("[]"),
-  labels: text("labels").notNull().default("{}"),
-  providers: text("providers").notNull().default("[]"),
-  locations: text("locations").notNull().default("[]"),
-  defaultLocation: text("default_location"),
-  configSource: text("config_source").notNull().default("cli"),
-  configRevision: integer("config_revision").notNull().default(1),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-});
-var keywords = sqliteTable("keywords", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  keyword: text("keyword").notNull(),
-  createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_keywords_project").on(table.projectId),
-  uniqueIndex("idx_keywords_project_keyword").on(table.projectId, table.keyword)
-]);
-var competitors = sqliteTable("competitors", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  domain: text("domain").notNull(),
-  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"),
-  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)
-]);
-var querySnapshots = sqliteTable("query_snapshots", {
-  id: text("id").primaryKey(),
-  runId: text("run_id").notNull().references(() => runs.id, { onDelete: "cascade" }),
-  keywordId: text("keyword_id").notNull().references(() => keywords.id, { onDelete: "cascade" }),
-  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").notNull().default("[]"),
-  competitorOverlap: text("competitor_overlap").notNull().default("[]"),
-  recommendedCompetitors: text("recommended_competitors").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_keyword").on(table.keywordId)
-]);
-var auditLog = sqliteTable("audit_log", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id").references(() => projects.id, { onDelete: "cascade" }),
-  actor: text("actor").notNull(),
-  action: text("action").notNull(),
-  entityType: text("entity_type").notNull(),
-  entityId: text("entity_id"),
-  diff: text("diff"),
-  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").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" }),
-  cronExpr: text("cron_expr").notNull(),
-  preset: text("preset"),
-  timezone: text("timezone").notNull().default("UTC"),
-  enabled: integer("enabled").notNull().default(1),
-  providers: text("providers").notNull().default("[]"),
-  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").on(table.projectId)
-]);
-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").notNull(),
-  webhookSecret: text("webhook_secret"),
-  enabled: integer("enabled").notNull().default(1),
-  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"),
-  // WARNING: Authentication material should be stored in config.yaml per CLAUDE.md
-  accessToken: text("access_token"),
-  refreshToken: text("refresh_token"),
-  tokenExpiresAt: text("token_expires_at"),
-  scopes: text("scopes").notNull().default("[]"),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  uniqueIndex("idx_google_conn_domain_type").on(table.domain, table.connectionType)
-]);
-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"),
-  richResults: text("rich_results").notNull().default("[]"),
-  referringUrls: text("referring_urls").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").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 bingConnections = sqliteTable("bing_connections", {
-  id: text("id").primaryKey(),
-  domain: text("domain").notNull(),
-  siteUrl: text("site_url"),
-  createdAt: text("created_at").notNull(),
-  updatedAt: text("updated_at").notNull()
-}, (table) => [
-  uniqueIndex("idx_bing_conn_domain").on(table.domain)
-]);
-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"),
-  lastCrawledDate: text("last_crawled_date"),
-  inIndexDate: text("in_index_date"),
-  inspectedAt: text("inspected_at").notNull(),
-  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)
-]);
-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(),
-  // WARNING: Authentication material should be stored in config.yaml per CLAUDE.md
-  privateKey: text("private_key").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(),
-  sessions: integer("sessions").notNull().default(0),
-  organicSessions: integer("organic_sessions").notNull().default(0),
-  users: integer("users").notNull().default(0),
-  syncedAt: text("synced_at").notNull()
-}, (table) => [
-  index("idx_ga_traffic_project_date").on(table.projectId, table.date),
-  index("idx_ga_traffic_page").on(table.landingPage)
-]);
-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"),
-  sessions: integer("sessions").notNull().default(0),
-  users: integer("users").notNull().default(0),
-  syncedAt: text("synced_at").notNull()
-}, (table) => [
-  index("idx_ga_ai_ref_project_date").on(table.projectId, table.date),
-  index("idx_ga_ai_ref_source").on(table.source),
-  uniqueIndex("idx_ga_ai_ref_unique_v2").on(table.projectId, table.date, table.source, table.medium, table.sourceDimension)
-]);
-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()
-}, (table) => [
-  index("idx_ga_summary_project").on(table.projectId)
-]);
-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(),
-  keyword: text("keyword").notNull(),
-  provider: text("provider").notNull(),
-  recommendation: text("recommendation"),
-  cause: text("cause"),
-  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_keyword_provider").on(table.keyword, 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").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)
-]);
-
-// ../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 keywords (
-  id          TEXT PRIMARY KEY,
-  project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  keyword     TEXT NOT NULL,
-  created_at  TEXT NOT NULL,
-  UNIQUE(project_id, keyword)
-);
-
-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,
-  keyword_id          TEXT NOT NULL REFERENCES keywords(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_keywords_project ON keywords(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_keyword ON query_snapshots(keyword_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);
-CREATE UNIQUE INDEX IF NOT EXISTS idx_schedules_project ON schedules(project_id);
-CREATE INDEX IF NOT EXISTS idx_notifications_project ON notifications(project_id);
-`;
-var MIGRATIONS = [
-  // v2: Add providers column to projects for multi-provider support
-  `ALTER TABLE projects ADD COLUMN providers TEXT NOT NULL DEFAULT '[]'`,
-  // v3: Add webhook_secret column to notifications for HMAC signing
-  `ALTER TABLE notifications ADD COLUMN webhook_secret TEXT`,
-  // v4: Add owned_domains column to projects for multi-domain citation matching
-  `ALTER TABLE projects ADD COLUMN owned_domains TEXT NOT NULL DEFAULT '[]'`,
-  // v5: Add model column to query_snapshots for per-model scoring
-  `ALTER TABLE query_snapshots ADD COLUMN model TEXT`,
-  // v5b: Backfill model from rawResponse JSON for existing snapshots
-  `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`,
-  // v6: Google Search Console integration — google_connections table (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)`,
-  // v6: Google Search Console integration — gsc_search_data table
-  `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)`,
-  // v6: Google Search Console integration — gsc_url_inspections table
-  `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)`,
-  // v7: GSC coverage snapshots for historical tracking
-  `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)`,
-  // v8: Location-aware sweeps — project locations + snapshot location tag
-  `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`,
-  // v9: Add location column to runs for per-location run tracking
-  `ALTER TABLE runs ADD COLUMN location TEXT`,
-  // v10: Add sitemapUrl to google_connections for persistent sitemap storage
-  `ALTER TABLE google_connections ADD COLUMN sitemap_url TEXT`,
-  // v11: CDP browser provider — screenshot path for captured evidence
-  `ALTER TABLE query_snapshots ADD COLUMN screenshot_path TEXT`,
-  // v12: Bing Webmaster Tools — bing_connections table
-  `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)`,
-  // v12: Bing Webmaster Tools — bing_url_inspections table
-  `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)`,
-  // v12: Bing Webmaster Tools — bing_keyword_stats table
-  `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)`,
-  // v13: Google Analytics 4 — ga_connections table (service account auth)
-  // 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)`,
-  // v13: Google Analytics 4 — ga_traffic_snapshots table
-  `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)`,
-  // v14: GA4 aggregate summaries — stores true unique user count per sync period
-  `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)`,
-  // v15: Bing URL inspections — document_size, anchor_count, discovery_date columns
-  `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`,
-  // v16: Recommended competitor names extracted from run answers
-  `ALTER TABLE query_snapshots ADD COLUMN recommended_competitors TEXT NOT NULL DEFAULT '[]'`,
-  // v17: GA4 AI referral tracking — ga_ai_referrals table
-  `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)`,
-  `CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_ai_ref_unique ON ga_ai_referrals(project_id, date, source, medium)`,
-  // v18: Answer-level visibility derived from answer text
-  `ALTER TABLE query_snapshots ADD COLUMN answer_mentioned INTEGER`,
-  // v19: Add named unique indexes and missing columns from early tables
-  `CREATE UNIQUE INDEX IF NOT EXISTS idx_keywords_project_keyword ON keywords(project_id, keyword)`,
-  `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`,
-  // v20: Track which GA4 dimension produced each AI referral row
-  // 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'`,
-  // Replace old unique index with one that includes source_dimension
-  `DROP INDEX IF EXISTS idx_ga_ai_ref_unique`,
-  `CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_ai_ref_unique_v2 ON ga_ai_referrals(project_id, date, source, medium, source_dimension)`,
-  // v21: Add missing indexes for query_snapshots filtering
-  `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)`,
-  // v22: Intelligence — insights table for regression/gain/opportunity tracking
-  `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,
-    keyword         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_keyword_provider ON insights(keyword, provider)`,
-  // v23: Intelligence — health_snapshots table for citation health over time
-  `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)`,
-  // v24: Intelligence — add run_id to insights and health_snapshots for per-run correlation and idempotency
-  `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)`
-];
-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 migrate(db) {
-  const statements = MIGRATION_SQL.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
-  for (const statement of statements) {
-    db.run(sql.raw(statement));
-  }
-  for (const migration of MIGRATIONS) {
-    try {
-      db.run(sql.raw(migration));
-    } catch (err) {
-      if (isDuplicateColumnError(err)) continue;
-      throw err;
-    }
-  }
-}
-
-// ../api-routes/src/auth.ts
 function hashKey(key) {
   return crypto2.createHash("sha256").update(key).digest("hex");
 }
@@ -2055,7 +1305,7 @@ import { eq as eq3 } from "drizzle-orm";
 
 // ../api-routes/src/helpers.ts
 import crypto3 from "crypto";
-import { eq as eq2, sql as sql2 } from "drizzle-orm";
+import { eq as eq2, sql } from "drizzle-orm";
 function resolveProject(db, name) {
   const project = db.select().from(projects).where(eq2(projects.name, name)).get();
   if (!project) {
@@ -6572,7 +5822,7 @@ function formatNotification(row) {
 
 // ../api-routes/src/google.ts
 import crypto14 from "crypto";
-import { eq as eq14, and as and3, desc as desc5, sql as sql3 } from "drizzle-orm";
+import { eq as eq14, and as and3, desc as desc5, sql as sql2 } from "drizzle-orm";
 
 // ../integration-google/src/constants.ts
 var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
@@ -7536,10 +6786,10 @@ async function googleRoutes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     const { startDate, endDate, query, page, limit } = request.query;
     const conditions = [eq14(gscSearchData.projectId, project.id)];
-    if (startDate) conditions.push(sql3`${gscSearchData.date} >= ${startDate}`);
-    if (endDate) conditions.push(sql3`${gscSearchData.date} <= ${endDate}`);
-    if (query) conditions.push(sql3`${gscSearchData.query} LIKE ${"%" + query + "%"}`);
-    if (page) conditions.push(sql3`${gscSearchData.page} LIKE ${"%" + page + "%"}`);
+    if (startDate) conditions.push(sql2`${gscSearchData.date} >= ${startDate}`);
+    if (endDate) conditions.push(sql2`${gscSearchData.date} <= ${endDate}`);
+    if (query) conditions.push(sql2`${gscSearchData.query} LIKE ${"%" + query + "%"}`);
+    if (page) conditions.push(sql2`${gscSearchData.page} LIKE ${"%" + page + "%"}`);
     const rows = app.db.select().from(gscSearchData).where(and3(...conditions)).orderBy(desc5(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
     return rows.map((r) => ({
       date: r.date,
@@ -8081,12 +7331,12 @@ async function bingFetch(apiKey, endpoint, opts) {
     bingClientLog("error", "http.error", { endpoint, method, httpStatus: res.status, responseBody: body });
     throw new BingApiError(`Bing API error (${res.status}): ${body}`, res.status);
   }
-  const text2 = await res.text();
-  if (!text2 || text2.trim() === "") {
+  const text = await res.text();
+  if (!text || text.trim() === "") {
     return void 0;
   }
   try {
-    const parsed = JSON.parse(text2);
+    const parsed = JSON.parse(text);
     if (parsed && typeof parsed === "object" && "d" in parsed) {
       return parsed.d;
     }
@@ -8702,7 +7952,7 @@ async function cdpRoutes(app, opts) {
 
 // ../api-routes/src/ga.ts
 import crypto16 from "crypto";
-import { eq as eq17, desc as desc7, and as and6, sql as sql4 } from "drizzle-orm";
+import { eq as eq17, desc as desc7, and as and6, sql as sql3 } from "drizzle-orm";
 function gaLog(level, action, ctx) {
   const entry = { ts: (/* @__PURE__ */ new Date()).toISOString(), level, module: "GA4Routes", action, ...ctx };
   const stream = level === "error" ? process.stderr : process.stdout;
@@ -8917,8 +8167,8 @@ async function ga4Routes(app, opts) {
       tx.delete(gaTrafficSnapshots).where(
         and6(
           eq17(gaTrafficSnapshots.projectId, project.id),
-          sql4`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
-          sql4`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
+          sql3`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
+          sql3`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
         )
       ).run();
       if (rows.length > 0) {
@@ -8938,8 +8188,8 @@ async function ga4Routes(app, opts) {
       tx.delete(gaAiReferrals).where(
         and6(
           eq17(gaAiReferrals.projectId, project.id),
-          sql4`${gaAiReferrals.date} >= ${summary.periodStart}`,
-          sql4`${gaAiReferrals.date} <= ${summary.periodEnd}`
+          sql3`${gaAiReferrals.date} >= ${summary.periodStart}`,
+          sql3`${gaAiReferrals.date} <= ${summary.periodEnd}`
         )
       ).run();
       if (aiReferrals.length > 0) {
@@ -8995,22 +8245,22 @@ async function ga4Routes(app, opts) {
     }).from(gaTrafficSummaries).where(eq17(gaTrafficSummaries.projectId, project.id)).get();
     const rows = app.db.select({
       landingPage: gaTrafficSnapshots.landingPage,
-      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
-      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
-      users: sql4`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(eq17(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql4`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
+      sessions: sql3`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql3`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql3`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(eq17(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql3`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
     const aiReferrals = app.db.select({
       source: gaAiReferrals.source,
       medium: gaAiReferrals.medium,
       sourceDimension: gaAiReferrals.sourceDimension,
-      sessions: sql4`SUM(${gaAiReferrals.sessions})`,
-      users: sql4`SUM(${gaAiReferrals.users})`
-    }).from(gaAiReferrals).where(eq17(gaAiReferrals.projectId, project.id)).groupBy(gaAiReferrals.source, gaAiReferrals.medium, gaAiReferrals.sourceDimension).orderBy(sql4`SUM(${gaAiReferrals.sessions}) DESC`).all();
+      sessions: sql3`SUM(${gaAiReferrals.sessions})`,
+      users: sql3`SUM(${gaAiReferrals.users})`
+    }).from(gaAiReferrals).where(eq17(gaAiReferrals.projectId, project.id)).groupBy(gaAiReferrals.source, gaAiReferrals.medium, gaAiReferrals.sourceDimension).orderBy(sql3`SUM(${gaAiReferrals.sessions}) DESC`).all();
     const aiDeduped = app.db.select({
-      sessions: sql4`SUM(max_sessions)`,
-      users: sql4`SUM(max_users)`
+      sessions: sql3`SUM(max_sessions)`,
+      users: sql3`SUM(max_users)`
     }).from(
-      sql4`(
+      sql3`(
           SELECT date, source, medium,
                  MAX(sessions) AS max_sessions,
                  MAX(users) AS max_users
@@ -9060,9 +8310,9 @@ async function ga4Routes(app, opts) {
     requireGa4Connection(opts, project.name, project.canonicalDomain);
     const rows = app.db.select({
       date: gaTrafficSnapshots.date,
-      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
-      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
-      users: sql4`SUM(${gaTrafficSnapshots.users})`
+      sessions: sql3`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql3`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql3`SUM(${gaTrafficSnapshots.users})`
     }).from(gaTrafficSnapshots).where(eq17(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.date).orderBy(gaTrafficSnapshots.date).all();
     return rows.map((r) => ({
       date: r.date,
@@ -9076,10 +8326,10 @@ async function ga4Routes(app, opts) {
     requireGa4Connection(opts, project.name, project.canonicalDomain);
     const trafficPages = app.db.select({
       landingPage: gaTrafficSnapshots.landingPage,
-      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
-      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
-      users: sql4`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(eq17(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql4`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
+      sessions: sql3`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql3`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql3`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(eq17(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql3`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
     return {
       pages: trafficPages.map((r) => ({
         landingPage: r.landingPage,
@@ -9306,15 +8556,15 @@ async function fetchJson(connection, siteUrl, path7, init) {
     signal: AbortSignal.timeout(WP_REQUEST_TIMEOUT_MS)
   });
   if (res.status === 401 || res.status === 403) {
-    const text2 = await res.text().catch(() => "");
-    throw new WordpressApiError("AUTH_INVALID", buildAuthErrorMessage(res, text2), res.status);
+    const text = await res.text().catch(() => "");
+    throw new WordpressApiError("AUTH_INVALID", buildAuthErrorMessage(res, text), res.status);
   }
   if (res.status === 404) {
     throw new WordpressApiError("NOT_FOUND", "WordPress endpoint not found", 404);
   }
   if (!res.ok) {
-    const text2 = await res.text().catch(() => "");
-    throw new WordpressApiError("UPSTREAM_ERROR", `WordPress API error (${res.status}): ${text2 || res.statusText}`, res.status);
+    const text = await res.text().catch(() => "");
+    throw new WordpressApiError("UPSTREAM_ERROR", `WordPress API error (${res.status}): ${text || res.statusText}`, res.status);
   }
   return {
     body: await res.json(),
@@ -9415,9 +8665,9 @@ function computeWordCount(content) {
   return clean.split(/\s+/).filter(Boolean).length;
 }
 function buildSnippet(content) {
-  const text2 = stripHtml(content);
-  if (text2.length <= 160) return text2;
-  return `${text2.slice(0, 157)}...`;
+  const text = stripHtml(content);
+  if (text.length <= 160) return text;
+  return `${text.slice(0, 157)}...`;
 }
 function contentHash(content) {
   return crypto17.createHash("sha256").update(content).digest("hex");
@@ -9434,9 +8684,9 @@ async function mapWithConcurrency(items, limit, iteratee) {
   let nextIndex = 0;
   async function worker() {
     while (nextIndex < items.length) {
-      const index2 = nextIndex;
+      const index = nextIndex;
       nextIndex += 1;
-      results[index2] = await iteratee(items[index2], index2);
+      results[index] = await iteratee(items[index], index);
     }
   }
   const workerCount = Math.max(1, Math.min(limit, items.length));
@@ -10913,7 +10163,7 @@ function isVertexConfig(config) {
 function resolveModel(config) {
   return config.model || DEFAULT_MODEL;
 }
-function createClient2(config) {
+function createClient(config) {
   if (isVertexConfig(config)) {
     return new GoogleGenAI({
       vertexai: true,
@@ -10953,19 +10203,19 @@ async function healthcheck(config) {
   if (!validation.ok) return validation;
   try {
     const model = resolveModel(config);
-    const client = createClient2(config);
+    const client = createClient(config);
     const result = await withRetry(
       () => client.models.generateContent({
         model,
         contents: 'Say "ok"'
       })
     );
-    const text2 = result.text ?? "";
+    const text = result.text ?? "";
     const backend = isVertexConfig(config) ? "vertex ai" : "api key";
     return {
-      ok: text2.length > 0,
+      ok: text.length > 0,
       provider: "gemini",
-      message: text2.length > 0 ? `gemini ${backend} verified` : `empty response from gemini ${backend}`,
+      message: text.length > 0 ? `gemini ${backend} verified` : `empty response from gemini ${backend}`,
       model
     };
   } catch (err) {
@@ -10980,7 +10230,7 @@ async function healthcheck(config) {
 async function executeTrackedQuery(input) {
   const model = resolveModel(input.config);
   const prompt = buildPrompt(input.keyword, input.location);
-  const client = createClient2(input.config);
+  const client = createClient(input.config);
   try {
     const result = await withRetry(
       () => client.models.generateContent({
@@ -10991,14 +10241,14 @@ async function executeTrackedQuery(input) {
         }
       })
     );
-    const groundingSources = extractGroundingMetadata(result);
-    const searchQueries = extractSearchQueries(result);
+    const rawResponse = responseToRecord(result);
+    const parsed = reparseStoredResult(rawResponse);
     return {
       provider: "gemini",
-      rawResponse: responseToRecord(result),
+      rawResponse,
       model,
-      groundingSources,
-      searchQueries
+      groundingSources: parsed.groundingSources,
+      searchQueries: parsed.searchQueries
     };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -11006,14 +10256,31 @@ async function executeTrackedQuery(input) {
   }
 }
 function normalizeResult(raw) {
-  const answerText = extractAnswerText(raw.rawResponse);
-  const citedDomains = extractCitedDomains(raw);
+  const parsed = reparseStoredResult(raw.rawResponse);
+  const useParsed = hasParsedResponseContent(raw.rawResponse);
+  const groundingSources = useParsed ? parsed.groundingSources : raw.groundingSources;
+  const searchQueries = useParsed ? parsed.searchQueries : raw.searchQueries;
+  const citedDomains = extractCitedDomainsFromSources(groundingSources);
   return {
     provider: "gemini",
-    answerText,
+    answerText: parsed.answerText,
     citedDomains,
-    groundingSources: raw.groundingSources,
-    searchQueries: raw.searchQueries
+    groundingSources,
+    searchQueries
+  };
+}
+function hasParsedResponseContent(rawResponse) {
+  return Array.isArray(rawResponse.candidates) && rawResponse.candidates.length > 0;
+}
+function reparseStoredResult(rawResponse) {
+  const groundingSources = extractGroundingMetadataFromRaw(rawResponse);
+  const searchQueries = extractSearchQueriesFromRaw(rawResponse);
+  return {
+    provider: "gemini",
+    answerText: extractAnswerText(rawResponse),
+    citedDomains: extractCitedDomainsFromSources(groundingSources),
+    groundingSources,
+    searchQueries
   };
 }
 function buildPrompt(keyword, location) {
@@ -11033,33 +10300,51 @@ function extractAnswerText(rawResponse) {
     return "";
   }
 }
-function extractGroundingMetadata(response) {
+function extractGroundingMetadataFromRaw(rawResponse) {
   try {
-    const candidate = response.candidates?.[0];
+    const candidates = rawResponse.candidates;
+    const candidate = candidates?.[0];
     if (!candidate) return [];
     const metadata = candidate.groundingMetadata;
     if (!metadata) return [];
     const chunks = metadata.groundingChunks;
     if (!chunks) return [];
-    return chunks.filter((chunk) => chunk.web?.uri).map((chunk) => ({
-      uri: chunk.web.uri,
-      title: chunk.web?.title ?? ""
-    }));
+    const indices = /* @__PURE__ */ new Set();
+    for (const support of metadata.groundingSupports ?? []) {
+      for (const index of support.groundingChunkIndices ?? []) {
+        if (Number.isInteger(index) && index >= 0 && index < chunks.length) {
+          indices.add(index);
+        }
+      }
+    }
+    const selectedChunks = indices.size > 0 ? [...indices].map((index) => chunks[index]).filter(Boolean) : chunks;
+    const seen = /* @__PURE__ */ new Set();
+    const sources = [];
+    for (const chunk of selectedChunks) {
+      if (!chunk.web?.uri || seen.has(chunk.web.uri)) continue;
+      seen.add(chunk.web.uri);
+      sources.push({
+        uri: chunk.web.uri,
+        title: chunk.web.title ?? ""
+      });
+    }
+    return sources;
   } catch {
     return [];
   }
 }
-function extractSearchQueries(response) {
+function extractSearchQueriesFromRaw(rawResponse) {
   try {
-    const candidate = response.candidates?.[0];
+    const candidates = rawResponse.candidates;
+    const candidate = candidates?.[0];
     return candidate?.groundingMetadata?.webSearchQueries ?? [];
   } catch {
     return [];
   }
 }
-function extractCitedDomains(raw) {
+function extractCitedDomainsFromSources(groundingSources) {
   const domains = /* @__PURE__ */ new Set();
-  for (const source of raw.groundingSources) {
+  for (const source of groundingSources) {
     const domain = extractDomainFromUri(source.uri);
     if (domain) {
       domains.add(domain);
@@ -11104,7 +10389,7 @@ function extractDomainFromUri(uri) {
 }
 async function generateText(prompt, config) {
   const model = resolveModel(config);
-  const client = createClient2(config);
+  const client = createClient(config);
   const result = await withRetry(
     () => client.models.generateContent({
       model,
@@ -11120,7 +10405,11 @@ function responseToRecord(response) {
       finishReason: c.finishReason,
       groundingMetadata: c.groundingMetadata ? {
         webSearchQueries: c.groundingMetadata.webSearchQueries,
-        groundingChunks: c.groundingMetadata.groundingChunks
+        groundingChunks: c.groundingMetadata.groundingChunks,
+        // Preserve support-to-chunk mappings so stored snapshots can be reparsed using
+        // Google's documented citation model.
+        // Docs: https://ai.google.dev/gemini-api/docs/google-search
+        groundingSupports: c.groundingMetadata.groundingSupports
       } : void 0
     }));
     return {
@@ -11263,11 +10552,11 @@ async function healthcheck2(config) {
         input: 'Say "ok"'
       })
     );
-    const text2 = extractResponseText(response);
+    const text = extractResponseText(response);
     return {
-      ok: text2.length > 0,
+      ok: text.length > 0,
       provider: "openai",
-      message: text2.length > 0 ? "openai api key verified" : "empty response from openai",
+      message: text.length > 0 ? "openai api key verified" : "empty response from openai",
       model: config.model ?? DEFAULT_MODEL2
     };
   } catch (err) {
@@ -11301,14 +10590,14 @@ async function executeTrackedQuery2(input) {
         input: buildPrompt2(input.keyword)
       })
     );
-    const groundingSources = extractGroundingSources(response);
-    const searchQueries = extractSearchQueries2(response);
+    const rawResponse = responseToRecord2(response);
+    const parsed = reparseStoredResult2(rawResponse);
     return {
       provider: "openai",
-      rawResponse: responseToRecord2(response),
+      rawResponse,
       model,
-      groundingSources,
-      searchQueries
+      groundingSources: parsed.groundingSources,
+      searchQueries: parsed.searchQueries
     };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -11316,14 +10605,31 @@ async function executeTrackedQuery2(input) {
   }
 }
 function normalizeResult2(raw) {
-  const answerText = extractAnswerTextFromRaw(raw.rawResponse);
-  const citedDomains = extractCitedDomains2(raw);
+  const parsed = reparseStoredResult2(raw.rawResponse);
+  const useParsed = hasParsedResponseContent2(raw.rawResponse);
+  const groundingSources = useParsed ? parsed.groundingSources : raw.groundingSources;
+  const searchQueries = useParsed ? parsed.searchQueries : raw.searchQueries;
+  const citedDomains = extractCitedDomainsFromSources2(groundingSources);
   return {
     provider: "openai",
-    answerText,
+    answerText: parsed.answerText,
     citedDomains,
-    groundingSources: raw.groundingSources,
-    searchQueries: raw.searchQueries
+    groundingSources,
+    searchQueries
+  };
+}
+function hasParsedResponseContent2(rawResponse) {
+  return Array.isArray(rawResponse.output) && rawResponse.output.length > 0;
+}
+function reparseStoredResult2(rawResponse) {
+  const groundingSources = extractGroundingSourcesFromRaw(rawResponse);
+  const searchQueries = extractSearchQueriesFromRaw2(rawResponse);
+  return {
+    provider: "openai",
+    answerText: extractAnswerTextFromRaw(rawResponse),
+    citedDomains: extractCitedDomainsFromSources2(groundingSources),
+    groundingSources,
+    searchQueries
   };
 }
 function buildPrompt2(keyword) {
@@ -11346,16 +10652,18 @@ function extractResponseText(response) {
     return "";
   }
 }
-function extractGroundingSources(response) {
+function extractGroundingSourcesFromRaw(rawResponse) {
   const sources = [];
   const seen = /* @__PURE__ */ new Set();
   try {
-    for (const item of response.output) {
+    const output = rawResponse.output;
+    if (!output) return [];
+    for (const item of output) {
       if (item.type === "message") {
-        for (const content of item.content) {
+        for (const content of item.content ?? []) {
           if (content.type === "output_text" && content.annotations) {
             for (const annotation of content.annotations) {
-              if (annotation.type === "url_citation" && !seen.has(annotation.url)) {
+              if (annotation.type === "url_citation" && typeof annotation.url === "string" && !seen.has(annotation.url)) {
                 seen.add(annotation.url);
                 sources.push({
                   uri: annotation.url,
@@ -11371,20 +10679,28 @@ function extractGroundingSources(response) {
   }
   return sources;
 }
-function extractSearchQueries2(response) {
-  const queries = [];
+function extractSearchQueriesFromRaw2(rawResponse) {
+  const queries = /* @__PURE__ */ new Set();
   try {
-    for (const item of response.output) {
-      if (item.type === "web_search_call" && "query" in item) {
-        const query = item.query;
-        if (typeof query === "string" && query.length > 0) {
-          queries.push(query);
+    const output = rawResponse.output;
+    if (!output) return [];
+    for (const item of output) {
+      if (item.type !== "web_search_call" || !item.action) continue;
+      const action = item.action;
+      if (typeof action.query === "string" && action.query.length > 0) {
+        queries.add(action.query);
+      }
+      if (Array.isArray(action.queries)) {
+        for (const query of action.queries) {
+          if (typeof query === "string" && query.length > 0) {
+            queries.add(query);
+          }
         }
       }
     }
   } catch {
   }
-  return queries;
+  return [...queries];
 }
 function extractAnswerTextFromRaw(rawResponse) {
   try {
@@ -11405,9 +10721,9 @@ function extractAnswerTextFromRaw(rawResponse) {
     return "";
   }
 }
-function extractCitedDomains2(raw) {
+function extractCitedDomainsFromSources2(groundingSources) {
   const domains = /* @__PURE__ */ new Set();
-  for (const source of raw.groundingSources) {
+  for (const source of groundingSources) {
     const domain = extractDomainFromUri2(source.uri);
     if (domain) domains.add(domain);
   }
@@ -11583,11 +10899,11 @@ async function healthcheck3(config) {
         messages: [{ role: "user", content: 'Say "ok"' }]
       })
     );
-    const text2 = extractTextFromResponse(response);
+    const text = extractTextFromResponse(response);
     return {
-      ok: text2.length > 0,
+      ok: text.length > 0,
       provider: "claude",
-      message: text2.length > 0 ? "claude api key verified" : "empty response from claude",
+      message: text.length > 0 ? "claude api key verified" : "empty response from claude",
       model
     };
   } catch (err) {
@@ -11625,14 +10941,17 @@ async function executeTrackedQuery3(input) {
         messages: [{ role: "user", content: input.keyword }]
       })
     );
-    const groundingSources = extractGroundingSources2(response);
-    const searchQueries = extractSearchQueries3(response);
+    const rawResponse = responseToRecord3(response);
+    const parsed = reparseStoredResult3(rawResponse);
+    if (parsed.providerError) {
+      throw new Error(parsed.providerError);
+    }
     return {
       provider: "claude",
-      rawResponse: responseToRecord3(response),
+      rawResponse,
       model,
-      groundingSources,
-      searchQueries
+      groundingSources: parsed.groundingSources,
+      searchQueries: parsed.searchQueries
     };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -11640,14 +10959,33 @@ async function executeTrackedQuery3(input) {
   }
 }
 function normalizeResult3(raw) {
-  const answerText = extractAnswerTextFromRaw2(raw.rawResponse);
-  const citedDomains = extractCitedDomains3(raw);
+  const parsed = reparseStoredResult3(raw.rawResponse);
+  const useParsed = hasParsedResponseContent3(raw.rawResponse);
+  const groundingSources = useParsed ? parsed.groundingSources : raw.groundingSources;
+  const searchQueries = useParsed ? parsed.searchQueries : raw.searchQueries;
+  const citedDomains = extractCitedDomainsFromSources3(groundingSources);
   return {
     provider: "claude",
-    answerText,
+    answerText: parsed.answerText,
     citedDomains,
-    groundingSources: raw.groundingSources,
-    searchQueries: raw.searchQueries
+    groundingSources,
+    searchQueries
+  };
+}
+function hasParsedResponseContent3(rawResponse) {
+  return Array.isArray(rawResponse.content) && rawResponse.content.length > 0;
+}
+function reparseStoredResult3(rawResponse) {
+  const groundingSources = extractGroundingSourcesFromRaw2(rawResponse);
+  const searchQueries = extractSearchQueriesFromRaw3(rawResponse);
+  const providerErrors = extractWebSearchToolErrors(rawResponse);
+  return {
+    provider: "claude",
+    answerText: extractAnswerTextFromRaw2(rawResponse),
+    citedDomains: extractCitedDomainsFromSources3(groundingSources),
+    groundingSources,
+    searchQueries,
+    ...providerErrors.length > 0 ? { providerError: `web_search tool error: ${providerErrors.join(", ")}` } : {}
   };
 }
 function extractTextFromResponse(response) {
@@ -11663,16 +11001,20 @@ function extractTextFromResponse(response) {
     return "";
   }
 }
-function extractGroundingSources2(response) {
+function extractGroundingSourcesFromRaw2(rawResponse) {
   const sources = [];
+  const seen = /* @__PURE__ */ new Set();
   try {
-    for (const block of response.content) {
-      if (block.type === "web_search_tool_result" && Array.isArray(block.content)) {
-        for (const result of block.content) {
-          if (result.type === "web_search_result") {
+    const content = rawResponse.content;
+    if (!content) return [];
+    for (const block of content) {
+      if (block.type === "text" && Array.isArray(block.citations)) {
+        for (const citation of block.citations) {
+          if (citation.type === "web_search_result_location" && typeof citation.url === "string" && !seen.has(citation.url)) {
+            seen.add(citation.url);
             sources.push({
-              uri: result.url,
-              title: result.title ?? ""
+              uri: citation.url,
+              title: citation.title ?? ""
             });
           }
         }
@@ -11682,20 +11024,28 @@ function extractGroundingSources2(response) {
   }
   return sources;
 }
-function extractSearchQueries3(response) {
-  const queries = [];
+function extractSearchQueriesFromRaw3(rawResponse) {
+  const queries = /* @__PURE__ */ new Set();
   try {
-    for (const block of response.content) {
+    const content = rawResponse.content;
+    if (!content) return [];
+    for (const block of content) {
       if (block.type === "server_tool_use" && block.name === "web_search") {
-        const input = block.input;
-        if (input.query) {
-          queries.push(input.query);
+        if (typeof block.input?.query === "string" && block.input.query.length > 0) {
+          queries.add(block.input.query);
+        }
+        if (Array.isArray(block.input?.queries)) {
+          for (const query of block.input.queries) {
+            if (typeof query === "string" && query.length > 0) {
+              queries.add(query);
+            }
+          }
         }
       }
     }
   } catch {
   }
-  return queries;
+  return [...queries];
 }
 function extractAnswerTextFromRaw2(rawResponse) {
   try {
@@ -11712,9 +11062,26 @@ function extractAnswerTextFromRaw2(rawResponse) {
     return "";
   }
 }
-function extractCitedDomains3(raw) {
+function extractWebSearchToolErrors(rawResponse) {
+  const errors = /* @__PURE__ */ new Set();
+  try {
+    const content = rawResponse.content;
+    if (!content) return [];
+    for (const block of content) {
+      if (block.type !== "web_search_tool_result") continue;
+      if (block.content === null || typeof block.content !== "object" || Array.isArray(block.content)) continue;
+      const errorCode = block.content.error_code;
+      if (typeof errorCode === "string" && errorCode.length > 0) {
+        errors.add(errorCode);
+      }
+    }
+  } catch {
+  }
+  return [...errors];
+}
+function extractCitedDomainsFromSources3(groundingSources) {
   const domains = /* @__PURE__ */ new Set();
-  for (const source of raw.groundingSources) {
+  for (const source of groundingSources) {
     const domain = extractDomainFromUri3(source.uri);
     if (domain) domains.add(domain);
   }
@@ -11967,15 +11334,15 @@ async function generateText4(prompt, config) {
   );
   return response.choices[0]?.message?.content ?? "";
 }
-function extractDomainMentions(text2) {
+function extractDomainMentions(text) {
   const domains = /* @__PURE__ */ new Set();
   const urlPattern = /https?:\/\/([a-zA-Z0-9][-a-zA-Z0-9]*(?:\.[a-zA-Z0-9][-a-zA-Z0-9]*)+)/g;
   let match;
-  while ((match = urlPattern.exec(text2)) !== null) {
+  while ((match = urlPattern.exec(text)) !== null) {
     domains.add(match[1].replace(/^www\./, "").toLowerCase());
   }
   const domainPattern = /(?:^|[\s(["'])((?:[a-zA-Z0-9][-a-zA-Z0-9]*\.)+(?:com|org|net|io|co|dev|ai|app|edu|gov|biz|info|tech|health|dental|legal|law|med|uk|us|ca|au|de|fr|es|it|nl|se|no|dk|fi|jp|cn|kr|br|mx|ru|in|sg|nz|za)(?:\.[a-zA-Z]{2})?)(?:[\s).,;/"']|$)/g;
-  while ((match = domainPattern.exec(text2)) !== null) {
+  while ((match = domainPattern.exec(text)) !== null) {
     domains.add(match[1].replace(/^www\./, "").toLowerCase());
   }
   return [...domains];
@@ -12341,11 +11708,11 @@ var chatgptTarget = {
       })()`,
       returnByValue: true
     });
-    const text2 = String(result.value ?? "");
-    if (!text2) {
+    const text = String(result.value ?? "");
+    if (!text) {
       throw new CDPProviderError("CDP_TARGET_SELECTOR_FAILED", "Could not extract ChatGPT answer text");
     }
-    return text2;
+    return text;
   },
   async extractCitations(client) {
     const { result } = await client.Runtime.evaluate({
@@ -12468,7 +11835,7 @@ async function captureElementScreenshot(client, selector, outputPath) {
 }
 
 // ../provider-cdp/src/normalize.ts
-function extractCitedDomains4(groundingSources) {
+function extractCitedDomains(groundingSources) {
   const domains = /* @__PURE__ */ new Set();
   for (const source of groundingSources) {
     try {
@@ -12497,7 +11864,7 @@ function normalizeResult5(raw) {
   return {
     provider: raw.provider,
     answerText,
-    citedDomains: extractCitedDomains4(raw.groundingSources),
+    citedDomains: extractCitedDomains(raw.groundingSources),
     groundingSources: raw.groundingSources,
     searchQueries: raw.searchQueries
   };
@@ -12670,11 +12037,11 @@ async function healthcheck5(config) {
         messages: [{ role: "user", content: 'Say "ok"' }]
       })
     );
-    const text2 = response.choices[0]?.message?.content ?? "";
+    const text = response.choices[0]?.message?.content ?? "";
     return {
-      ok: text2.length > 0,
+      ok: text.length > 0,
       provider: "perplexity",
-      message: text2.length > 0 ? "perplexity api key verified" : "empty response from perplexity",
+      message: text.length > 0 ? "perplexity api key verified" : "empty response from perplexity",
       model: config.model ?? DEFAULT_MODEL5
     };
   } catch (err) {
@@ -12698,17 +12065,13 @@ async function executeTrackedQuery5(input) {
       })
     );
     const rawResponse = responseToRecord5(response);
-    const citations = extractCitations(rawResponse);
-    const groundingSources = citations.map((url) => ({
-      uri: url,
-      title: ""
-    }));
+    const parsed = reparseStoredResult4(rawResponse);
     return {
       provider: "perplexity",
       rawResponse,
       model,
-      groundingSources,
-      searchQueries: [input.keyword]
+      groundingSources: parsed.groundingSources,
+      searchQueries: parsed.searchQueries
     };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -12716,14 +12079,38 @@ async function executeTrackedQuery5(input) {
   }
 }
 function normalizeResult6(raw) {
-  const answerText = extractAnswerText3(raw.rawResponse);
-  const citedDomains = extractCitedDomains5(raw.groundingSources);
+  const parsed = reparseStoredResult4(raw.rawResponse);
+  const useParsed = hasParsedResponseContent4(raw.rawResponse);
+  const groundingSources = useParsed ? parsed.groundingSources : raw.groundingSources;
+  const searchQueries = useParsed ? parsed.searchQueries : raw.searchQueries;
+  const citedDomains = extractCitedDomains2(groundingSources);
   return {
     provider: "perplexity",
-    answerText,
+    answerText: parsed.answerText,
     citedDomains,
-    groundingSources: raw.groundingSources,
-    searchQueries: raw.searchQueries
+    groundingSources,
+    searchQueries
+  };
+}
+function hasParsedResponseContent4(rawResponse) {
+  if (Array.isArray(rawResponse.choices) && rawResponse.choices.length > 0) return true;
+  if (Array.isArray(rawResponse.search_results) && rawResponse.search_results.length > 0) return true;
+  if (Array.isArray(rawResponse.citations) && rawResponse.citations.length > 0) return true;
+  const nestedResponse = extractNestedApiResponse(rawResponse);
+  if (!nestedResponse) return false;
+  return Array.isArray(nestedResponse.choices) && nestedResponse.choices.length > 0 || Array.isArray(nestedResponse.search_results) && nestedResponse.search_results.length > 0 || Array.isArray(nestedResponse.citations) && nestedResponse.citations.length > 0;
+}
+function reparseStoredResult4(rawResponse) {
+  const groundingSources = extractGroundingSources(rawResponse);
+  return {
+    provider: "perplexity",
+    answerText: extractAnswerText3(rawResponse),
+    citedDomains: extractCitedDomains2(groundingSources),
+    groundingSources,
+    // Perplexity documents `search_results` and `citations` on the response structure but
+    // does not document returned search-query telemetry, so Canonry does not synthesize it.
+    // Docs: https://docs.perplexity.ai/docs/sonar/openai-compatibility
+    searchQueries: []
   };
 }
 function buildPrompt4(keyword, location) {
@@ -12736,25 +12123,80 @@ function extractCitations(rawResponse) {
   if (Array.isArray(rawResponse.citations)) {
     return rawResponse.citations.filter((c) => typeof c === "string");
   }
-  const apiResponse = rawResponse.apiResponse;
-  if (apiResponse !== null && typeof apiResponse === "object" && !Array.isArray(apiResponse)) {
-    const nested = apiResponse.citations;
+  const nestedResponse = extractNestedApiResponse(rawResponse);
+  if (nestedResponse) {
+    const nested = nestedResponse.citations;
     if (Array.isArray(nested)) {
       return nested.filter((c) => typeof c === "string");
     }
   }
   return [];
 }
+function extractGroundingSources(rawResponse) {
+  const searchResults = extractSearchResults(rawResponse);
+  if (searchResults.length > 0) {
+    const seen = /* @__PURE__ */ new Set();
+    const sources = [];
+    for (const result of searchResults) {
+      if (seen.has(result.uri)) continue;
+      seen.add(result.uri);
+      sources.push(result);
+    }
+    return sources;
+  }
+  return extractCitations(rawResponse).map((url) => ({
+    uri: url,
+    title: ""
+  }));
+}
+function extractSearchResults(rawResponse) {
+  const direct = parseSearchResultsArray(rawResponse.search_results);
+  if (direct.length > 0) return direct;
+  const nestedResponse = extractNestedApiResponse(rawResponse);
+  if (nestedResponse) {
+    return parseSearchResultsArray(nestedResponse.search_results);
+  }
+  return [];
+}
+function parseSearchResultsArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((result) => {
+    if (result === null || typeof result !== "object" || Array.isArray(result)) {
+      return [];
+    }
+    const url = result.url;
+    if (typeof url !== "string" || url.length === 0) {
+      return [];
+    }
+    const title = result.title;
+    return [{
+      uri: url,
+      title: typeof title === "string" ? title : ""
+    }];
+  });
+}
 function extractAnswerText3(rawResponse) {
   try {
-    const choices = rawResponse.choices;
-    if (!choices?.length) return "";
-    return choices[0].message?.content ?? "";
+    const directChoices = rawResponse.choices;
+    if (directChoices?.length) {
+      return directChoices[0].message?.content ?? "";
+    }
+    const nestedResponse = extractNestedApiResponse(rawResponse);
+    const nestedChoices = nestedResponse?.choices;
+    if (!nestedChoices?.length) return "";
+    return nestedChoices[0].message?.content ?? "";
   } catch {
     return "";
   }
 }
-function extractCitedDomains5(groundingSources) {
+function extractNestedApiResponse(rawResponse) {
+  const apiResponse = rawResponse.apiResponse;
+  if (apiResponse !== null && typeof apiResponse === "object" && !Array.isArray(apiResponse)) {
+    return apiResponse;
+  }
+  return null;
+}
+function extractCitedDomains2(groundingSources) {
   const domains = /* @__PURE__ */ new Set();
   for (const source of groundingSources) {
     const domain = extractDomainFromUri4(source.uri);
@@ -12901,7 +12343,7 @@ function getGoogleConnection(config, domain, connectionType) {
 }
 function upsertGoogleConnection(config, connection) {
   const connections = ensureConnections(config);
-  const index2 = connections.findIndex((entry) => entry.domain === connection.domain && entry.connectionType === connection.connectionType);
+  const index = connections.findIndex((entry) => entry.domain === connection.domain && entry.connectionType === connection.connectionType);
   const normalized = {
     ...connection,
     propertyId: connection.propertyId ?? null,
@@ -12910,11 +12352,11 @@ function upsertGoogleConnection(config, connection) {
     tokenExpiresAt: connection.tokenExpiresAt ?? null,
     scopes: connection.scopes ?? []
   };
-  if (index2 === -1) {
+  if (index === -1) {
     connections.push(normalized);
     return normalized;
   }
-  connections[index2] = normalized;
+  connections[index] = normalized;
   return normalized;
 }
 function patchGoogleConnection(config, domain, connectionType, patch) {
@@ -12954,12 +12396,12 @@ function getGa4Connection(config, projectName) {
 }
 function upsertGa4Connection(config, connection) {
   const connections = ensureConnections2(config);
-  const index2 = connections.findIndex((c) => c.projectName === connection.projectName);
-  if (index2 === -1) {
+  const index = connections.findIndex((c) => c.projectName === connection.projectName);
+  if (index === -1) {
     connections.push(connection);
     return connection;
   }
-  connections[index2] = connection;
+  connections[index] = connection;
   return connection;
 }
 function removeGa4Connection(config, projectName) {
@@ -12995,12 +12437,12 @@ function getWordpressConnection(config, projectName) {
 function upsertWordpressConnection(config, connection) {
   const connections = ensureConnections3(config);
   const normalized = normalizeConnection(connection);
-  const index2 = connections.findIndex((entry) => entry.projectName === connection.projectName);
-  if (index2 === -1) {
+  const index = connections.findIndex((entry) => entry.projectName === connection.projectName);
+  if (index === -1) {
     connections.push(normalized);
     return normalized;
   }
-  connections[index2] = normalized;
+  connections[index] = normalized;
   return normalized;
 }
 function patchWordpressConnection(config, projectName, patch) {
@@ -13031,85 +12473,199 @@ import crypto18 from "crypto";
 import fs4 from "fs";
 import path5 from "path";
 import os4 from "os";
-import { and as and7, eq as eq18, inArray as inArray3, sql as sql5 } from "drizzle-orm";
+import { and as and7, eq as eq18, inArray as inArray3, sql as sql4 } from "drizzle-orm";
 
-// 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");
-  }
+// src/citation-utils.ts
+function domainMatches(domain, canonicalDomain) {
+  const normalized = normalizeProjectDomain(canonicalDomain);
+  const d = normalizeProjectDomain(domain);
+  return d === normalized || d.endsWith(`.${normalized}`);
 }
-function createLogger(module) {
-  function log10(level, action, ctx) {
-    const entry = {
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      level,
-      module,
-      action,
-      ...ctx
-    };
-    emit(entry);
+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 {
-    info: (action, ctx) => log10("info", action, ctx),
-    warn: (action, ctx) => log10("warn", action, ctx),
-    error: (action, ctx) => log10("error", action, ctx)
-  };
+  return "not-cited";
 }
-
-// src/job-runner.ts
-var log = createLogger("JobRunner");
-var RunCancelledError = class extends Error {
-  constructor(runId) {
-    super(`Run ${runId} was cancelled`);
-    this.name = "RunCancelledError";
-  }
-};
-var ProviderExecutionGate = class {
-  constructor(maxConcurrency, maxPerMinute) {
-    this.maxConcurrency = maxConcurrency;
-    this.maxPerMinute = maxPerMinute;
-  }
-  window = [];
-  waiters = [];
-  rateLimitChain = Promise.resolve();
-  inFlight = 0;
-  async run(task) {
-    await this.acquire();
-    try {
-      await this.waitForRateLimit();
-      return await task();
-    } finally {
-      this.release();
+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);
+      }
     }
   }
-  async acquire() {
-    if (this.inFlight < Math.max(1, this.maxConcurrency)) {
-      this.inFlight++;
-      return;
+  for (const source of normalized.groundingSources) {
+    const uri = source.uri.toLowerCase();
+    for (const cd of competitorDomains) {
+      if (uri.includes(cd.toLowerCase())) {
+        overlapSet.add(cd);
+      }
     }
-    await new Promise((resolve) => {
-      this.waiters.push(resolve);
-    });
-    this.inFlight++;
-  }
-  release() {
-    this.inFlight = Math.max(0, this.inFlight - 1);
-    const next = this.waiters.shift();
-    next?.();
+  }
+  if (normalized.answerText) {
+    const lowerAnswer = normalized.answerText.toLowerCase();
+    for (const cd of competitorDomains) {
+      if (lowerAnswer.includes(cd.toLowerCase())) {
+        overlapSet.add(cd);
+      }
+      const brand = cd.split(".")[0];
+      if (brand && brand.length >= 4 && new RegExp(`\\b${brand}\\b`, "i").test(lowerAnswer)) {
+        overlapSet.add(cd);
+      }
+    }
+  }
+  return [...overlapSet];
+}
+function extractRecommendedCompetitors(answerText, ownDomains, citedDomains, competitorDomains) {
+  if (!answerText || answerText.length < 20) return [];
+  const ownBrandKeys = new Set(
+    ownDomains.flatMap((domain) => collectBrandKeysFromDomain(domain))
+  );
+  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 hostname = normalizeProjectDomain(domain).split("/")[0] ?? "";
+  const labels = hostname.split(".").filter(Boolean);
+  const keys = /* @__PURE__ */ new Set();
+  const hostnameKey = hostname.replace(/[^a-z0-9]/gi, "").toLowerCase();
+  if (hostnameKey.length >= 4) keys.add(hostnameKey);
+  for (const label of labels) {
+    const key = label.replace(/[^a-z0-9]/gi, "").toLowerCase();
+    if (key.length >= 4) keys.add(key);
+  }
+  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/job-runner.ts
+var log = createLogger("JobRunner");
+var RunCancelledError = class extends Error {
+  constructor(runId) {
+    super(`Run ${runId} was cancelled`);
+    this.name = "RunCancelledError";
+  }
+};
+var ProviderExecutionGate = class {
+  constructor(maxConcurrency, maxPerMinute) {
+    this.maxConcurrency = maxConcurrency;
+    this.maxPerMinute = maxPerMinute;
+  }
+  window = [];
+  waiters = [];
+  rateLimitChain = Promise.resolve();
+  inFlight = 0;
+  async run(task) {
+    await this.acquire();
+    try {
+      await this.waitForRateLimit();
+      return await task();
+    } finally {
+      this.release();
+    }
+  }
+  async acquire() {
+    if (this.inFlight < Math.max(1, this.maxConcurrency)) {
+      this.inFlight++;
+      return;
+    }
+    await new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+    this.inFlight++;
+  }
+  release() {
+    this.inFlight = Math.max(0, this.inFlight - 1);
+    const next = this.waiters.shift();
+    next?.();
   }
   async waitForRateLimit() {
     let releaseChain;
@@ -13431,7 +12987,7 @@ var JobRunner = class {
       updatedAt: now
     }).onConflictDoUpdate({
       target: [usageCounters.scope, usageCounters.period, usageCounters.metric],
-      set: { count: sql5`${usageCounters.count} + ${count}`, updatedAt: now }
+      set: { count: sql4`${usageCounters.count} + ${count}`, updatedAt: now }
     }).run();
   }
   flushProviderUsage(projectId, providerDispatchCounts) {
@@ -13481,159 +13037,10 @@ var JobRunner = class {
 function getCurrentUsageDay() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
-function domainMatches(domain, canonicalDomain) {
-  const normalized = normalizeProjectDomain(canonicalDomain);
-  const d = normalizeProjectDomain(domain);
-  return d === normalized || d.endsWith(`.${normalized}`);
-}
-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 = cd.split(".")[0];
-      if (brand && brand.length >= 4 && new RegExp(`\\b${brand}\\b`, "i").test(lowerAnswer)) {
-        overlapSet.add(cd);
-      }
-    }
-  }
-  return [...overlapSet];
-}
-function extractRecommendedCompetitors(answerText, ownDomains, citedDomains, competitorDomains) {
-  if (!answerText || answerText.length < 20) return [];
-  const ownBrandKeys = new Set(
-    ownDomains.flatMap((domain) => collectBrandKeysFromDomain(domain))
-  );
-  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 hostname = normalizeProjectDomain(domain).split("/")[0] ?? "";
-  const labels = hostname.split(".").filter(Boolean);
-  const keys = /* @__PURE__ */ new Set();
-  const hostnameKey = hostname.replace(/[^a-z0-9]/gi, "").toLowerCase();
-  if (hostnameKey.length >= 4) keys.add(hostnameKey);
-  for (const label of labels) {
-    const key = label.replace(/[^a-z0-9]/gi, "").toLowerCase();
-    if (key.length >= 4) keys.add(key);
-  }
-  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/gsc-sync.ts
 import crypto19 from "crypto";
-import { eq as eq19, and as and8, sql as sql6 } from "drizzle-orm";
+import { eq as eq19, and as and8, sql as sql5 } from "drizzle-orm";
 var log2 = createLogger("GscSync");
 function formatDate2(d) {
   return d.toISOString().split("T")[0];
@@ -13687,8 +13094,8 @@ async function executeGscSync(db, runId, projectId, opts) {
     db.delete(gscSearchData).where(
       and8(
         eq19(gscSearchData.projectId, projectId),
-        sql6`${gscSearchData.date} >= ${startDate}`,
-        sql6`${gscSearchData.date} <= ${endDate}`
+        sql5`${gscSearchData.date} >= ${startDate}`,
+        sql5`${gscSearchData.date} <= ${endDate}`
       )
     ).run();
     const batchSize = 500;
@@ -14213,7 +13620,8 @@ var Notifier = class {
     if (lostTransitions.length > 0) events.push("citation.lost");
     if (gainedTransitions.length > 0) events.push("citation.gained");
     for (const notif of notifs) {
-      const config = JSON.parse(notif.config);
+      const config = parseJsonColumn(notif.config, { url: "", events: [] });
+      if (!config.url) continue;
       const subscribedEvents = config.events;
       const matchingEvents = events.filter((e) => subscribedEvents.includes(e));
       log5.info("notification.match", { notificationId: notif.id, subscribedEvents, matchedEvents: matchingEvents });
@@ -14323,380 +13731,8 @@ var Notifier = class {
   }
 };
 
-// src/intelligence-service.ts
-import { eq as eq23, desc as desc9, asc as asc2, and as and11, or as or3 } from "drizzle-orm";
-
-// ../intelligence/src/regressions.ts
-function detectRegressions(currentRun, previousRun) {
-  const regressions = [];
-  const previousCited = /* @__PURE__ */ new Map();
-  for (const snap of previousRun.snapshots) {
-    if (snap.cited) {
-      previousCited.set(`${snap.keyword}:${snap.provider}`, {
-        citationUrl: snap.citationUrl,
-        position: snap.position
-      });
-    }
-  }
-  for (const snap of currentRun.snapshots) {
-    const key = `${snap.keyword}:${snap.provider}`;
-    if (!snap.cited && previousCited.has(key)) {
-      const prev = previousCited.get(key);
-      regressions.push({
-        keyword: snap.keyword,
-        provider: snap.provider,
-        previousCitationUrl: prev.citationUrl,
-        previousPosition: prev.position,
-        currentRunId: currentRun.runId,
-        previousRunId: previousRun.runId
-      });
-    }
-  }
-  return regressions;
-}
-
-// ../intelligence/src/gains.ts
-function detectGains(currentRun, previousRun) {
-  const gains = [];
-  const previousCited = /* @__PURE__ */ new Set();
-  for (const snap of previousRun.snapshots) {
-    if (snap.cited) {
-      previousCited.add(`${snap.keyword}:${snap.provider}`);
-    }
-  }
-  for (const snap of currentRun.snapshots) {
-    const key = `${snap.keyword}:${snap.provider}`;
-    if (snap.cited && !previousCited.has(key)) {
-      gains.push({
-        keyword: snap.keyword,
-        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 currentSnap = currentSnapshots.find(
-    (s) => s.keyword === regression.keyword && s.provider === regression.provider && !s.cited && s.competitorDomain
-  );
-  if (currentSnap) {
-    return {
-      cause: "competitor_gain",
-      competitorDomain: currentSnap.competitorDomain,
-      details: `Competitor ${currentSnap.competitorDomain} now cited for "${regression.keyword}" on ${regression.provider}`
-    };
-  }
-  return {
-    cause: "unknown",
-    details: `No specific cause identified for loss of "${regression.keyword}" on ${regression.provider}`
-  };
-}
-
-// ../intelligence/src/insights.ts
-import { randomUUID } from "crypto";
-function generateInsights(regressions, gains, health, causes) {
-  const insights2 = [];
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  for (const reg of regressions) {
-    const key = `${reg.keyword}:${reg.provider}`;
-    const cause = causes.get(key);
-    insights2.push({
-      id: `ins_${randomUUID().slice(0, 8)}`,
-      type: "regression",
-      severity: "high",
-      title: `Lost ${reg.provider} citation for "${reg.keyword}"`,
-      keyword: reg.keyword,
-      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 gains) {
-    insights2.push({
-      id: `ins_${randomUUID().slice(0, 8)}`,
-      type: "gain",
-      severity: "low",
-      title: `New ${gain.provider} citation for "${gain.keyword}"`,
-      keyword: gain.keyword,
-      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
-    });
-  }
-  return insights2;
-}
-
-// ../intelligence/src/analyzer.ts
-function analyzeRuns(currentRun, previousRun, allRuns) {
-  const regressions = detectRegressions(currentRun, previousRun);
-  const gains = detectGains(currentRun, previousRun);
-  const health = computeHealth(currentRun);
-  const trend = allRuns ? computeHealthTrend(allRuns) : void 0;
-  const causes = /* @__PURE__ */ new Map();
-  for (const reg of regressions) {
-    const cause = analyzeCause(reg, currentRun.snapshots);
-    causes.set(`${reg.keyword}:${reg.provider}`, cause);
-  }
-  const insights2 = generateInsights(regressions, gains, health, causes);
-  return {
-    regressions,
-    gains,
-    health,
-    trend,
-    insights: insights2
-  };
-}
-
-// src/intelligence-service.ts
-import crypto22 from "crypto";
-var log6 = 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(
-      and11(
-        eq23(runs.projectId, projectId),
-        or3(eq23(runs.status, "completed"), eq23(runs.status, "partial"))
-      )
-    ).orderBy(desc9(runs.createdAt)).limit(2).all();
-    if (recentRuns.length === 0) {
-      log6.info("intelligence.skip", { runId, reason: "no completed runs" });
-      return null;
-    }
-    const currentRunRecord = recentRuns.find((r) => r.id === runId);
-    if (!currentRunRecord) {
-      log6.info("intelligence.skip", { runId, reason: "run not in recent completed list" });
-      return null;
-    }
-    const currentRun = this.buildRunData(runId, projectId, currentRunRecord.finishedAt ?? currentRunRecord.createdAt);
-    if (currentRun.snapshots.length === 0) {
-      log6.info("intelligence.skip", { runId, reason: "no snapshots" });
-      return null;
-    }
-    const previousRunRecord = recentRuns.find((r) => r.id !== runId);
-    const previousRun = previousRunRecord ? this.buildRunData(previousRunRecord.id, projectId, previousRunRecord.finishedAt ?? previousRunRecord.createdAt) : null;
-    if (!previousRun) {
-      const result2 = analyzeRuns(currentRun, currentRun);
-      log6.info("intelligence.analyzed", {
-        runId,
-        regressions: 0,
-        gains: 0,
-        citedRate: result2.health.overallCitedRate,
-        insights: 0
-      });
-      this.persistResult({ ...result2, insights: [], regressions: [], gains: [] }, runId, projectId);
-      return result2;
-    }
-    const result = analyzeRuns(currentRun, previousRun);
-    log6.info("intelligence.analyzed", {
-      runId,
-      regressions: result.regressions.length,
-      gains: result.gains.length,
-      citedRate: result.health.overallCitedRate,
-      insights: result.insights.length
-    });
-    this.persistResult(result, runId, projectId);
-    return result;
-  }
-  /**
-   * Analyze a single run given an explicit previous run (or null for first run).
-   * Used by backfill where we control the run ordering.
-   */
-  analyzeRunWithPrevious(runRecord, previousRunRecord) {
-    const currentRun = this.buildRunData(runRecord.id, runRecord.projectId, runRecord.finishedAt ?? runRecord.createdAt);
-    if (currentRun.snapshots.length === 0) {
-      return null;
-    }
-    const previousRun = previousRunRecord ? this.buildRunData(previousRunRecord.id, previousRunRecord.projectId, previousRunRecord.finishedAt ?? previousRunRecord.createdAt) : null;
-    if (!previousRun) {
-      const result2 = analyzeRuns(currentRun, currentRun);
-      this.persistResult({ ...result2, insights: [], regressions: [], gains: [] }, runRecord.id, runRecord.projectId);
-      return result2;
-    }
-    const result = analyzeRuns(currentRun, previousRun);
-    this.persistResult(result, runRecord.id, runRecord.projectId);
-    return result;
-  }
-  /**
-   * Backfill intelligence for all completed/partial runs of a project.
-   * Processes runs in chronological order so each run compares against its predecessor.
-   */
-  backfill(projectName, opts, onProgress) {
-    const project = this.db.select().from(projects).where(eq23(projects.name, projectName)).get();
-    if (!project) {
-      throw new Error(`Project "${projectName}" not found`);
-    }
-    const allRuns = this.db.select().from(runs).where(
-      and11(
-        eq23(runs.projectId, project.id),
-        or3(eq23(runs.status, "completed"), eq23(runs.status, "partial"))
-      )
-    ).orderBy(asc2(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;
-    }
-    const targetRuns = allRuns.slice(startIdx, endIdx);
-    let processed = 0;
-    let skipped = 0;
-    let totalInsights = 0;
-    for (let i = 0; i < targetRuns.length; i++) {
-      const run = targetRuns[i];
-      const globalIdx = allRuns.indexOf(run);
-      const previousRun = globalIdx > 0 ? allRuns[globalIdx - 1] : null;
-      const result = this.analyzeRunWithPrevious(run, previousRun);
-      if (result) {
-        processed++;
-        totalInsights += 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 });
-      }
-    }
-    return { processed, skipped, totalInsights };
-  }
-  persistResult(result, runId, projectId) {
-    const previouslyDismissed = /* @__PURE__ */ new Set();
-    const existingInsights = this.db.select({ keyword: insights.keyword, provider: insights.provider, type: insights.type, dismissed: insights.dismissed }).from(insights).where(eq23(insights.runId, runId)).all();
-    for (const row of existingInsights) {
-      if (row.dismissed) {
-        previouslyDismissed.add(`${row.keyword}:${row.provider}:${row.type}`);
-      }
-    }
-    this.db.transaction((tx) => {
-      tx.delete(insights).where(eq23(insights.runId, runId)).run();
-      tx.delete(healthSnapshots).where(eq23(healthSnapshots.runId, runId)).run();
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      for (const insight of result.insights) {
-        const wasDismissed = previouslyDismissed.has(`${insight.keyword}:${insight.provider}:${insight.type}`);
-        tx.insert(insights).values({
-          id: insight.id,
-          projectId,
-          runId,
-          type: insight.type,
-          severity: insight.severity,
-          title: insight.title,
-          keyword: insight.keyword,
-          provider: insight.provider,
-          recommendation: insight.recommendation ? JSON.stringify(insight.recommendation) : null,
-          cause: insight.cause ? JSON.stringify(insight.cause) : null,
-          dismissed: wasDismissed,
-          createdAt: insight.createdAt
-        }).run();
-      }
-      tx.insert(healthSnapshots).values({
-        id: crypto22.randomUUID(),
-        projectId,
-        runId,
-        overallCitedRate: String(result.health.overallCitedRate),
-        totalPairs: result.health.totalPairs,
-        citedPairs: result.health.citedPairs,
-        providerBreakdown: JSON.stringify(result.health.providerBreakdown),
-        createdAt: now
-      }).run();
-    });
-    log6.info("intelligence.persisted", { runId, insights: result.insights.length });
-  }
-  buildRunData(runId, projectId, completedAt) {
-    const rows = this.db.select({
-      keyword: keywords.keyword,
-      provider: querySnapshots.provider,
-      citationState: querySnapshots.citationState,
-      citedDomains: querySnapshots.citedDomains,
-      competitorOverlap: querySnapshots.competitorOverlap
-    }).from(querySnapshots).leftJoin(keywords, eq23(querySnapshots.keywordId, keywords.id)).where(eq23(querySnapshots.runId, runId)).all();
-    const snapshots = rows.map((r) => {
-      const domains = parseJsonColumn(r.citedDomains, []);
-      const competitors2 = parseJsonColumn(r.competitorOverlap, []);
-      return {
-        keyword: r.keyword ?? "",
-        provider: r.provider,
-        cited: r.citationState === "cited",
-        citationUrl: domains[0] ?? void 0,
-        competitorDomain: competitors2[0] ?? void 0
-      };
-    });
-    return { runId, projectId, completedAt, snapshots };
-  }
-};
-
 // src/run-coordinator.ts
-var log7 = createLogger("RunCoordinator");
+var log6 = createLogger("RunCoordinator");
 var RunCoordinator = class {
   constructor(notifier, intelligenceService) {
     this.notifier = notifier;
@@ -14706,12 +13742,12 @@ var RunCoordinator = class {
     try {
       this.intelligenceService.analyzeAndPersist(runId, projectId);
     } catch (err) {
-      log7.error("intelligence.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+      log6.error("intelligence.failed", { runId, error: err instanceof Error ? err.message : String(err) });
     }
     try {
       await this.notifier.onRunCompleted(runId, projectId);
     } catch (err) {
-      log7.error("notifier.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+      log6.error("notifier.failed", { runId, error: err instanceof Error ? err.message : String(err) });
     }
   }
 };
@@ -14814,20 +13850,20 @@ async function fetchSiteText(domain) {
 }
 function stripHtml2(html) {
   if (!html) return "";
-  let text2 = html.replace(/<script[\s\S]*?<\/script>/gi, " ");
-  text2 = text2.replace(/<style[\s\S]*?<\/style>/gi, " ");
-  text2 = text2.replace(/<[^>]+>/g, " ");
-  text2 = text2.replace(/&amp;/g, "&");
-  text2 = text2.replace(/&lt;/g, "<");
-  text2 = text2.replace(/&gt;/g, ">");
-  text2 = text2.replace(/&quot;/g, '"');
-  text2 = text2.replace(/&#39;/g, "'");
-  text2 = text2.replace(/&nbsp;/g, " ");
-  text2 = text2.replace(/\s+/g, " ").trim();
-  if (text2.length > MAX_TEXT_LENGTH) {
-    text2 = text2.slice(0, MAX_TEXT_LENGTH);
-  }
-  return text2;
+  let text = html.replace(/<script[\s\S]*?<\/script>/gi, " ");
+  text = text.replace(/<style[\s\S]*?<\/style>/gi, " ");
+  text = text.replace(/<[^>]+>/g, " ");
+  text = text.replace(/&amp;/g, "&");
+  text = text.replace(/&lt;/g, "<");
+  text = text.replace(/&gt;/g, ">");
+  text = text.replace(/&quot;/g, '"');
+  text = text.replace(/&#39;/g, "'");
+  text = text.replace(/&nbsp;/g, " ");
+  text = text.replace(/\s+/g, " ").trim();
+  if (text.length > MAX_TEXT_LENGTH) {
+    text = text.slice(0, MAX_TEXT_LENGTH);
+  }
+  return text;
 }
 
 // src/snapshot-format.ts
@@ -14836,7 +13872,7 @@ function formatAuditFactorScore(factor) {
 }
 
 // src/snapshot-service.ts
-var log8 = createLogger("Snapshot");
+var log7 = createLogger("Snapshot");
 var ANALYSIS_PROVIDER_PRIORITY = ["openai", "claude", "gemini", "perplexity", "local"];
 var SNAPSHOT_QUERY_COUNT = 6;
 var ProviderExecutionGate2 = class {
@@ -14979,7 +14015,7 @@ var SnapshotService = class {
       return mapAuditReport(report);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      log8.warn("audit.failed", { homepageUrl, error: message });
+      log7.warn("audit.failed", { homepageUrl, error: message });
       return {
         url: homepageUrl,
         finalUrl: homepageUrl,
@@ -15009,7 +14045,7 @@ var SnapshotService = class {
           phrases: parsedPhrases
         };
       } catch (err) {
-        log8.warn("profile.generation-failed", {
+        log7.warn("profile.generation-failed", {
           domain: ctx.domain,
           provider: ctx.analysisProvider.adapter.name,
           error: err instanceof Error ? err.message : String(err)
@@ -15151,7 +14187,7 @@ var SnapshotService = class {
         recommendedActions: uniqueStrings(parsed.recommendedActions ?? []).slice(0, 4)
       };
     } catch (err) {
-      log8.warn("response.analysis-failed", {
+      log7.warn("response.analysis-failed", {
         provider: ctx.analysisProvider.adapter.name,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -15436,7 +14472,7 @@ function clipText(value, length) {
 // src/server.ts
 var _require2 = createRequire2(import.meta.url);
 var { version: PKG_VERSION } = _require2("../package.json");
-var log9 = createLogger("Server");
+var log8 = createLogger("Server");
 var DEFAULT_QUOTA = {
   maxConcurrency: 2,
   maxRequestsPerMinute: 10,
@@ -15467,7 +14503,7 @@ function summarizeProviderConfig(provider, config) {
   };
 }
 function hashApiKey(key) {
-  return crypto23.createHash("sha256").update(key).digest("hex");
+  return crypto22.createHash("sha256").update(key).digest("hex");
 }
 function parseCookies2(header) {
   if (!header) return {};
@@ -15526,7 +14562,7 @@ async function createServer(opts) {
       quota: opts.config.geminiQuota
     };
   }
-  log9.info("providers.configured", { providers: Object.keys(providers).filter((k) => {
+  log8.info("providers.configured", { providers: Object.keys(providers).filter((k) => {
     const p = providers[k];
     return p?.apiKey || p?.baseUrl || p?.vertexProject;
   }) });
@@ -15641,7 +14677,7 @@ async function createServer(opts) {
       return removed;
     }
   };
-  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto23.randomBytes(32).toString("hex");
+  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto22.randomBytes(32).toString("hex");
   const googleConnectionStore = {
     listConnections: (domain) => listGoogleConnections(opts.config, domain),
     getConnection: (domain, connectionType) => getGoogleConnection(opts.config, domain, connectionType),
@@ -15687,11 +14723,11 @@ async function createServer(opts) {
   const apiPrefix = basePath ? `${basePath}api/v1` : "/api/v1";
   if (opts.config.apiKey) {
     const keyHash = hashApiKey(opts.config.apiKey);
-    const existing = opts.db.select().from(apiKeys).where(eq24(apiKeys.keyHash, keyHash)).get();
+    const existing = opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, keyHash)).get();
     if (!existing) {
       const prefix = opts.config.apiKey.slice(0, 12);
       opts.db.insert(apiKeys).values({
-        id: `key_${crypto23.randomBytes(8).toString("hex")}`,
+        id: `key_${crypto22.randomBytes(8).toString("hex")}`,
         name: "default",
         keyHash,
         keyPrefix: prefix,
@@ -15715,7 +14751,7 @@ async function createServer(opts) {
   };
   const createSession = (apiKeyId) => {
     pruneExpiredSessions();
-    const sessionId = crypto23.randomBytes(32).toString("hex");
+    const sessionId = crypto22.randomBytes(32).toString("hex");
     sessions.set(sessionId, {
       apiKeyId,
       expiresAt: Date.now() + SESSION_TTL_MS
@@ -15739,7 +14775,7 @@ async function createServer(opts) {
   };
   const getDefaultApiKey = () => {
     if (!opts.config.apiKey) return void 0;
-    return opts.db.select().from(apiKeys).where(eq24(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
+    return opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
   };
   const createPasswordSession = (reply) => {
     const key = getDefaultApiKey();
@@ -15796,12 +14832,12 @@ async function createServer(opts) {
       return reply.send({ authenticated: true });
     }
     if (apiKey) {
-      const key = opts.db.select().from(apiKeys).where(eq24(apiKeys.keyHash, hashApiKey(apiKey))).get();
+      const key = opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, hashApiKey(apiKey))).get();
       if (!key || key.revokedAt) {
         const err2 = authInvalid();
         return reply.status(err2.statusCode).send(err2.toJSON());
       }
-      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq24(apiKeys.id, key.id)).run();
+      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq23(apiKeys.id, key.id)).run();
       const sessionId = createSession(key.id);
       reply.header("set-cookie", serializeSessionCookie({
         name: SESSION_COOKIE_NAME,
@@ -15936,17 +14972,13 @@ async function createServer(opts) {
           after: afterConfig
         });
         const affectedProjectIds = opts.db.select({ id: projects.id, providers: projects.providers }).from(projects).all().filter((project) => {
-          try {
-            const configuredProviders = JSON.parse(project.providers || "[]");
-            return configuredProviders.length === 0 || configuredProviders.includes(name);
-          } catch {
-            return false;
-          }
+          const configuredProviders = parseJsonColumn(project.providers, []);
+          return configuredProviders.length === 0 || configuredProviders.includes(name);
         }).map((project) => project.id);
         const targetProjectIds = affectedProjectIds.length > 0 ? affectedProjectIds : [null];
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
         opts.db.insert(auditLog).values(targetProjectIds.map((projectId) => ({
-          id: crypto23.randomUUID(),
+          id: crypto22.randomUUID(),
           projectId,
           actor: "api",
           action: existing ? "provider.updated" : "provider.created",
@@ -16077,8 +15109,8 @@ async function createServer(opts) {
       return snapshotService.createReport(input);
     }
   });
-  const dirname2 = path6.dirname(fileURLToPath(import.meta.url));
-  const assetsDir = path6.join(dirname2, "..", "assets");
+  const dirname = path6.dirname(fileURLToPath(import.meta.url));
+  const assetsDir = path6.join(dirname, "..", "assets");
   if (fs5.existsSync(assetsDir)) {
     const indexPath = path6.join(assetsDir, "index.html");
     const injectConfig = (html) => {
@@ -16200,19 +15232,20 @@ export {
   isFirstRun,
   showFirstRunNotice,
   trackEvent,
-  projects,
-  runs,
-  querySnapshots,
-  apiKeys,
-  createClient,
-  parseJsonColumn,
-  migrate,
   providerQuotaPolicySchema,
+  ProviderNames,
   resolveProviderInput,
   notificationEventSchema,
   effectiveDomains,
+  RunKinds,
   determineAnswerMentioned,
-  IntelligenceService,
+  reparseStoredResult2 as reparseStoredResult,
+  reparseStoredResult3 as reparseStoredResult2,
+  reparseStoredResult as reparseStoredResult3,
+  reparseStoredResult4,
+  determineCitationState,
+  computeCompetitorOverlap,
+  extractRecommendedCompetitors,
   setGoogleAuthConfig,
   formatAuditFactorScore,
   createServer