@ainyc/canonry 1.39.4 → 1.40.0

package/dist/chunk-FOWWBLXD.js

@@ -0,0 +1,1218 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/intelligence-service.ts
+import { eq, desc, asc, and, or } 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;
+    }
+  }
+}
+
+// ../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 crypto from "crypto";
+
+// src/logger.ts
+var IS_TTY = process.stdout.isTTY === true;
+function formatTTY(entry) {
+  const { ts, level, module, action, msg, ...ctx } = entry;
+  const time = ts.slice(11, 19);
+  const levelTag = level === "error" ? "\x1B[31mERR\x1B[0m" : level === "warn" ? "\x1B[33mWRN\x1B[0m" : "\x1B[36mINF\x1B[0m";
+  const ctxParts = Object.entries(ctx).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+  const msgPart = msg ? ` ${msg}` : "";
+  const ctxPart = ctxParts ? ` ${ctxParts}` : "";
+  return `${time} ${levelTag} [${module}] ${action}${msgPart}${ctxPart}`;
+}
+function emit(entry) {
+  const stream = entry.level === "error" ? process.stderr : process.stdout;
+  if (IS_TTY) {
+    stream.write(formatTTY(entry) + "\n");
+  } else {
+    stream.write(JSON.stringify(entry) + "\n");
+  }
+}
+function createLogger(module) {
+  function log2(level, action, ctx) {
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      module,
+      action,
+      ...ctx
+    };
+    emit(entry);
+  }
+  return {
+    info: (action, ctx) => log2("info", action, ctx),
+    warn: (action, ctx) => log2("warn", action, ctx),
+    error: (action, ctx) => log2("error", action, ctx)
+  };
+}
+
+// src/intelligence-service.ts
+var log = createLogger("IntelligenceService");
+var IntelligenceService = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Analyze a completed run and persist insights + health snapshot.
+   * Idempotent: deletes prior results for the same runId before inserting.
+   * Returns the analysis result for the coordinator to inspect (e.g. for webhook dispatch).
+   */
+  analyzeAndPersist(runId, projectId) {
+    const recentRuns = this.db.select().from(runs).where(
+      and(
+        eq(runs.projectId, projectId),
+        or(eq(runs.status, "completed"), eq(runs.status, "partial"))
+      )
+    ).orderBy(desc(runs.createdAt)).limit(2).all();
+    if (recentRuns.length === 0) {
+      log.info("intelligence.skip", { runId, reason: "no completed runs" });
+      return null;
+    }
+    const currentRunRecord = recentRuns.find((r) => r.id === runId);
+    if (!currentRunRecord) {
+      log.info("intelligence.skip", { runId, reason: "run not in recent completed list" });
+      return null;
+    }
+    const currentRun = this.buildRunData(runId, projectId, currentRunRecord.finishedAt ?? currentRunRecord.createdAt);
+    if (currentRun.snapshots.length === 0) {
+      log.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);
+      log.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);
+    log.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(eq(projects.name, projectName)).get();
+    if (!project) {
+      throw new Error(`Project "${projectName}" not found`);
+    }
+    const allRuns = this.db.select().from(runs).where(
+      and(
+        eq(runs.projectId, project.id),
+        or(eq(runs.status, "completed"), eq(runs.status, "partial"))
+      )
+    ).orderBy(asc(runs.finishedAt)).all();
+    let startIdx = 0;
+    let endIdx = allRuns.length;
+    if (opts?.fromRunId) {
+      const idx = allRuns.findIndex((r) => r.id === opts.fromRunId);
+      if (idx === -1) throw new Error(`Run "${opts.fromRunId}" not found in project`);
+      startIdx = idx;
+    }
+    if (opts?.toRunId) {
+      const idx = allRuns.findIndex((r) => r.id === opts.toRunId);
+      if (idx === -1) throw new Error(`Run "${opts.toRunId}" not found in project`);
+      endIdx = idx + 1;
+    }
+    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(eq(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(eq(insights.runId, runId)).run();
+      tx.delete(healthSnapshots).where(eq(healthSnapshots.runId, runId)).run();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const insight of result.insights) {
+        const wasDismissed = previouslyDismissed.has(`${insight.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: crypto.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();
+    });
+    log.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, eq(querySnapshots.keywordId, keywords.id)).where(eq(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 };
+  }
+};
+
+export {
+  projects,
+  keywords,
+  competitors,
+  runs,
+  querySnapshots,
+  auditLog,
+  apiKeys,
+  schedules,
+  notifications,
+  gscSearchData,
+  gscUrlInspections,
+  gscCoverageSnapshots,
+  bingUrlInspections,
+  gaTrafficSnapshots,
+  gaAiReferrals,
+  gaTrafficSummaries,
+  usageCounters,
+  insights,
+  healthSnapshots,
+  createClient,
+  parseJsonColumn,
+  migrate,
+  createLogger,
+  IntelligenceService
+};