@ainyc/canonry 4.78.0 → 4.81.0

package/dist/{chunk-3WXARKUE.js → chunk-UAQ42NVJ.js}

@@ -3,6 +3,7 @@ import {
   AI_ENGINE_DOMAINS,
   AI_PROVIDER_INFRA_DOMAINS,
   AppError,
+  BacklinkSources,
   CcReleaseSyncStatuses,
   CheckCategories,
   CheckScopes,
@@ -34,6 +35,16 @@ import {
   __export,
   absolutizeProjectUrl,
   actionConfidenceLabel,
+  adsCampaignListResponseSchema,
+  adsConnectRequestSchema,
+  adsConnectionStatusDtoSchema,
+  adsCpcMicros,
+  adsCtr,
+  adsDisconnectResponseSchema,
+  adsInsightLevelSchema,
+  adsInsightsResponseSchema,
+  adsSummaryDtoSchema,
+  adsSyncResponseSchema,
   agentProvidersResponseDtoSchema,
   apiKeyDtoSchema,
   apiKeyListDtoSchema,
@@ -42,6 +53,8 @@ import {
   authRequired,
   backlinkHistoryEntrySchema,
   backlinkListResponseSchema,
+  backlinkSourceSchema,
+  backlinkSourcesResponseSchema,
   backlinkSummaryDtoSchema,
   backlinksInstallResultDtoSchema,
   backlinksInstallStatusDtoSchema,
@@ -232,10 +245,10 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-KPN22EWK.js";
+} from "./chunk-GMT3YPLT.js";
 
 // src/intelligence-service.ts
-import { eq as eq33, desc as desc17, asc as asc4, and as and24, ne as ne5, or as or5, inArray as inArray12, gte as gte6, lte as lte3 } from "drizzle-orm";
+import { eq as eq36, desc as desc17, asc as asc5, and as and26, ne as ne5, or as or5, inArray as inArray13, gte as gte7, lte as lte4 } from "drizzle-orm";
 
 // ../db/src/client.ts
 import { mkdirSync } from "fs";
@@ -246,6 +259,11 @@ import { drizzle } from "drizzle-orm/better-sqlite3";
 // ../db/src/schema.ts
 var schema_exports = {};
 __export(schema_exports, {
+  adsAdGroups: () => adsAdGroups,
+  adsAds: () => adsAds,
+  adsCampaigns: () => adsCampaigns,
+  adsConnections: () => adsConnections,
+  adsInsightsDaily: () => adsInsightsDaily,
   agentMemory: () => agentMemory,
   agentSessions: () => agentSessions,
   aiReferralEventsHourly: () => aiReferralEventsHourly,
@@ -835,7 +853,9 @@ var ccReleaseSyncs = sqliteTable("cc_release_syncs", {
 var backlinkDomains = sqliteTable("backlink_domains", {
   id: text("id").primaryKey(),
   projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  releaseSyncId: text("release_sync_id").notNull().references(() => ccReleaseSyncs.id, { onDelete: "cascade" }),
+  // Nullable: Bing Webmaster backlink rows have no Common Crawl release sync.
+  releaseSyncId: text("release_sync_id").references(() => ccReleaseSyncs.id, { onDelete: "cascade" }),
+  source: text("source").$type().notNull().default("commoncrawl"),
   release: text("release").notNull(),
   targetDomain: text("target_domain").notNull(),
   linkingDomain: text("linking_domain").notNull(),
@@ -846,12 +866,14 @@ var backlinkDomains = sqliteTable("backlink_domains", {
   index("idx_backlink_domains_release_sync").on(table.releaseSyncId),
   index("idx_backlink_domains_project_release").on(table.projectId, table.release),
   index("idx_backlink_domains_hosts").on(table.numHosts),
-  uniqueIndex("idx_backlink_domains_unique").on(table.projectId, table.release, table.linkingDomain)
+  uniqueIndex("idx_backlink_domains_unique").on(table.projectId, table.source, table.release, table.linkingDomain)
 ]);
 var backlinkSummaries = sqliteTable("backlink_summaries", {
   id: text("id").primaryKey(),
   projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-  releaseSyncId: text("release_sync_id").notNull().references(() => ccReleaseSyncs.id, { onDelete: "cascade" }),
+  // Nullable: Bing Webmaster summaries have no Common Crawl release sync.
+  releaseSyncId: text("release_sync_id").references(() => ccReleaseSyncs.id, { onDelete: "cascade" }),
+  source: text("source").$type().notNull().default("commoncrawl"),
   release: text("release").notNull(),
   targetDomain: text("target_domain").notNull(),
   totalLinkingDomains: integer("total_linking_domains").notNull(),
@@ -860,7 +882,7 @@ var backlinkSummaries = sqliteTable("backlink_summaries", {
   queriedAt: text("queried_at").notNull(),
   createdAt: text("created_at").notNull()
 }, (table) => [
-  uniqueIndex("idx_backlink_summaries_project_release").on(table.projectId, table.release),
+  uniqueIndex("idx_backlink_summaries_project_release").on(table.projectId, table.source, table.release),
   index("idx_backlink_summaries_project").on(table.projectId)
 ]);
 var agentMemory = sqliteTable("agent_memory", {
@@ -1219,6 +1241,83 @@ var gbpPlaceDetails = sqliteTable("gbp_place_details", {
 }, (table) => [
   index("idx_gbp_place_details_loc").on(table.projectId, table.locationName, table.syncedAt)
 ]);
+var adsConnections = sqliteTable("ads_connections", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  adAccountId: text("ad_account_id").notNull(),
+  displayName: text("display_name"),
+  currencyCode: text("currency_code"),
+  timezone: text("timezone"),
+  status: text("status"),
+  lastSyncedAt: text("last_synced_at"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+}, (table) => [
+  uniqueIndex("idx_ads_conn_project").on(table.projectId)
+]);
+var adsCampaigns = sqliteTable("ads_campaigns", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  status: text("status").notNull(),
+  biddingType: text("bidding_type"),
+  dailySpendLimitMicros: integer("daily_spend_limit_micros"),
+  lifetimeSpendLimitMicros: integer("lifetime_spend_limit_micros"),
+  targeting: text("targeting", { mode: "json" }).$type(),
+  upstreamCreatedAt: integer("upstream_created_at"),
+  upstreamUpdatedAt: integer("upstream_updated_at"),
+  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "set null" }),
+  syncedAt: text("synced_at").notNull()
+}, (table) => [
+  index("idx_ads_campaigns_project").on(table.projectId)
+]);
+var adsAdGroups = sqliteTable("ads_ad_groups", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  campaignId: text("campaign_id").notNull().references(() => adsCampaigns.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  status: text("status").notNull(),
+  billingEventType: text("billing_event_type"),
+  maxBidMicros: integer("max_bid_micros"),
+  contextHints: text("context_hints", { mode: "json" }).$type().notNull().default([]),
+  upstreamCreatedAt: integer("upstream_created_at"),
+  upstreamUpdatedAt: integer("upstream_updated_at"),
+  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "set null" }),
+  syncedAt: text("synced_at").notNull()
+}, (table) => [
+  index("idx_ads_ad_groups_project").on(table.projectId),
+  index("idx_ads_ad_groups_campaign").on(table.campaignId)
+]);
+var adsAds = sqliteTable("ads_ads", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  adGroupId: text("ad_group_id").notNull().references(() => adsAdGroups.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  status: text("status").notNull(),
+  creative: text("creative", { mode: "json" }).$type(),
+  reviewStatus: text("review_status"),
+  upstreamCreatedAt: integer("upstream_created_at"),
+  upstreamUpdatedAt: integer("upstream_updated_at"),
+  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "set null" }),
+  syncedAt: text("synced_at").notNull()
+}, (table) => [
+  index("idx_ads_ads_project").on(table.projectId),
+  index("idx_ads_ads_group").on(table.adGroupId)
+]);
+var adsInsightsDaily = sqliteTable("ads_insights_daily", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  level: text("level").notNull(),
+  entityId: text("entity_id").notNull(),
+  date: text("date").notNull(),
+  impressions: integer("impressions").notNull().default(0),
+  clicks: integer("clicks").notNull().default(0),
+  spendMicros: integer("spend_micros").notNull().default(0),
+  syncRunId: text("sync_run_id").references(() => runs.id, { onDelete: "set null" })
+}, (table) => [
+  uniqueIndex("uniq_ads_insights_daily").on(table.projectId, table.level, table.entityId, table.date),
+  index("idx_ads_insights_project_date").on(table.projectId, table.date)
+]);
 
 // ../db/src/client.ts
 function createClient(databasePath) {
@@ -2876,8 +2975,169 @@ var MIGRATION_VERSIONS = [
     statements: [
       `ALTER TABLE discovery_sessions ADD COLUMN warning TEXT`
     ]
+  },
+  {
+    // OpenAI Advertiser API (ChatGPT ads) — connection metadata, entity
+    // snapshots (campaigns / ad groups / ads), and daily paid-performance
+    // rollups. One connection per project (ad accounts are not domain-bound).
+    // Money columns are integer micros; ads-sync normalizes the insights
+    // API's decimal-dollar spend at ingest. Credentials live in config.yaml.
+    version: 77,
+    name: "openai-ads-tables",
+    statements: [
+      `CREATE TABLE IF NOT EXISTS ads_connections (
+        id             TEXT PRIMARY KEY,
+        project_id     TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        ad_account_id  TEXT NOT NULL,
+        display_name   TEXT,
+        currency_code  TEXT,
+        timezone       TEXT,
+        status         TEXT,
+        last_synced_at TEXT,
+        created_at     TEXT NOT NULL,
+        updated_at     TEXT NOT NULL
+      )`,
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_ads_conn_project ON ads_connections(project_id)`,
+      `CREATE TABLE IF NOT EXISTS ads_campaigns (
+        id                          TEXT PRIMARY KEY,
+        project_id                  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        name                        TEXT NOT NULL,
+        status                      TEXT NOT NULL,
+        bidding_type                TEXT,
+        daily_spend_limit_micros    INTEGER,
+        lifetime_spend_limit_micros INTEGER,
+        targeting                   TEXT,
+        upstream_created_at         INTEGER,
+        upstream_updated_at         INTEGER,
+        sync_run_id                 TEXT REFERENCES runs(id) ON DELETE SET NULL,
+        synced_at                   TEXT NOT NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS idx_ads_campaigns_project ON ads_campaigns(project_id)`,
+      `CREATE TABLE IF NOT EXISTS ads_ad_groups (
+        id                  TEXT PRIMARY KEY,
+        project_id          TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        campaign_id         TEXT NOT NULL REFERENCES ads_campaigns(id) ON DELETE CASCADE,
+        name                TEXT NOT NULL,
+        status              TEXT NOT NULL,
+        billing_event_type  TEXT,
+        max_bid_micros      INTEGER,
+        context_hints       TEXT NOT NULL DEFAULT '[]',
+        upstream_created_at INTEGER,
+        upstream_updated_at INTEGER,
+        sync_run_id         TEXT REFERENCES runs(id) ON DELETE SET NULL,
+        synced_at           TEXT NOT NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS idx_ads_ad_groups_project ON ads_ad_groups(project_id)`,
+      `CREATE INDEX IF NOT EXISTS idx_ads_ad_groups_campaign ON ads_ad_groups(campaign_id)`,
+      `CREATE TABLE IF NOT EXISTS ads_ads (
+        id                  TEXT PRIMARY KEY,
+        project_id          TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        ad_group_id         TEXT NOT NULL REFERENCES ads_ad_groups(id) ON DELETE CASCADE,
+        name                TEXT NOT NULL,
+        status              TEXT NOT NULL,
+        creative            TEXT,
+        review_status       TEXT,
+        upstream_created_at INTEGER,
+        upstream_updated_at INTEGER,
+        sync_run_id         TEXT REFERENCES runs(id) ON DELETE SET NULL,
+        synced_at           TEXT NOT NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS idx_ads_ads_project ON ads_ads(project_id)`,
+      `CREATE INDEX IF NOT EXISTS idx_ads_ads_group ON ads_ads(ad_group_id)`,
+      `CREATE TABLE IF NOT EXISTS ads_insights_daily (
+        id           TEXT PRIMARY KEY,
+        project_id   TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        level        TEXT NOT NULL,
+        entity_id    TEXT NOT NULL,
+        date         TEXT NOT NULL,
+        impressions  INTEGER NOT NULL DEFAULT 0,
+        clicks       INTEGER NOT NULL DEFAULT 0,
+        spend_micros INTEGER NOT NULL DEFAULT 0,
+        sync_run_id  TEXT REFERENCES runs(id) ON DELETE SET NULL
+      )`,
+      `CREATE UNIQUE INDEX IF NOT EXISTS uniq_ads_insights_daily ON ads_insights_daily(project_id, level, entity_id, date)`,
+      `CREATE INDEX IF NOT EXISTS idx_ads_insights_project_date ON ads_insights_daily(project_id, date)`
+    ]
+  },
+  {
+    // Bing Webmaster inbound links land in the SAME backlink store as Common
+    // Crawl, tagged by a `source` discriminator (commoncrawl | bing-webmaster).
+    // Bing rows have no `cc_release_syncs` row, so `release_sync_id` becomes
+    // nullable and the per-window UNIQUE gains `source`. SQLite can't drop a
+    // NOT NULL or rewrite a UNIQUE in place — canonical table rebuild (the
+    // v58/v60 pattern). Guarded on the `source` column's absence so a replay
+    // over the already-migrated schema is a no-op (the hardcoded
+    // `source='commoncrawl'` backfill must never clobber real bing rows).
+    version: 78,
+    name: "backlinks-source-discriminator",
+    statements: [],
+    run: (tx) => {
+      addBacklinkSourceDiscriminator(tx);
+    }
   }
 ];
+function rebuildBacklinkTableWithSource(tx, table) {
+  if (!tableExists(tx, table)) return;
+  if (columnExists(tx, table, "source")) return;
+  if (table === "backlink_domains") {
+    tx.run(sql.raw(`DROP TABLE IF EXISTS backlink_domains_v78`));
+    tx.run(sql.raw(`CREATE TABLE backlink_domains_v78 (
+      id               TEXT PRIMARY KEY,
+      project_id       TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      release_sync_id  TEXT REFERENCES cc_release_syncs(id) ON DELETE CASCADE,
+      source           TEXT NOT NULL DEFAULT 'commoncrawl',
+      release          TEXT NOT NULL,
+      target_domain    TEXT NOT NULL,
+      linking_domain   TEXT NOT NULL,
+      num_hosts        INTEGER NOT NULL,
+      created_at       TEXT NOT NULL
+    )`));
+    tx.run(sql.raw(`INSERT INTO backlink_domains_v78
+        (id, project_id, release_sync_id, source, release, target_domain, linking_domain, num_hosts, created_at)
+      SELECT bd.id, bd.project_id,
+             CASE WHEN bd.release_sync_id IN (SELECT id FROM cc_release_syncs) THEN bd.release_sync_id ELSE NULL END,
+             'commoncrawl', bd.release, bd.target_domain, bd.linking_domain, bd.num_hosts, bd.created_at
+      FROM backlink_domains bd
+      WHERE bd.project_id IN (SELECT id FROM projects)`));
+    tx.run(sql.raw(`DROP TABLE backlink_domains`));
+    tx.run(sql.raw(`ALTER TABLE backlink_domains_v78 RENAME TO backlink_domains`));
+    tx.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_backlink_domains_project ON backlink_domains(project_id)`));
+    tx.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_backlink_domains_release_sync ON backlink_domains(release_sync_id)`));
+    tx.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_backlink_domains_project_release ON backlink_domains(project_id, release)`));
+    tx.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_backlink_domains_hosts ON backlink_domains(num_hosts)`));
+    tx.run(sql.raw(`CREATE UNIQUE INDEX IF NOT EXISTS idx_backlink_domains_unique ON backlink_domains(project_id, source, release, linking_domain)`));
+    return;
+  }
+  tx.run(sql.raw(`DROP TABLE IF EXISTS backlink_summaries_v78`));
+  tx.run(sql.raw(`CREATE TABLE backlink_summaries_v78 (
+    id                     TEXT PRIMARY KEY,
+    project_id             TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    release_sync_id        TEXT REFERENCES cc_release_syncs(id) ON DELETE CASCADE,
+    source                 TEXT NOT NULL DEFAULT 'commoncrawl',
+    release                TEXT NOT NULL,
+    target_domain          TEXT NOT NULL,
+    total_linking_domains  INTEGER NOT NULL,
+    total_hosts            INTEGER NOT NULL,
+    top_10_hosts_share     TEXT NOT NULL,
+    queried_at             TEXT NOT NULL,
+    created_at             TEXT NOT NULL
+  )`));
+  tx.run(sql.raw(`INSERT INTO backlink_summaries_v78
+      (id, project_id, release_sync_id, source, release, target_domain, total_linking_domains, total_hosts, top_10_hosts_share, queried_at, created_at)
+    SELECT bs.id, bs.project_id,
+           CASE WHEN bs.release_sync_id IN (SELECT id FROM cc_release_syncs) THEN bs.release_sync_id ELSE NULL END,
+           'commoncrawl', bs.release, bs.target_domain, bs.total_linking_domains, bs.total_hosts, bs.top_10_hosts_share, bs.queried_at, bs.created_at
+    FROM backlink_summaries bs
+    WHERE bs.project_id IN (SELECT id FROM projects)`));
+  tx.run(sql.raw(`DROP TABLE backlink_summaries`));
+  tx.run(sql.raw(`ALTER TABLE backlink_summaries_v78 RENAME TO backlink_summaries`));
+  tx.run(sql.raw(`CREATE UNIQUE INDEX IF NOT EXISTS idx_backlink_summaries_project_release ON backlink_summaries(project_id, source, release)`));
+  tx.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_backlink_summaries_project ON backlink_summaries(project_id)`));
+}
+function addBacklinkSourceDiscriminator(tx) {
+  rebuildBacklinkTableWithSource(tx, "backlink_domains");
+  rebuildBacklinkTableWithSource(tx, "backlink_summaries");
+}
 function isDuplicateColumnError(err) {
   if (!(err instanceof Error)) return false;
   if (err.message.includes("duplicate column name")) return true;
@@ -13020,11 +13280,18 @@ function makeSnippet(text2, query) {
 import { z } from "zod";
 var SCHEMA_TABLE = {
   AgentProvidersResponseDto: agentProvidersResponseDtoSchema,
+  AdsCampaignListResponse: adsCampaignListResponseSchema,
+  AdsConnectionStatusDto: adsConnectionStatusDtoSchema,
+  AdsDisconnectResponse: adsDisconnectResponseSchema,
+  AdsInsightsResponse: adsInsightsResponseSchema,
+  AdsSummaryDto: adsSummaryDtoSchema,
+  AdsSyncResponse: adsSyncResponseSchema,
   ApiKeyDto: apiKeyDtoSchema,
   ApiKeyListDto: apiKeyListDtoSchema,
   AuditLogEntry: auditLogEntrySchema,
   BacklinkHistoryEntry: backlinkHistoryEntrySchema,
   BacklinkListResponse: backlinkListResponseSchema,
+  BacklinkSourcesResponse: backlinkSourcesResponseSchema,
   BacklinkSummaryDto: backlinkSummaryDtoSchema,
   BacklinksInstallResultDto: backlinksInstallResultDtoSchema,
   BacklinksInstallStatusDto: backlinksInstallStatusDtoSchema,
@@ -15061,6 +15328,106 @@ var routeCatalog = [
       404: errorResponse("Project not found.")
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/ads/connect",
+    summary: "Connect an OpenAI ad account (ChatGPT ads) with an Ads Manager SDK key",
+    tags: ["ads"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["apiKey"],
+            properties: {
+              apiKey: stringSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: jsonResponse("Connected; key validated against the upstream ad account.", "AdsConnectionStatusDto"),
+      400: errorResponse("Missing/invalid key or credential storage unavailable."),
+      404: errorResponse("Project not found.")
+    }
+  },
+  {
+    method: "delete",
+    path: "/api/v1/projects/{name}/ads/connection",
+    summary: "Disconnect the OpenAI ad account (removes the stored credential)",
+    tags: ["ads"],
+    parameters: [nameParameter],
+    responses: {
+      200: jsonResponse("Disconnected (idempotent).", "AdsDisconnectResponse"),
+      404: errorResponse("Project not found.")
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/ads/status",
+    summary: "OpenAI ads connection status and last sync time",
+    tags: ["ads"],
+    parameters: [nameParameter],
+    responses: {
+      200: jsonResponse("Connection status.", "AdsConnectionStatusDto"),
+      404: errorResponse("Project not found.")
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/ads/sync",
+    summary: "Trigger an ads-sync run (entity snapshots + daily paid-performance rollups)",
+    tags: ["ads"],
+    parameters: [nameParameter],
+    responses: {
+      200: jsonResponse("Sync run queued.", "AdsSyncResponse"),
+      400: errorResponse("No ads connection for this project."),
+      404: errorResponse("Project not found.")
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/ads/campaigns",
+    summary: "Synced campaign snapshots with nested ad groups (context hints) and ads",
+    tags: ["ads"],
+    parameters: [nameParameter],
+    responses: {
+      200: jsonResponse("Campaign snapshots.", "AdsCampaignListResponse"),
+      404: errorResponse("Project not found.")
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/ads/insights",
+    summary: "Daily paid-performance rollups (spend in integer micros; ctr/cpc derived server-side)",
+    tags: ["ads"],
+    parameters: [
+      nameParameter,
+      { in: "query", name: "level", required: false, description: "campaign | ad_group", schema: stringSchema },
+      { in: "query", name: "entityId", required: false, description: "Scope to one upstream entity id", schema: stringSchema },
+      { in: "query", name: "from", required: false, description: "Inclusive start date (YYYY-MM-DD)", schema: stringSchema },
+      { in: "query", name: "to", required: false, description: "Inclusive end date (YYYY-MM-DD)", schema: stringSchema }
+    ],
+    responses: {
+      200: jsonResponse("Daily rollup rows.", "AdsInsightsResponse"),
+      400: errorResponse("Invalid level filter."),
+      404: errorResponse("Project not found.")
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/ads/summary",
+    summary: "Composite paid-performance summary (campaign-level totals; all derived metrics)",
+    tags: ["ads"],
+    parameters: [nameParameter],
+    responses: {
+      200: jsonResponse("Summary returned.", "AdsSummaryDto"),
+      404: errorResponse("Project not found.")
+    }
+  },
   {
     method: "post",
     path: "/api/v1/projects/{name}/bing/connect",
@@ -16385,7 +16752,8 @@ var routeCatalog = [
     tags: ["backlinks"],
     parameters: [
       nameParameter,
-      { name: "release", in: "query", description: "Release id filter.", schema: stringSchema }
+      { name: "release", in: "query", description: "Release id filter.", schema: stringSchema },
+      { name: "source", in: "query", description: "Backlink source: commoncrawl (default) or bing-webmaster.", schema: stringSchema }
     ],
     responses: {
       200: rawJsonResponse("Summary returned, or null when no backlinks exist.", {
@@ -16403,7 +16771,8 @@ var routeCatalog = [
       nameParameter,
       { name: "release", in: "query", description: "Release id filter.", schema: stringSchema },
       { name: "limit", in: "query", description: "Max results (1-500).", schema: stringSchema },
-      { name: "offset", in: "query", description: "Pagination offset.", schema: stringSchema }
+      { name: "offset", in: "query", description: "Pagination offset.", schema: stringSchema },
+      { name: "source", in: "query", description: "Backlink source: commoncrawl (default) or bing-webmaster.", schema: stringSchema }
     ],
     responses: {
       200: jsonResponse("Domain list returned.", "BacklinkListResponse"),
@@ -16415,12 +16784,44 @@ var routeCatalog = [
     path: "/api/v1/projects/{name}/backlinks/history",
     summary: "Get per-release backlink summaries for a project",
     tags: ["backlinks"],
-    parameters: [nameParameter],
+    parameters: [
+      nameParameter,
+      { name: "source", in: "query", description: "Backlink source: commoncrawl (default) or bing-webmaster.", schema: stringSchema }
+    ],
     responses: {
       200: jsonArrayResponse("History returned oldest-first by queriedAt.", "BacklinkHistoryEntry"),
       404: errorResponse("Project not found.")
     }
   },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/backlinks/sources",
+    summary: "Report per-source backlink availability for a project",
+    description: "Returns connection + data availability for every backlink source (commoncrawl, bing-webmaster) so callers can degrade gracefully across CC-only / Bing-only / both / neither.",
+    tags: ["backlinks"],
+    parameters: [
+      nameParameter,
+      { name: "excludeCrawlers", in: "query", description: 'When "1"/"true", count linking domains excluding crawler/proxy hosts (matches the dashboard). Default off.', schema: stringSchema }
+    ],
+    responses: {
+      200: jsonResponse("Per-source availability returned.", "BacklinkSourcesResponse"),
+      404: errorResponse("Project not found.")
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/backlinks/bing-sync",
+    summary: "Sync a project's inbound links from Bing Webmaster Tools",
+    description: 'Creates a tracking run and pulls inbound links live from the connected Bing Webmaster account, writing source="bing-webmaster" backlink rows. Requires a Bing connection for the project domain.',
+    tags: ["backlinks"],
+    parameters: [nameParameter],
+    responses: {
+      201: jsonResponse("Bing sync run queued.", "RunDto"),
+      400: errorResponse("No Bing Webmaster connection for this project."),
+      404: errorResponse("Project not found."),
+      422: errorResponse("Bing backlinks sync is not available on this deployment.")
+    }
+  },
   {
     method: "post",
     path: "/api/v1/projects/{name}/traffic/connect/cloud-run",
@@ -20351,15 +20752,276 @@ async function googleRoutes(app, opts) {
   });
 }
 
-// ../api-routes/src/bing.ts
+// ../api-routes/src/ads.ts
 import crypto18 from "crypto";
-import { eq as eq21, and as and14, desc as desc11 } from "drizzle-orm";
+import { eq as eq21, and as and14, asc as asc2, gte as gte3, lte as lte2, inArray as inArray10 } from "drizzle-orm";
+function statusDto(row) {
+  if (!row) return { connected: false };
+  return {
+    connected: true,
+    adAccountId: row.adAccountId,
+    displayName: row.displayName,
+    currencyCode: row.currencyCode,
+    timezone: row.timezone,
+    status: row.status,
+    lastSyncedAt: row.lastSyncedAt
+  };
+}
+function creativeDto(raw) {
+  if (raw == null || typeof raw !== "object") return null;
+  const c = raw;
+  return {
+    type: typeof c.type === "string" ? c.type : null,
+    title: typeof c.title === "string" ? c.title : null,
+    body: typeof c.body === "string" ? c.body : null,
+    targetUrl: typeof c.target_url === "string" ? c.target_url : null
+  };
+}
+async function adsRoutes(app, opts) {
+  app.post(
+    "/projects/:name/ads/connect",
+    async (request) => {
+      const project = resolveProject(app.db, request.params.name);
+      const parsed = adsConnectRequestSchema.safeParse(request.body ?? {});
+      if (!parsed.success) throw validationError('"apiKey" is required');
+      if (!opts.adsCredentialStore || !opts.verifyAdsAccount) {
+        throw validationError("Ads credential storage is not configured for this deployment");
+      }
+      let account;
+      try {
+        account = await opts.verifyAdsAccount(parsed.data.apiKey);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw validationError(`OpenAI Ads API rejected the key: ${message}`);
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existingCfg = opts.adsCredentialStore.getConnection(project.name);
+      opts.adsCredentialStore.upsertConnection({
+        projectName: project.name,
+        apiKey: parsed.data.apiKey,
+        adAccountId: account.id,
+        createdAt: existingCfg?.createdAt ?? now,
+        updatedAt: now
+      });
+      const existingRow = app.db.select().from(adsConnections).where(eq21(adsConnections.projectId, project.id)).get();
+      app.db.transaction((tx) => {
+        if (existingRow) {
+          tx.update(adsConnections).set({
+            adAccountId: account.id,
+            displayName: account.name,
+            currencyCode: account.currencyCode,
+            timezone: account.timezone,
+            status: account.status,
+            updatedAt: now
+          }).where(eq21(adsConnections.id, existingRow.id)).run();
+        } else {
+          tx.insert(adsConnections).values({
+            id: crypto18.randomUUID(),
+            projectId: project.id,
+            adAccountId: account.id,
+            displayName: account.name,
+            currencyCode: account.currencyCode,
+            timezone: account.timezone,
+            status: account.status,
+            createdAt: now,
+            updatedAt: now
+          }).run();
+        }
+        writeAuditLog(tx, auditFromRequest(request, {
+          projectId: project.id,
+          actor: "api",
+          action: "ads.connected",
+          entityType: "ads-connection",
+          entityId: account.id
+        }));
+      });
+      const row = app.db.select().from(adsConnections).where(eq21(adsConnections.projectId, project.id)).get();
+      return statusDto(row);
+    }
+  );
+  app.delete("/projects/:name/ads/connection", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const row = app.db.select().from(adsConnections).where(eq21(adsConnections.projectId, project.id)).get();
+    if (row) {
+      app.db.transaction((tx) => {
+        tx.delete(adsConnections).where(eq21(adsConnections.id, row.id)).run();
+        writeAuditLog(tx, auditFromRequest(request, {
+          projectId: project.id,
+          actor: "api",
+          action: "ads.disconnected",
+          entityType: "ads-connection",
+          entityId: row.adAccountId
+        }));
+      });
+    }
+    const removedFromConfig = opts.adsCredentialStore?.removeConnection(project.name) ?? false;
+    const response = { disconnected: Boolean(row) || removedFromConfig };
+    return response;
+  });
+  app.get("/projects/:name/ads/status", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const row = app.db.select().from(adsConnections).where(eq21(adsConnections.projectId, project.id)).get();
+    return statusDto(row);
+  });
+  app.post("/projects/:name/ads/sync", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const row = app.db.select().from(adsConnections).where(eq21(adsConnections.projectId, project.id)).get();
+    if (!row) {
+      throw validationError('No ads connection for this project. Run "canonry ads connect" first.');
+    }
+    const inFlight = app.db.select({ id: runs.id, status: runs.status }).from(runs).where(and14(
+      eq21(runs.projectId, project.id),
+      eq21(runs.kind, RunKinds["ads-sync"]),
+      inArray10(runs.status, [RunStatuses.queued, RunStatuses.running])
+    )).get();
+    if (inFlight) {
+      const existing = { runId: inFlight.id, status: inFlight.status };
+      return existing;
+    }
+    const runId = crypto18.randomUUID();
+    app.db.insert(runs).values({
+      id: runId,
+      projectId: project.id,
+      kind: RunKinds["ads-sync"],
+      status: RunStatuses.queued,
+      trigger: RunTriggers.manual,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }).run();
+    opts.onAdsSyncRequested?.(runId, project.id);
+    const response = { runId, status: RunStatuses.queued };
+    return response;
+  });
+  app.get("/projects/:name/ads/campaigns", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const campaignRows = app.db.select().from(adsCampaigns).where(eq21(adsCampaigns.projectId, project.id)).all();
+    const groupRows = app.db.select().from(adsAdGroups).where(eq21(adsAdGroups.projectId, project.id)).all();
+    const adRows = app.db.select().from(adsAds).where(eq21(adsAds.projectId, project.id)).all();
+    const adsByGroup = /* @__PURE__ */ new Map();
+    for (const ad of adRows) {
+      const dto = {
+        id: ad.id,
+        adGroupId: ad.adGroupId,
+        name: ad.name,
+        status: ad.status,
+        reviewStatus: ad.reviewStatus,
+        creative: creativeDto(ad.creative)
+      };
+      const list = adsByGroup.get(ad.adGroupId) ?? [];
+      list.push(dto);
+      adsByGroup.set(ad.adGroupId, list);
+    }
+    const groupsByCampaign = /* @__PURE__ */ new Map();
+    for (const group of groupRows) {
+      const dto = {
+        id: group.id,
+        campaignId: group.campaignId,
+        name: group.name,
+        status: group.status,
+        billingEventType: group.billingEventType,
+        maxBidMicros: group.maxBidMicros,
+        contextHints: group.contextHints,
+        ads: adsByGroup.get(group.id) ?? []
+      };
+      const list = groupsByCampaign.get(group.campaignId) ?? [];
+      list.push(dto);
+      groupsByCampaign.set(group.campaignId, list);
+    }
+    const campaigns = campaignRows.map((campaign) => ({
+      id: campaign.id,
+      name: campaign.name,
+      status: campaign.status,
+      biddingType: campaign.biddingType,
+      dailySpendLimitMicros: campaign.dailySpendLimitMicros,
+      lifetimeSpendLimitMicros: campaign.lifetimeSpendLimitMicros,
+      adGroups: groupsByCampaign.get(campaign.id) ?? []
+    }));
+    const response = { campaigns };
+    return response;
+  });
+  app.get("/projects/:name/ads/insights", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const { level, entityId, from, to } = request.query;
+    let parsedLevel;
+    if (level !== void 0) {
+      const result = adsInsightLevelSchema.safeParse(level);
+      if (!result.success) {
+        throw validationError('"level" must be one of: campaign, ad_group');
+      }
+      parsedLevel = result.data;
+    }
+    const conditions = [eq21(adsInsightsDaily.projectId, project.id)];
+    if (parsedLevel) conditions.push(eq21(adsInsightsDaily.level, parsedLevel));
+    if (entityId) conditions.push(eq21(adsInsightsDaily.entityId, entityId));
+    if (from) conditions.push(gte3(adsInsightsDaily.date, from));
+    if (to) conditions.push(lte2(adsInsightsDaily.date, to));
+    const rows = app.db.select().from(adsInsightsDaily).where(and14(...conditions)).orderBy(asc2(adsInsightsDaily.date)).all();
+    const dtoRows = rows.map((row) => ({
+      level: row.level,
+      entityId: row.entityId,
+      date: row.date,
+      impressions: row.impressions,
+      clicks: row.clicks,
+      spendMicros: row.spendMicros,
+      ctr: adsCtr(row.clicks, row.impressions),
+      cpcMicros: adsCpcMicros(row.spendMicros, row.clicks)
+    }));
+    const conn = app.db.select().from(adsConnections).where(eq21(adsConnections.projectId, project.id)).get();
+    const response = { rows: dtoRows, currencyCode: conn?.currencyCode ?? null };
+    return response;
+  });
+  app.get("/projects/:name/ads/summary", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const row = app.db.select().from(adsConnections).where(eq21(adsConnections.projectId, project.id)).get();
+    const campaignCount = app.db.select().from(adsCampaigns).where(eq21(adsCampaigns.projectId, project.id)).all().length;
+    const adGroupCount = app.db.select().from(adsAdGroups).where(eq21(adsAdGroups.projectId, project.id)).all().length;
+    const adCount = app.db.select().from(adsAds).where(eq21(adsAds.projectId, project.id)).all().length;
+    const campaignInsights = app.db.select().from(adsInsightsDaily).where(and14(
+      eq21(adsInsightsDaily.projectId, project.id),
+      eq21(adsInsightsDaily.level, "campaign")
+    )).all();
+    let impressions = 0;
+    let clicks = 0;
+    let spendMicros = 0;
+    let fromDate = null;
+    let toDate = null;
+    for (const insight of campaignInsights) {
+      impressions += insight.impressions;
+      clicks += insight.clicks;
+      spendMicros += insight.spendMicros;
+      if (fromDate === null || insight.date < fromDate) fromDate = insight.date;
+      if (toDate === null || insight.date > toDate) toDate = insight.date;
+    }
+    const response = {
+      connected: Boolean(row),
+      displayName: row?.displayName ?? null,
+      currencyCode: row?.currencyCode ?? null,
+      lastSyncedAt: row?.lastSyncedAt ?? null,
+      campaignCount,
+      adGroupCount,
+      adCount,
+      window: { from: fromDate, to: toDate },
+      totals: {
+        impressions,
+        clicks,
+        spendMicros,
+        ctr: adsCtr(clicks, impressions),
+        cpcMicros: adsCpcMicros(spendMicros, clicks)
+      }
+    };
+    return response;
+  });
+}
+
+// ../api-routes/src/bing.ts
+import crypto19 from "crypto";
+import { eq as eq22, and as and15, desc as desc11 } from "drizzle-orm";
 
 // ../integration-bing/src/constants.ts
 var BING_WMT_API_BASE = "https://ssl.bing.com/webmaster/api.svc/json";
 var BING_SUBMIT_URL_BATCH_LIMIT = 500;
 var BING_SUBMIT_URL_DAILY_LIMIT = 1e4;
 var BING_REQUEST_TIMEOUT_MS = 3e4;
+var BING_LINKS_MAX_PAGES = 20;
 
 // ../integration-bing/src/types.ts
 var BingApiError = class extends Error {
@@ -20523,6 +21185,51 @@ async function getCrawlIssues(apiKey, siteUrl) {
   const data = await bingFetch(apiKey, `GetCrawlIssues?siteUrl=${encodedSite}`);
   return data ?? [];
 }
+async function getLinkCounts(apiKey, siteUrl, opts = {}) {
+  validateApiKey(apiKey);
+  validateSiteUrl2(siteUrl);
+  const encodedSite = encodeURIComponent(siteUrl);
+  const maxPages = Math.max(1, opts.maxPages ?? BING_LINKS_MAX_PAGES);
+  const out = [];
+  let page = 0;
+  let totalPages = 1;
+  while (page < totalPages && page < maxPages) {
+    const data = await bingFetch(apiKey, `GetLinkCounts?siteUrl=${encodedSite}&page=${page}`);
+    for (const link of data?.Links ?? []) {
+      if (link && typeof link.Url === "string") {
+        out.push({ Url: link.Url, Count: Number(link.Count ?? 0) });
+      }
+    }
+    totalPages = Number(data?.TotalPages ?? 1) || 1;
+    page++;
+  }
+  return out;
+}
+async function getUrlLinks(apiKey, siteUrl, link, opts = {}) {
+  validateApiKey(apiKey);
+  validateSiteUrl2(siteUrl);
+  validateUrl2(link);
+  const encodedSite = encodeURIComponent(siteUrl);
+  const encodedLink = encodeURIComponent(link);
+  const maxPages = Math.max(1, opts.maxPages ?? BING_LINKS_MAX_PAGES);
+  const out = [];
+  let page = 0;
+  let totalPages = 1;
+  while (page < totalPages && page < maxPages) {
+    const data = await bingFetch(
+      apiKey,
+      `GetUrlLinks?siteUrl=${encodedSite}&link=${encodedLink}&page=${page}`
+    );
+    for (const detail of data?.Details ?? []) {
+      if (detail && typeof detail.Url === "string") {
+        out.push({ Url: detail.Url, AnchorText: detail.AnchorText });
+      }
+    }
+    totalPages = Number(data?.TotalPages ?? 1) || 1;
+    page++;
+  }
+  return out;
+}
 
 // ../api-routes/src/bing.ts
 function parseBingDate(value) {
@@ -20681,7 +21388,7 @@ async function bingRoutes(app, opts) {
     const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     requireConnection(store, project.canonicalDomain);
-    const allInspections = app.db.select().from(bingUrlInspections).where(eq21(bingUrlInspections.projectId, project.id)).orderBy(desc11(bingUrlInspections.inspectedAt)).all();
+    const allInspections = app.db.select().from(bingUrlInspections).where(eq22(bingUrlInspections.projectId, project.id)).orderBy(desc11(bingUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     const definitiveByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
@@ -20738,7 +21445,7 @@ async function bingRoutes(app, opts) {
       const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
       const now = (/* @__PURE__ */ new Date()).toISOString();
       app.db.insert(bingCoverageSnapshots).values({
-        id: crypto18.randomUUID(),
+        id: crypto19.randomUUID(),
         projectId: project.id,
         syncRunId: snapshotRunId,
         date: snapshotDate,
@@ -20770,7 +21477,7 @@ async function bingRoutes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     const parsed = parseInt(request.query.limit ?? "90", 10);
     const limit = Number.isNaN(parsed) || parsed <= 0 ? 90 : parsed;
-    const rows = app.db.select().from(bingCoverageSnapshots).where(eq21(bingCoverageSnapshots.projectId, project.id)).orderBy(desc11(bingCoverageSnapshots.date)).limit(limit).all();
+    const rows = app.db.select().from(bingCoverageSnapshots).where(eq22(bingCoverageSnapshots.projectId, project.id)).orderBy(desc11(bingCoverageSnapshots.date)).limit(limit).all();
     return rows.map((r) => ({
       date: r.date,
       indexed: r.indexed,
@@ -20782,7 +21489,7 @@ async function bingRoutes(app, opts) {
     requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const { url, limit } = request.query;
-    const whereClause = url ? and14(eq21(bingUrlInspections.projectId, project.id), eq21(bingUrlInspections.url, url)) : eq21(bingUrlInspections.projectId, project.id);
+    const whereClause = url ? and15(eq22(bingUrlInspections.projectId, project.id), eq22(bingUrlInspections.url, url)) : eq22(bingUrlInspections.projectId, project.id);
     const filtered = app.db.select().from(bingUrlInspections).where(whereClause).orderBy(desc11(bingUrlInspections.inspectedAt)).limit(Math.max(1, Math.min(parseInt(limit ?? "100", 10) || 100, 1e3))).all();
     return filtered.map((r) => ({
       id: r.id,
@@ -20809,7 +21516,7 @@ async function bingRoutes(app, opts) {
       throw validationError("url is required");
     }
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const runId = crypto18.randomUUID();
+    const runId = crypto19.randomUUID();
     app.db.insert(runs).values({
       id: runId,
       projectId: project.id,
@@ -20830,7 +21537,7 @@ async function bingRoutes(app, opts) {
         discoveryDate: result.DiscoveryDate ?? null
       });
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const id = crypto18.randomUUID();
+      const id = crypto19.randomUUID();
       const httpCode = result.HttpStatus ?? result.HttpCode ?? null;
       const lastCrawledDate = parseBingDate(result.LastCrawledDate);
       const inIndexDate = parseBingDate(result.InIndexDate);
@@ -20872,7 +21579,7 @@ async function bingRoutes(app, opts) {
         anchorCount: result.AnchorCount ?? null,
         discoveryDate
       }).run();
-      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: now }).where(eq21(runs.id, runId)).run();
+      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: now }).where(eq22(runs.id, runId)).run();
       return {
         id,
         url,
@@ -20888,7 +21595,7 @@ async function bingRoutes(app, opts) {
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       bingLog("error", "inspect-url.failed", { domain: project.canonicalDomain, url, error: msg });
-      app.db.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq21(runs.id, runId)).run();
+      app.db.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq22(runs.id, runId)).run();
       throw e;
     }
   });
@@ -20900,7 +21607,7 @@ async function bingRoutes(app, opts) {
       throw validationError('No Bing site configured. Run "canonry bing set-site <project> <url>" first.');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const runId = crypto18.randomUUID();
+    const runId = crypto19.randomUUID();
     app.db.insert(runs).values({
       id: runId,
       projectId: project.id,
@@ -20915,7 +21622,7 @@ async function bingRoutes(app, opts) {
     } else {
       bingLog("warn", "inspect-sitemap.no-callback", { domain: project.canonicalDomain, runId });
     }
-    const run = app.db.select().from(runs).where(eq21(runs.id, runId)).get();
+    const run = app.db.select().from(runs).where(eq22(runs.id, runId)).get();
     return run;
   });
   app.post("/projects/:name/bing/request-indexing", async (request) => {
@@ -20927,7 +21634,7 @@ async function bingRoutes(app, opts) {
     }
     let urlsToSubmit = request.body?.urls ?? [];
     if (request.body?.allUnindexed) {
-      const allInspections = app.db.select().from(bingUrlInspections).where(eq21(bingUrlInspections.projectId, project.id)).orderBy(desc11(bingUrlInspections.inspectedAt)).all();
+      const allInspections = app.db.select().from(bingUrlInspections).where(eq22(bingUrlInspections.projectId, project.id)).orderBy(desc11(bingUrlInspections.inspectedAt)).all();
       const latestByUrl = /* @__PURE__ */ new Map();
       for (const row of allInspections) {
         if (!latestByUrl.has(row.url)) {
@@ -21014,14 +21721,14 @@ async function bingRoutes(app, opts) {
 import fs from "fs";
 import path from "path";
 import os from "os";
-import { eq as eq22, and as and15 } from "drizzle-orm";
+import { eq as eq23, and as and16 } from "drizzle-orm";
 function getScreenshotDir() {
   return path.join(os.homedir(), ".canonry", "screenshots");
 }
 async function cdpRoutes(app, opts) {
   app.get("/screenshots/:snapshotId", async (request, reply) => {
     const { snapshotId } = request.params;
-    const snapshot = app.db.select({ screenshotPath: querySnapshots.screenshotPath }).from(querySnapshots).where(eq22(querySnapshots.id, snapshotId)).get();
+    const snapshot = app.db.select({ screenshotPath: querySnapshots.screenshotPath }).from(querySnapshots).where(eq23(querySnapshots.id, snapshotId)).get();
     if (!snapshot?.screenshotPath) {
       const err = notFound("Screenshot", snapshotId);
       return reply.code(err.statusCode).send(err.toJSON());
@@ -21088,7 +21795,7 @@ async function cdpRoutes(app, opts) {
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
       const { runId } = request.params;
-      const run = app.db.select().from(runs).where(and15(eq22(runs.id, runId), eq22(runs.projectId, project.id))).get();
+      const run = app.db.select().from(runs).where(and16(eq23(runs.id, runId), eq23(runs.projectId, project.id))).get();
       if (!run) {
         const err = notFound("Run", runId);
         return reply.code(err.statusCode).send(err.toJSON());
@@ -21101,8 +21808,8 @@ async function cdpRoutes(app, opts) {
         citedDomains: querySnapshots.citedDomains,
         screenshotPath: querySnapshots.screenshotPath,
         rawResponse: querySnapshots.rawResponse
-      }).from(querySnapshots).where(eq22(querySnapshots.runId, runId)).all());
-      const queryRows = app.db.select({ id: queries.id, query: queries.query }).from(queries).where(eq22(queries.projectId, project.id)).all();
+      }).from(querySnapshots).where(eq23(querySnapshots.runId, runId)).all());
+      const queryRows = app.db.select({ id: queries.id, query: queries.query }).from(queries).where(eq23(queries.projectId, project.id)).all();
       const queryMap = new Map(queryRows.map((q) => [q.id, q.query]));
       const byQuery = /* @__PURE__ */ new Map();
       for (const snap of snapshots) {
@@ -21184,8 +21891,8 @@ async function cdpRoutes(app, opts) {
 }
 
 // ../api-routes/src/ga.ts
-import crypto19 from "crypto";
-import { eq as eq23, desc as desc12, and as and16, sql as sql9 } from "drizzle-orm";
+import crypto20 from "crypto";
+import { eq as eq24, desc as desc12, and as and17, sql as sql9 } 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;
@@ -21392,10 +22099,10 @@ async function ga4Routes(app, opts) {
     if (!saConn && !oauthConn) {
       throw notFound("GA4 connection", project.name);
     }
-    app.db.delete(gaTrafficSnapshots).where(eq23(gaTrafficSnapshots.projectId, project.id)).run();
-    app.db.delete(gaTrafficSummaries).where(eq23(gaTrafficSummaries.projectId, project.id)).run();
-    app.db.delete(gaAiReferrals).where(eq23(gaAiReferrals.projectId, project.id)).run();
-    app.db.delete(gaSocialReferrals).where(eq23(gaSocialReferrals.projectId, project.id)).run();
+    app.db.delete(gaTrafficSnapshots).where(eq24(gaTrafficSnapshots.projectId, project.id)).run();
+    app.db.delete(gaTrafficSummaries).where(eq24(gaTrafficSummaries.projectId, project.id)).run();
+    app.db.delete(gaAiReferrals).where(eq24(gaAiReferrals.projectId, project.id)).run();
+    app.db.delete(gaSocialReferrals).where(eq24(gaSocialReferrals.projectId, project.id)).run();
     const propertyId = saConn?.propertyId ?? oauthConn?.propertyId ?? null;
     opts.ga4CredentialStore?.deleteConnection(project.name);
     opts.googleConnectionStore?.deleteConnection(project.canonicalDomain, "ga4");
@@ -21416,7 +22123,7 @@ async function ga4Routes(app, opts) {
     if (!connected) {
       return { connected: false, propertyId: null, clientEmail: null, authMethod: null, lastSyncedAt: null };
     }
-    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq23(gaTrafficSummaries.projectId, project.id)).orderBy(desc12(gaTrafficSummaries.syncedAt)).limit(1).get();
+    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq24(gaTrafficSummaries.projectId, project.id)).orderBy(desc12(gaTrafficSummaries.syncedAt)).limit(1).get();
     return {
       connected: true,
       propertyId: saConn?.propertyId ?? oauthConn?.propertyId ?? null,
@@ -21440,7 +22147,7 @@ async function ga4Routes(app, opts) {
     const syncAi = !only || only === "ai";
     const syncSocial = !only || only === "social";
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const runId = crypto19.randomUUID();
+    const runId = crypto20.randomUUID();
     app.db.insert(runs).values({
       id: runId,
       projectId: project.id,
@@ -21480,15 +22187,15 @@ async function ga4Routes(app, opts) {
       app.db.transaction((tx) => {
         if (syncTraffic) {
           tx.delete(gaTrafficSnapshots).where(
-            and16(
-              eq23(gaTrafficSnapshots.projectId, project.id),
+            and17(
+              eq24(gaTrafficSnapshots.projectId, project.id),
               sql9`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
               sql9`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
             )
           ).run();
           for (const row of rows) {
             tx.insert(gaTrafficSnapshots).values({
-              id: crypto19.randomUUID(),
+              id: crypto20.randomUUID(),
               projectId: project.id,
               date: row.date,
               landingPage: row.landingPage,
@@ -21504,15 +22211,15 @@ async function ga4Routes(app, opts) {
         }
         if (syncAi) {
           tx.delete(gaAiReferrals).where(
-            and16(
-              eq23(gaAiReferrals.projectId, project.id),
+            and17(
+              eq24(gaAiReferrals.projectId, project.id),
               sql9`${gaAiReferrals.date} >= ${summary.periodStart}`,
               sql9`${gaAiReferrals.date} <= ${summary.periodEnd}`
             )
           ).run();
           for (const row of aiReferrals) {
             tx.insert(gaAiReferrals).values({
-              id: crypto19.randomUUID(),
+              id: crypto20.randomUUID(),
               projectId: project.id,
               date: row.date,
               source: row.source,
@@ -21530,15 +22237,15 @@ async function ga4Routes(app, opts) {
         }
         if (syncSocial) {
           tx.delete(gaSocialReferrals).where(
-            and16(
-              eq23(gaSocialReferrals.projectId, project.id),
+            and17(
+              eq24(gaSocialReferrals.projectId, project.id),
               sql9`${gaSocialReferrals.date} >= ${summary.periodStart}`,
               sql9`${gaSocialReferrals.date} <= ${summary.periodEnd}`
             )
           ).run();
           for (const row of socialReferrals) {
             tx.insert(gaSocialReferrals).values({
-              id: crypto19.randomUUID(),
+              id: crypto20.randomUUID(),
               projectId: project.id,
               date: row.date,
               source: row.source,
@@ -21552,9 +22259,9 @@ async function ga4Routes(app, opts) {
           }
         }
         if (syncSummary) {
-          tx.delete(gaTrafficSummaries).where(eq23(gaTrafficSummaries.projectId, project.id)).run();
+          tx.delete(gaTrafficSummaries).where(eq24(gaTrafficSummaries.projectId, project.id)).run();
           tx.insert(gaTrafficSummaries).values({
-            id: crypto19.randomUUID(),
+            id: crypto20.randomUUID(),
             projectId: project.id,
             periodStart: summary.periodStart,
             periodEnd: summary.periodEnd,
@@ -21564,10 +22271,10 @@ async function ga4Routes(app, opts) {
             syncedAt: now,
             syncRunId: runId
           }).run();
-          tx.delete(gaTrafficWindowSummaries).where(eq23(gaTrafficWindowSummaries.projectId, project.id)).run();
+          tx.delete(gaTrafficWindowSummaries).where(eq24(gaTrafficWindowSummaries.projectId, project.id)).run();
           for (const ws of windowSummaries) {
             tx.insert(gaTrafficWindowSummaries).values({
-              id: crypto19.randomUUID(),
+              id: crypto20.randomUUID(),
               projectId: project.id,
               windowKey: ws.windowKey,
               periodStart: ws.periodStart,
@@ -21582,7 +22289,7 @@ async function ga4Routes(app, opts) {
           }
         }
       });
-      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: now }).where(eq23(runs.id, runId)).run();
+      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: now }).where(eq24(runs.id, runId)).run();
       const syncedComponents = only ? [
         ...syncTraffic ? ["traffic"] : [],
         ...syncSummary ? ["summary"] : [],
@@ -21611,7 +22318,7 @@ async function ga4Routes(app, opts) {
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       gaLog("error", "sync.fetch-failed", { projectId: project.id, runId, error: msg });
-      app.db.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq23(runs.id, runId)).run();
+      app.db.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq24(runs.id, runId)).run();
       throw e;
     }
   });
@@ -21622,11 +22329,11 @@ async function ga4Routes(app, opts) {
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const cutoffDate = cutoff?.slice(0, 10) ?? null;
-    const snapshotConditions = [eq23(gaTrafficSnapshots.projectId, project.id)];
+    const snapshotConditions = [eq24(gaTrafficSnapshots.projectId, project.id)];
     if (cutoffDate) snapshotConditions.push(sql9`${gaTrafficSnapshots.date} >= ${cutoffDate}`);
-    const aiConditions = [eq23(gaAiReferrals.projectId, project.id)];
+    const aiConditions = [eq24(gaAiReferrals.projectId, project.id)];
     if (cutoffDate) aiConditions.push(sql9`${gaAiReferrals.date} >= ${cutoffDate}`);
-    const socialConditions = [eq23(gaSocialReferrals.projectId, project.id)];
+    const socialConditions = [eq24(gaSocialReferrals.projectId, project.id)];
     if (cutoffDate) socialConditions.push(sql9`${gaSocialReferrals.date} >= ${cutoffDate}`);
     const windowSummaryRow = cutoffDate ? app.db.select({
       totalSessions: gaTrafficWindowSummaries.totalSessions,
@@ -21634,42 +22341,42 @@ async function ga4Routes(app, opts) {
       totalDirectSessions: gaTrafficWindowSummaries.totalDirectSessions,
       totalUsers: gaTrafficWindowSummaries.totalUsers
     }).from(gaTrafficWindowSummaries).where(
-      and16(
-        eq23(gaTrafficWindowSummaries.projectId, project.id),
-        eq23(gaTrafficWindowSummaries.windowKey, window)
+      and17(
+        eq24(gaTrafficWindowSummaries.projectId, project.id),
+        eq24(gaTrafficWindowSummaries.windowKey, window)
       )
     ).get() : null;
     const snapshotTotalsRow = cutoffDate && !windowSummaryRow ? app.db.select({
       totalSessions: sql9`COALESCE(SUM(${gaTrafficSnapshots.sessions}), 0)`,
       totalOrganicSessions: sql9`COALESCE(SUM(${gaTrafficSnapshots.organicSessions}), 0)`,
       totalUsers: sql9`COALESCE(SUM(${gaTrafficSnapshots.users}), 0)`
-    }).from(gaTrafficSnapshots).where(and16(...snapshotConditions)).get() : null;
+    }).from(gaTrafficSnapshots).where(and17(...snapshotConditions)).get() : null;
     const summaryRow = cutoffDate ? windowSummaryRow ?? snapshotTotalsRow : app.db.select({
       totalSessions: gaTrafficSummaries.totalSessions,
       totalOrganicSessions: gaTrafficSummaries.totalOrganicSessions,
       totalUsers: gaTrafficSummaries.totalUsers
-    }).from(gaTrafficSummaries).where(eq23(gaTrafficSummaries.projectId, project.id)).get();
+    }).from(gaTrafficSummaries).where(eq24(gaTrafficSummaries.projectId, project.id)).get();
     const directTotalRow = windowSummaryRow ? { totalDirectSessions: windowSummaryRow.totalDirectSessions } : app.db.select({
       totalDirectSessions: sql9`COALESCE(SUM(${gaTrafficSnapshots.directSessions}), 0)`
-    }).from(gaTrafficSnapshots).where(and16(...snapshotConditions)).get();
+    }).from(gaTrafficSnapshots).where(and17(...snapshotConditions)).get();
     const summaryMeta = app.db.select({
       periodStart: gaTrafficSummaries.periodStart,
       periodEnd: gaTrafficSummaries.periodEnd
-    }).from(gaTrafficSummaries).where(eq23(gaTrafficSummaries.projectId, project.id)).get();
+    }).from(gaTrafficSummaries).where(eq24(gaTrafficSummaries.projectId, project.id)).get();
     const rows = app.db.select({
       landingPage: sql9`COALESCE(${gaTrafficSnapshots.landingPageNormalized}, ${gaTrafficSnapshots.landingPage})`,
       sessions: sql9`SUM(${gaTrafficSnapshots.sessions})`,
       organicSessions: sql9`SUM(${gaTrafficSnapshots.organicSessions})`,
       directSessions: sql9`COALESCE(SUM(${gaTrafficSnapshots.directSessions}), 0)`,
       users: sql9`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(and16(...snapshotConditions)).groupBy(sql9`COALESCE(${gaTrafficSnapshots.landingPageNormalized}, ${gaTrafficSnapshots.landingPage})`).orderBy(sql9`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
+    }).from(gaTrafficSnapshots).where(and17(...snapshotConditions)).groupBy(sql9`COALESCE(${gaTrafficSnapshots.landingPageNormalized}, ${gaTrafficSnapshots.landingPage})`).orderBy(sql9`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
     const aiReferralRows = app.db.select({
       source: gaAiReferrals.source,
       medium: gaAiReferrals.medium,
       sourceDimension: gaAiReferrals.sourceDimension,
       sessions: sql9`SUM(${gaAiReferrals.sessions})`,
       users: sql9`SUM(${gaAiReferrals.users})`
-    }).from(gaAiReferrals).where(and16(...aiConditions)).groupBy(gaAiReferrals.source, gaAiReferrals.medium, gaAiReferrals.sourceDimension).all();
+    }).from(gaAiReferrals).where(and17(...aiConditions)).groupBy(gaAiReferrals.source, gaAiReferrals.medium, gaAiReferrals.sourceDimension).all();
     const aiReferralLandingPageRows = app.db.select({
       source: gaAiReferrals.source,
       medium: gaAiReferrals.medium,
@@ -21677,7 +22384,7 @@ async function ga4Routes(app, opts) {
       landingPage: sql9`COALESCE(${gaAiReferrals.landingPageNormalized}, ${gaAiReferrals.landingPage})`,
       sessions: sql9`SUM(${gaAiReferrals.sessions})`,
       users: sql9`SUM(${gaAiReferrals.users})`
-    }).from(gaAiReferrals).where(and16(...aiConditions)).groupBy(
+    }).from(gaAiReferrals).where(and17(...aiConditions)).groupBy(
       gaAiReferrals.source,
       gaAiReferrals.medium,
       gaAiReferrals.sourceDimension,
@@ -21714,7 +22421,7 @@ async function ga4Routes(app, opts) {
       channelGroup: gaAiReferrals.channelGroup,
       sessions: sql9`COALESCE(SUM(${gaAiReferrals.sessions}), 0)`,
       users: sql9`COALESCE(SUM(${gaAiReferrals.users}), 0)`
-    }).from(gaAiReferrals).where(and16(...aiConditions, eq23(gaAiReferrals.sourceDimension, "session"))).groupBy(gaAiReferrals.channelGroup).all();
+    }).from(gaAiReferrals).where(and17(...aiConditions, eq24(gaAiReferrals.sourceDimension, "session"))).groupBy(gaAiReferrals.channelGroup).all();
     const aiSessionsByChannelGroup = /* @__PURE__ */ new Map();
     let aiBySessionUsers = 0;
     for (const row of aiBySessionRows) {
@@ -21728,12 +22435,12 @@ async function ga4Routes(app, opts) {
       channelGroup: gaSocialReferrals.channelGroup,
       sessions: sql9`SUM(${gaSocialReferrals.sessions})`,
       users: sql9`SUM(${gaSocialReferrals.users})`
-    }).from(gaSocialReferrals).where(and16(...socialConditions)).groupBy(gaSocialReferrals.source, gaSocialReferrals.medium, gaSocialReferrals.channelGroup).orderBy(sql9`SUM(${gaSocialReferrals.sessions}) DESC`).all();
+    }).from(gaSocialReferrals).where(and17(...socialConditions)).groupBy(gaSocialReferrals.source, gaSocialReferrals.medium, gaSocialReferrals.channelGroup).orderBy(sql9`SUM(${gaSocialReferrals.sessions}) DESC`).all();
     const socialTotals = app.db.select({
       sessions: sql9`SUM(${gaSocialReferrals.sessions})`,
       users: sql9`SUM(${gaSocialReferrals.users})`
-    }).from(gaSocialReferrals).where(and16(...socialConditions)).get();
-    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq23(gaTrafficSummaries.projectId, project.id)).orderBy(desc12(gaTrafficSummaries.syncedAt)).limit(1).get();
+    }).from(gaSocialReferrals).where(and17(...socialConditions)).get();
+    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq24(gaTrafficSummaries.projectId, project.id)).orderBy(desc12(gaTrafficSummaries.syncedAt)).limit(1).get();
     const total = summaryRow?.totalSessions ?? 0;
     const totalDirectSessions = directTotalRow?.totalDirectSessions ?? 0;
     const totalOrganicSessions = summaryRow?.totalOrganicSessions ?? 0;
@@ -21813,7 +22520,7 @@ async function ga4Routes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     requireGa4Connection(opts, project.name, project.canonicalDomain);
     const cutoffDate = windowCutoff(parseWindow(request.query.window))?.slice(0, 10) ?? null;
-    const conditions = [eq23(gaAiReferrals.projectId, project.id)];
+    const conditions = [eq24(gaAiReferrals.projectId, project.id)];
     if (cutoffDate) conditions.push(sql9`${gaAiReferrals.date} >= ${cutoffDate}`);
     const rows = app.db.select({
       date: gaAiReferrals.date,
@@ -21823,7 +22530,7 @@ async function ga4Routes(app, opts) {
       sourceDimension: gaAiReferrals.sourceDimension,
       sessions: sql9`SUM(${gaAiReferrals.sessions})`,
       users: sql9`SUM(${gaAiReferrals.users})`
-    }).from(gaAiReferrals).where(and16(...conditions)).groupBy(
+    }).from(gaAiReferrals).where(and17(...conditions)).groupBy(
       gaAiReferrals.date,
       gaAiReferrals.source,
       gaAiReferrals.medium,
@@ -21836,7 +22543,7 @@ async function ga4Routes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     requireGa4Connection(opts, project.name, project.canonicalDomain);
     const cutoffDate = windowCutoff(parseWindow(request.query.window))?.slice(0, 10) ?? null;
-    const conditions = [eq23(gaSocialReferrals.projectId, project.id)];
+    const conditions = [eq24(gaSocialReferrals.projectId, project.id)];
     if (cutoffDate) conditions.push(sql9`${gaSocialReferrals.date} >= ${cutoffDate}`);
     const rows = app.db.select({
       date: gaSocialReferrals.date,
@@ -21845,7 +22552,7 @@ async function ga4Routes(app, opts) {
       channelGroup: gaSocialReferrals.channelGroup,
       sessions: gaSocialReferrals.sessions,
       users: gaSocialReferrals.users
-    }).from(gaSocialReferrals).where(and16(...conditions)).orderBy(gaSocialReferrals.date).all();
+    }).from(gaSocialReferrals).where(and17(...conditions)).orderBy(gaSocialReferrals.date).all();
     return rows;
   });
   app.get("/projects/:name/ga/social-referral-trend", async (request, _reply) => {
@@ -21858,8 +22565,8 @@ async function ga4Routes(app, opts) {
       d.setDate(d.getDate() - n);
       return fmt(d);
     };
-    const sumSocial = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaSocialReferrals.sessions}), 0)` }).from(gaSocialReferrals).where(and16(
-      eq23(gaSocialReferrals.projectId, project.id),
+    const sumSocial = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaSocialReferrals.sessions}), 0)` }).from(gaSocialReferrals).where(and17(
+      eq24(gaSocialReferrals.projectId, project.id),
       sql9`${gaSocialReferrals.date} >= ${from}`,
       sql9`${gaSocialReferrals.date} < ${to}`
     )).get();
@@ -21871,16 +22578,16 @@ async function ga4Routes(app, opts) {
     const sourceCurrent = app.db.select({
       source: gaSocialReferrals.source,
       sessions: sql9`SUM(${gaSocialReferrals.sessions})`
-    }).from(gaSocialReferrals).where(and16(
-      eq23(gaSocialReferrals.projectId, project.id),
+    }).from(gaSocialReferrals).where(and17(
+      eq24(gaSocialReferrals.projectId, project.id),
       sql9`${gaSocialReferrals.date} >= ${daysAgo(7)}`,
       sql9`${gaSocialReferrals.date} < ${fmt(today)}`
     )).groupBy(gaSocialReferrals.source).all();
     const sourcePrev = app.db.select({
       source: gaSocialReferrals.source,
       sessions: sql9`SUM(${gaSocialReferrals.sessions})`
-    }).from(gaSocialReferrals).where(and16(
-      eq23(gaSocialReferrals.projectId, project.id),
+    }).from(gaSocialReferrals).where(and17(
+      eq24(gaSocialReferrals.projectId, project.id),
       sql9`${gaSocialReferrals.date} >= ${daysAgo(14)}`,
       sql9`${gaSocialReferrals.date} < ${daysAgo(7)}`
     )).groupBy(gaSocialReferrals.source).all();
@@ -21921,16 +22628,16 @@ async function ga4Routes(app, opts) {
       return fmt(d);
     };
     const pct = (cur, prev) => prev === 0 ? null : Math.round((cur - prev) / prev * 100);
-    const sumTotal = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaTrafficSnapshots.sessions}), 0)` }).from(gaTrafficSnapshots).where(and16(eq23(gaTrafficSnapshots.projectId, project.id), sql9`${gaTrafficSnapshots.date} >= ${from}`, sql9`${gaTrafficSnapshots.date} < ${to}`)).get();
-    const sumOrganic = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaTrafficSnapshots.organicSessions}), 0)` }).from(gaTrafficSnapshots).where(and16(eq23(gaTrafficSnapshots.projectId, project.id), sql9`${gaTrafficSnapshots.date} >= ${from}`, sql9`${gaTrafficSnapshots.date} < ${to}`)).get();
-    const sumDirect = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaTrafficSnapshots.directSessions}), 0)` }).from(gaTrafficSnapshots).where(and16(eq23(gaTrafficSnapshots.projectId, project.id), sql9`${gaTrafficSnapshots.date} >= ${from}`, sql9`${gaTrafficSnapshots.date} < ${to}`)).get();
-    const sumAi = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaAiReferrals.sessions}), 0)` }).from(gaAiReferrals).where(and16(
-      eq23(gaAiReferrals.projectId, project.id),
+    const sumTotal = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaTrafficSnapshots.sessions}), 0)` }).from(gaTrafficSnapshots).where(and17(eq24(gaTrafficSnapshots.projectId, project.id), sql9`${gaTrafficSnapshots.date} >= ${from}`, sql9`${gaTrafficSnapshots.date} < ${to}`)).get();
+    const sumOrganic = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaTrafficSnapshots.organicSessions}), 0)` }).from(gaTrafficSnapshots).where(and17(eq24(gaTrafficSnapshots.projectId, project.id), sql9`${gaTrafficSnapshots.date} >= ${from}`, sql9`${gaTrafficSnapshots.date} < ${to}`)).get();
+    const sumDirect = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaTrafficSnapshots.directSessions}), 0)` }).from(gaTrafficSnapshots).where(and17(eq24(gaTrafficSnapshots.projectId, project.id), sql9`${gaTrafficSnapshots.date} >= ${from}`, sql9`${gaTrafficSnapshots.date} < ${to}`)).get();
+    const sumAi = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaAiReferrals.sessions}), 0)` }).from(gaAiReferrals).where(and17(
+      eq24(gaAiReferrals.projectId, project.id),
       sql9`${gaAiReferrals.date} >= ${from}`,
       sql9`${gaAiReferrals.date} < ${to}`,
-      eq23(gaAiReferrals.sourceDimension, "session")
+      eq24(gaAiReferrals.sourceDimension, "session")
     )).get();
-    const sumSocial = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaSocialReferrals.sessions}), 0)` }).from(gaSocialReferrals).where(and16(eq23(gaSocialReferrals.projectId, project.id), sql9`${gaSocialReferrals.date} >= ${from}`, sql9`${gaSocialReferrals.date} < ${to}`)).get();
+    const sumSocial = (from, to) => app.db.select({ sessions: sql9`COALESCE(SUM(${gaSocialReferrals.sessions}), 0)` }).from(gaSocialReferrals).where(and17(eq24(gaSocialReferrals.projectId, project.id), sql9`${gaSocialReferrals.date} >= ${from}`, sql9`${gaSocialReferrals.date} < ${to}`)).get();
     const todayStr = fmt(today);
     const buildTrend = (sum) => {
       const c7 = sum(daysAgo(7), todayStr)?.sessions ?? 0;
@@ -21939,17 +22646,17 @@ async function ga4Routes(app, opts) {
       const p30 = sum(daysAgo(60), daysAgo(30))?.sessions ?? 0;
       return { sessions7d: c7, sessionsPrev7d: p7, trend7dPct: pct(c7, p7), sessions30d: c30, sessionsPrev30d: p30, trend30dPct: pct(c30, p30) };
     };
-    const aiSourceCurrent = app.db.select({ source: gaAiReferrals.source, sessions: sql9`COALESCE(SUM(${gaAiReferrals.sessions}), 0)` }).from(gaAiReferrals).where(and16(
-      eq23(gaAiReferrals.projectId, project.id),
+    const aiSourceCurrent = app.db.select({ source: gaAiReferrals.source, sessions: sql9`COALESCE(SUM(${gaAiReferrals.sessions}), 0)` }).from(gaAiReferrals).where(and17(
+      eq24(gaAiReferrals.projectId, project.id),
       sql9`${gaAiReferrals.date} >= ${daysAgo(7)}`,
       sql9`${gaAiReferrals.date} < ${todayStr}`,
-      eq23(gaAiReferrals.sourceDimension, "session")
+      eq24(gaAiReferrals.sourceDimension, "session")
     )).groupBy(gaAiReferrals.source).all();
-    const aiSourcePrev = app.db.select({ source: gaAiReferrals.source, sessions: sql9`COALESCE(SUM(${gaAiReferrals.sessions}), 0)` }).from(gaAiReferrals).where(and16(
-      eq23(gaAiReferrals.projectId, project.id),
+    const aiSourcePrev = app.db.select({ source: gaAiReferrals.source, sessions: sql9`COALESCE(SUM(${gaAiReferrals.sessions}), 0)` }).from(gaAiReferrals).where(and17(
+      eq24(gaAiReferrals.projectId, project.id),
       sql9`${gaAiReferrals.date} >= ${daysAgo(14)}`,
       sql9`${gaAiReferrals.date} < ${daysAgo(7)}`,
-      eq23(gaAiReferrals.sourceDimension, "session")
+      eq24(gaAiReferrals.sourceDimension, "session")
     )).groupBy(gaAiReferrals.source).all();
     const findBiggestMover = (current, prev) => {
       const prevMap = new Map(prev.map((r) => [r.source, r.sessions]));
@@ -21965,8 +22672,8 @@ async function ga4Routes(app, opts) {
       }
       return mover;
     };
-    const socialSourceCurrent = app.db.select({ source: gaSocialReferrals.source, sessions: sql9`SUM(${gaSocialReferrals.sessions})` }).from(gaSocialReferrals).where(and16(eq23(gaSocialReferrals.projectId, project.id), sql9`${gaSocialReferrals.date} >= ${daysAgo(7)}`, sql9`${gaSocialReferrals.date} < ${todayStr}`)).groupBy(gaSocialReferrals.source).all();
-    const socialSourcePrev = app.db.select({ source: gaSocialReferrals.source, sessions: sql9`SUM(${gaSocialReferrals.sessions})` }).from(gaSocialReferrals).where(and16(eq23(gaSocialReferrals.projectId, project.id), sql9`${gaSocialReferrals.date} >= ${daysAgo(14)}`, sql9`${gaSocialReferrals.date} < ${daysAgo(7)}`)).groupBy(gaSocialReferrals.source).all();
+    const socialSourceCurrent = app.db.select({ source: gaSocialReferrals.source, sessions: sql9`SUM(${gaSocialReferrals.sessions})` }).from(gaSocialReferrals).where(and17(eq24(gaSocialReferrals.projectId, project.id), sql9`${gaSocialReferrals.date} >= ${daysAgo(7)}`, sql9`${gaSocialReferrals.date} < ${todayStr}`)).groupBy(gaSocialReferrals.source).all();
+    const socialSourcePrev = app.db.select({ source: gaSocialReferrals.source, sessions: sql9`SUM(${gaSocialReferrals.sessions})` }).from(gaSocialReferrals).where(and17(eq24(gaSocialReferrals.projectId, project.id), sql9`${gaSocialReferrals.date} >= ${daysAgo(14)}`, sql9`${gaSocialReferrals.date} < ${daysAgo(7)}`)).groupBy(gaSocialReferrals.source).all();
     return {
       total: buildTrend(sumTotal),
       organic: buildTrend(sumOrganic),
@@ -21981,14 +22688,14 @@ async function ga4Routes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     requireGa4Connection(opts, project.name, project.canonicalDomain);
     const cutoffDate = windowCutoff(parseWindow(request.query.window))?.slice(0, 10) ?? null;
-    const conditions = [eq23(gaTrafficSnapshots.projectId, project.id)];
+    const conditions = [eq24(gaTrafficSnapshots.projectId, project.id)];
     if (cutoffDate) conditions.push(sql9`${gaTrafficSnapshots.date} >= ${cutoffDate}`);
     const rows = app.db.select({
       date: gaTrafficSnapshots.date,
       sessions: sql9`SUM(${gaTrafficSnapshots.sessions})`,
       organicSessions: sql9`SUM(${gaTrafficSnapshots.organicSessions})`,
       users: sql9`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(and16(...conditions)).groupBy(gaTrafficSnapshots.date).orderBy(gaTrafficSnapshots.date).all();
+    }).from(gaTrafficSnapshots).where(and17(...conditions)).groupBy(gaTrafficSnapshots.date).orderBy(gaTrafficSnapshots.date).all();
     return rows.map((r) => ({
       date: r.date,
       sessions: r.sessions ?? 0,
@@ -22004,7 +22711,7 @@ async function ga4Routes(app, opts) {
       sessions: sql9`SUM(${gaTrafficSnapshots.sessions})`,
       organicSessions: sql9`SUM(${gaTrafficSnapshots.organicSessions})`,
       users: sql9`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(eq23(gaTrafficSnapshots.projectId, project.id)).groupBy(sql9`COALESCE(${gaTrafficSnapshots.landingPageNormalized}, ${gaTrafficSnapshots.landingPage})`).orderBy(sql9`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
+    }).from(gaTrafficSnapshots).where(eq24(gaTrafficSnapshots.projectId, project.id)).groupBy(sql9`COALESCE(${gaTrafficSnapshots.landingPageNormalized}, ${gaTrafficSnapshots.landingPage})`).orderBy(sql9`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
     return {
       pages: trafficPages.map((r) => ({
         landingPage: r.landingPage,
@@ -22138,7 +22845,7 @@ function parseSchemaPageEntry(entry) {
 }
 
 // ../integration-wordpress/src/wordpress-client.ts
-import crypto20 from "crypto";
+import crypto21 from "crypto";
 function validateUsername(username) {
   if (!username || typeof username !== "string" || username.trim().length === 0) {
     throw new WordpressApiError("AUTH_INVALID", "Username is required and must be a non-empty string", 400);
@@ -22351,7 +23058,7 @@ function buildSnippet(content) {
   return `${text2.slice(0, 157)}...`;
 }
 function contentHash(content) {
-  return crypto20.createHash("sha256").update(content).digest("hex");
+  return crypto21.createHash("sha256").update(content).digest("hex");
 }
 function buildAmbiguousSlugMessage(slug, pages) {
   const candidates = pages.map((page) => {
@@ -23651,8 +24358,8 @@ async function wordpressRoutes(app, opts) {
 }
 
 // ../api-routes/src/backlinks.ts
-import crypto21 from "crypto";
-import { and as and18, asc as asc2, desc as desc13, eq as eq24, sql as sql10 } from "drizzle-orm";
+import crypto22 from "crypto";
+import { and as and19, asc as asc3, desc as desc13, eq as eq25, sql as sql10 } from "drizzle-orm";
 
 // ../integration-commoncrawl/src/constants.ts
 import os2 from "os";
@@ -24055,7 +24762,7 @@ function pruneCachedRelease(release, opts = {}) {
 }
 
 // ../api-routes/src/backlinks-filter.ts
-import { and as and17, ne as ne3, notLike } from "drizzle-orm";
+import { and as and18, ne as ne3, notLike } from "drizzle-orm";
 var BACKLINK_FILTER_PATTERNS = [
   "*.google.com",
   "*.googleusercontent.com",
@@ -24078,7 +24785,7 @@ function backlinkCrawlerExclusionClause() {
       conditions.push(ne3(backlinkDomains.linkingDomain, pattern));
     }
   }
-  const combined = and17(...conditions);
+  const combined = and18(...conditions);
   if (!combined) throw new Error("BACKLINK_FILTER_PATTERNS is unexpectedly empty");
   return combined;
 }
@@ -24121,9 +24828,18 @@ function mapSummaryRow(row) {
     totalLinkingDomains: row.totalLinkingDomains,
     totalHosts: row.totalHosts,
     top10HostsShare: row.top10HostsShare,
-    queriedAt: row.queriedAt
+    queriedAt: row.queriedAt,
+    source: row.source
   };
 }
+function parseSourceParam(value) {
+  if (value === void 0 || value === "") return BacklinkSources.commoncrawl;
+  const parsed = backlinkSourceSchema.safeParse(value);
+  if (!parsed.success) {
+    throw validationError(`Invalid source "${value}". Expected one of: ${Object.values(BacklinkSources).join(", ")}.`);
+  }
+  return parsed.data;
+}
 function mapRunRow(row) {
   return {
     id: row.id,
@@ -24138,9 +24854,13 @@ function mapRunRow(row) {
     createdAt: row.createdAt
   };
 }
-function latestSummaryForProject(db, projectId, release) {
-  const condition = release ? and18(eq24(backlinkSummaries.projectId, projectId), eq24(backlinkSummaries.release, release)) : eq24(backlinkSummaries.projectId, projectId);
-  return db.select().from(backlinkSummaries).where(condition).orderBy(desc13(backlinkSummaries.queriedAt)).limit(1).get();
+function latestSummaryForProject(db, projectId, source, release) {
+  const conditions = [
+    eq25(backlinkSummaries.projectId, projectId),
+    eq25(backlinkSummaries.source, source)
+  ];
+  if (release) conditions.push(eq25(backlinkSummaries.release, release));
+  return db.select().from(backlinkSummaries).where(and19(...conditions)).orderBy(desc13(backlinkSummaries.queriedAt)).limit(1).get();
 }
 function parseExcludeCrawlers(value) {
   if (!value) return false;
@@ -24148,11 +24868,12 @@ function parseExcludeCrawlers(value) {
   return lower === "1" || lower === "true" || lower === "yes";
 }
 function computeFilteredSummary(db, base) {
-  const baseDomainCondition = and18(
-    eq24(backlinkDomains.projectId, base.projectId),
-    eq24(backlinkDomains.release, base.release)
+  const baseDomainCondition = and19(
+    eq25(backlinkDomains.projectId, base.projectId),
+    eq25(backlinkDomains.source, base.source),
+    eq25(backlinkDomains.release, base.release)
   );
-  const filteredCondition = and18(baseDomainCondition, backlinkCrawlerExclusionClause());
+  const filteredCondition = and19(baseDomainCondition, backlinkCrawlerExclusionClause());
   const unfilteredAgg = db.select({
     count: sql10`count(*)`,
     total: sql10`coalesce(sum(${backlinkDomains.numHosts}), 0)`
@@ -24176,10 +24897,48 @@ function computeFilteredSummary(db, base) {
     totalHosts,
     top10HostsShare: top10Share.toFixed(6),
     queriedAt: base.queriedAt,
+    source: base.source,
     excludedLinkingDomains: Math.max(0, unfilteredLinkingDomains - totalLinkingDomains),
     excludedHosts: Math.max(0, unfilteredHosts - totalHosts)
   };
 }
+function buildSourceAvailability(db, projectId, source, connected, excludeCrawlers) {
+  const summary = db.select().from(backlinkSummaries).where(and19(eq25(backlinkSummaries.projectId, projectId), eq25(backlinkSummaries.source, source))).orderBy(desc13(backlinkSummaries.queriedAt)).limit(1).get();
+  let totalLinkingDomains = summary?.totalLinkingDomains ?? 0;
+  if (summary && excludeCrawlers) {
+    const filtered = db.select({ count: sql10`count(*)` }).from(backlinkDomains).where(and19(
+      eq25(backlinkDomains.projectId, projectId),
+      eq25(backlinkDomains.source, source),
+      eq25(backlinkDomains.release, summary.release),
+      backlinkCrawlerExclusionClause()
+    )).get();
+    totalLinkingDomains = Number(filtered?.count ?? 0);
+  }
+  return {
+    source,
+    connected,
+    hasData: !!summary,
+    latestRelease: summary?.release ?? null,
+    totalLinkingDomains,
+    lastSyncedAt: summary?.queriedAt ?? null
+  };
+}
+function computeSourceAvailability(db, project, bingStore, excludeCrawlers) {
+  const ccReadySync = db.select({ id: ccReleaseSyncs.id }).from(ccReleaseSyncs).where(eq25(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).limit(1).get();
+  const ccConnected = project.autoExtractBacklinks === true && !!ccReadySync;
+  const bingConnected = !!bingStore?.getConnection(project.canonicalDomain);
+  const sources = [
+    buildSourceAvailability(db, project.id, BacklinkSources.commoncrawl, ccConnected, excludeCrawlers),
+    buildSourceAvailability(db, project.id, BacklinkSources["bing-webmaster"], bingConnected, excludeCrawlers)
+  ];
+  return {
+    projectId: project.id,
+    targetDomain: project.canonicalDomain,
+    sources,
+    anyConnected: sources.some((s) => s.connected),
+    anyData: sources.some((s) => s.hasData)
+  };
+}
 async function backlinksRoutes(app, opts) {
   app.get("/backlinks/status", async (_request, reply) => {
     if (!opts.getBacklinksStatus) {
@@ -24221,7 +24980,7 @@ async function backlinksRoutes(app, opts) {
         "@duckdb/node-api is not installed. Run `canonry backlinks install` to enable the backlinks feature."
       );
     }
-    const existing = app.db.select().from(ccReleaseSyncs).where(eq24(ccReleaseSyncs.release, release)).get();
+    const existing = app.db.select().from(ccReleaseSyncs).where(eq25(ccReleaseSyncs.release, release)).get();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (existing) {
       if (NON_TERMINAL_SYNC_STATUSES.has(existing.status)) {
@@ -24232,12 +24991,12 @@ async function backlinksRoutes(app, opts) {
         phaseDetail: null,
         error: null,
         updatedAt: now
-      }).where(eq24(ccReleaseSyncs.id, existing.id)).run();
+      }).where(eq25(ccReleaseSyncs.id, existing.id)).run();
       opts.onReleaseSyncRequested(existing.id, release);
-      const refreshed = app.db.select().from(ccReleaseSyncs).where(eq24(ccReleaseSyncs.id, existing.id)).get();
+      const refreshed = app.db.select().from(ccReleaseSyncs).where(eq25(ccReleaseSyncs.id, existing.id)).get();
       return reply.status(200).send(mapSyncRow(refreshed));
     }
-    const id = crypto21.randomUUID();
+    const id = crypto22.randomUUID();
     app.db.insert(ccReleaseSyncs).values({
       id,
       release,
@@ -24246,7 +25005,7 @@ async function backlinksRoutes(app, opts) {
       updatedAt: now
     }).run();
     opts.onReleaseSyncRequested(id, release);
-    const inserted = app.db.select().from(ccReleaseSyncs).where(eq24(ccReleaseSyncs.id, id)).get();
+    const inserted = app.db.select().from(ccReleaseSyncs).where(eq25(ccReleaseSyncs.id, id)).get();
     return reply.status(201).send(mapSyncRow(inserted));
   });
   app.get("/backlinks/syncs/latest", async (_request, reply) => {
@@ -24294,7 +25053,7 @@ async function backlinksRoutes(app, opts) {
       throw validationError("Invalid release id");
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const runId = crypto21.randomUUID();
+    const runId = crypto22.randomUUID();
     app.db.insert(runs).values({
       id: runId,
       projectId: project.id,
@@ -24304,14 +25063,15 @@ async function backlinksRoutes(app, opts) {
       createdAt: now
     }).run();
     opts.onBacklinkExtractRequested(runId, project.id, release);
-    const run = app.db.select().from(runs).where(eq24(runs.id, runId)).get();
+    const run = app.db.select().from(runs).where(eq25(runs.id, runId)).get();
     return reply.status(201).send(mapRunRow(run));
   });
   app.get(
     "/projects/:name/backlinks/summary",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const row = latestSummaryForProject(app.db, project.id, request.query.release);
+      const source = parseSourceParam(request.query.source);
+      const row = latestSummaryForProject(app.db, project.id, source, request.query.release);
       if (!row) return reply.send(null);
       const excludeCrawlers = parseExcludeCrawlers(request.query.excludeCrawlers);
       return reply.send(excludeCrawlers ? computeFilteredSummary(app.db, row) : mapSummaryRow(row));
@@ -24319,30 +25079,34 @@ async function backlinksRoutes(app, opts) {
   );
   app.get("/projects/:name/backlinks/domains", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const summaryRow = latestSummaryForProject(app.db, project.id, request.query.release);
+    const source = parseSourceParam(request.query.source);
+    const summaryRow = latestSummaryForProject(app.db, project.id, source, request.query.release);
     const targetRelease = request.query.release ?? summaryRow?.release;
     if (!targetRelease) {
-      const response2 = { summary: null, total: 0, rows: [] };
+      const response2 = { source, summary: null, total: 0, rows: [] };
       return reply.send(response2);
     }
     const limit = Math.min(Math.max(parseInt(request.query.limit ?? "50", 10) || 50, 1), 500);
     const offset = Math.max(parseInt(request.query.offset ?? "0", 10) || 0, 0);
     const excludeCrawlers = parseExcludeCrawlers(request.query.excludeCrawlers);
-    const baseDomainCondition = and18(
-      eq24(backlinkDomains.projectId, project.id),
-      eq24(backlinkDomains.release, targetRelease)
+    const baseDomainCondition = and19(
+      eq25(backlinkDomains.projectId, project.id),
+      eq25(backlinkDomains.source, source),
+      eq25(backlinkDomains.release, targetRelease)
     );
-    const domainCondition = excludeCrawlers ? and18(baseDomainCondition, backlinkCrawlerExclusionClause()) : baseDomainCondition;
+    const domainCondition = excludeCrawlers ? and19(baseDomainCondition, backlinkCrawlerExclusionClause()) : baseDomainCondition;
     const totalRow = app.db.select({ count: sql10`count(*)` }).from(backlinkDomains).where(domainCondition).get();
     const rows = app.db.select({
       linkingDomain: backlinkDomains.linkingDomain,
-      numHosts: backlinkDomains.numHosts
+      numHosts: backlinkDomains.numHosts,
+      source: backlinkDomains.source
     }).from(backlinkDomains).where(domainCondition).orderBy(desc13(backlinkDomains.numHosts)).limit(limit).offset(offset).all();
     let summary = null;
     if (summaryRow) {
       summary = excludeCrawlers ? computeFilteredSummary(app.db, summaryRow) : mapSummaryRow(summaryRow);
     }
     const response = {
+      source,
       summary,
       total: Number(totalRow?.count ?? 0),
       rows
@@ -24353,26 +25117,67 @@ async function backlinksRoutes(app, opts) {
     "/projects/:name/backlinks/history",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const rows = app.db.select().from(backlinkSummaries).where(eq24(backlinkSummaries.projectId, project.id)).orderBy(asc2(backlinkSummaries.queriedAt)).all();
+      const source = parseSourceParam(request.query.source);
+      const rows = app.db.select().from(backlinkSummaries).where(and19(eq25(backlinkSummaries.projectId, project.id), eq25(backlinkSummaries.source, source))).orderBy(asc3(backlinkSummaries.queriedAt)).all();
       const response = rows.map((r) => ({
         release: r.release,
         totalLinkingDomains: r.totalLinkingDomains,
         totalHosts: r.totalHosts,
         top10HostsShare: r.top10HostsShare,
-        queriedAt: r.queriedAt
+        queriedAt: r.queriedAt,
+        source: r.source
       }));
       return reply.send(response);
     }
   );
+  app.get(
+    "/projects/:name/backlinks/sources",
+    async (request, reply) => {
+      const project = resolveProject(app.db, request.params.name);
+      const excludeCrawlers = parseExcludeCrawlers(request.query.excludeCrawlers);
+      const response = computeSourceAvailability(app.db, project, opts.bingConnectionStore, excludeCrawlers);
+      return reply.send(response);
+    }
+  );
+  app.post(
+    "/projects/:name/backlinks/bing-sync",
+    async (request, reply) => {
+      const project = resolveProject(app.db, request.params.name);
+      if (!opts.onBingBacklinkSyncRequested) {
+        throw missingDependency(
+          "Bing backlinks sync is only available from a local canonry install with Bing Webmaster connected."
+        );
+      }
+      const conn = opts.bingConnectionStore?.getConnection(project.canonicalDomain);
+      if (!conn) {
+        throw validationError(
+          `No Bing Webmaster connection for "${project.name}". Run \`canonry bing connect ${project.name} --api-key <key>\` first.`
+        );
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const runId = crypto22.randomUUID();
+      app.db.insert(runs).values({
+        id: runId,
+        projectId: project.id,
+        kind: RunKinds["backlink-extract"],
+        status: RunStatuses.queued,
+        trigger: RunTriggers.manual,
+        createdAt: now
+      }).run();
+      opts.onBingBacklinkSyncRequested(runId, project.id);
+      const run = app.db.select().from(runs).where(eq25(runs.id, runId)).get();
+      return reply.status(201).send(mapRunRow(run));
+    }
+  );
 }
 
 // ../api-routes/src/traffic.ts
-import crypto23 from "crypto";
+import crypto24 from "crypto";
 import { Agent as UndiciAgent } from "undici";
-import { and as and19, desc as desc14, eq as eq25, gte as gte3, lte as lte2, sql as sql11 } from "drizzle-orm";
+import { and as and20, desc as desc14, eq as eq26, gte as gte4, lte as lte3, sql as sql11 } from "drizzle-orm";
 
 // ../integration-cloud-run/src/auth.ts
-import crypto22 from "crypto";
+import crypto23 from "crypto";
 var GOOGLE_TOKEN_URL3 = "https://oauth2.googleapis.com/token";
 var CLOUD_LOGGING_READ_SCOPE = "https://www.googleapis.com/auth/logging.read";
 var TOKEN_REQUEST_TIMEOUT_MS = 3e4;
@@ -24403,7 +25208,7 @@ function createServiceAccountJwt2(clientEmail, privateKey, scope) {
   const headerB64 = encode(header);
   const payloadB64 = encode(payload);
   const signingInput = `${headerB64}.${payloadB64}`;
-  const sign = crypto22.createSign("RSA-SHA256");
+  const sign = crypto23.createSign("RSA-SHA256");
   sign.update(signingInput);
   const signature = sign.sign(privateKey, "base64url");
   return `${signingInput}.${signature}`;
@@ -28186,8 +28991,8 @@ async function runBackfillTask(options) {
     const failedAt = (/* @__PURE__ */ new Date()).toISOString();
     try {
       app.db.transaction((tx) => {
-        tx.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: failedAt }).where(eq25(runs.id, runId)).run();
-        tx.update(trafficSources).set({ status: TrafficSourceStatuses.error, lastError: msg, updatedAt: failedAt }).where(eq25(trafficSources.id, sourceRow.id)).run();
+        tx.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: failedAt }).where(eq26(runs.id, runId)).run();
+        tx.update(trafficSources).set({ status: TrafficSourceStatuses.error, lastError: msg, updatedAt: failedAt }).where(eq26(trafficSources.id, sourceRow.id)).run();
       });
     } catch {
     }
@@ -28202,7 +29007,7 @@ async function runBackfillTask(options) {
   if (allEvents.length === 0) {
     const finishedAt2 = (/* @__PURE__ */ new Date()).toISOString();
     try {
-      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: finishedAt2 }).where(eq25(runs.id, runId)).run();
+      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: finishedAt2 }).where(eq26(runs.id, runId)).run();
     } catch {
     }
     return;
@@ -28224,31 +29029,31 @@ async function runBackfillTask(options) {
   try {
     app.db.transaction((tx) => {
       tx.delete(crawlerEventsHourly).where(
-        and19(
-          eq25(crawlerEventsHourly.sourceId, sourceRow.id),
-          gte3(crawlerEventsHourly.tsHour, windowStartIso),
-          lte2(crawlerEventsHourly.tsHour, windowEndIso)
+        and20(
+          eq26(crawlerEventsHourly.sourceId, sourceRow.id),
+          gte4(crawlerEventsHourly.tsHour, windowStartIso),
+          lte3(crawlerEventsHourly.tsHour, windowEndIso)
         )
       ).run();
       tx.delete(aiUserFetchEventsHourly).where(
-        and19(
-          eq25(aiUserFetchEventsHourly.sourceId, sourceRow.id),
-          gte3(aiUserFetchEventsHourly.tsHour, windowStartIso),
-          lte2(aiUserFetchEventsHourly.tsHour, windowEndIso)
+        and20(
+          eq26(aiUserFetchEventsHourly.sourceId, sourceRow.id),
+          gte4(aiUserFetchEventsHourly.tsHour, windowStartIso),
+          lte3(aiUserFetchEventsHourly.tsHour, windowEndIso)
         )
       ).run();
       tx.delete(aiReferralEventsHourly).where(
-        and19(
-          eq25(aiReferralEventsHourly.sourceId, sourceRow.id),
-          gte3(aiReferralEventsHourly.tsHour, windowStartIso),
-          lte2(aiReferralEventsHourly.tsHour, windowEndIso)
+        and20(
+          eq26(aiReferralEventsHourly.sourceId, sourceRow.id),
+          gte4(aiReferralEventsHourly.tsHour, windowStartIso),
+          lte3(aiReferralEventsHourly.tsHour, windowEndIso)
         )
       ).run();
       tx.delete(rawEventSamples).where(
-        and19(
-          eq25(rawEventSamples.sourceId, sourceRow.id),
-          gte3(rawEventSamples.ts, windowStartIso),
-          lte2(rawEventSamples.ts, windowEndIso)
+        and20(
+          eq26(rawEventSamples.sourceId, sourceRow.id),
+          gte4(rawEventSamples.ts, windowStartIso),
+          lte3(rawEventSamples.ts, windowEndIso)
         )
       ).run();
       for (const bucket of report.crawlerEventsHourly) {
@@ -28311,7 +29116,7 @@ async function runBackfillTask(options) {
           }
         })();
         tx.insert(rawEventSamples).values({
-          id: crypto23.randomUUID(),
+          id: crypto24.randomUUID(),
           projectId: project.id,
           sourceId: sourceRow.id,
           ts: sample.observedAt,
@@ -28335,8 +29140,8 @@ async function runBackfillTask(options) {
         lastError: null,
         lastEventIds: newRingBuffer,
         updatedAt: finishedAt
-      }).where(eq25(trafficSources.id, sourceRow.id)).run();
-      tx.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq25(runs.id, runId)).run();
+      }).where(eq26(trafficSources.id, sourceRow.id)).run();
+      tx.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq26(runs.id, runId)).run();
     });
   } catch (e) {
     markFailed(`Backfill rollup write failed: ${e instanceof Error ? e.message : String(e)}`);
@@ -28418,7 +29223,7 @@ async function trafficRoutes(app, opts) {
       createdAt: existing?.createdAt ?? now,
       updatedAt: now
     });
-    const activeSource = app.db.select().from(trafficSources).where(eq25(trafficSources.projectId, project.id)).all().find((row) => row.sourceType === TrafficSourceTypes["cloud-run"] && row.status !== TrafficSourceStatuses.archived);
+    const activeSource = app.db.select().from(trafficSources).where(eq26(trafficSources.projectId, project.id)).all().find((row) => row.sourceType === TrafficSourceTypes["cloud-run"] && row.status !== TrafficSourceStatuses.archived);
     const config = {
       gcpProjectId,
       serviceName: serviceName ?? null,
@@ -28434,10 +29239,10 @@ async function trafficRoutes(app, opts) {
         lastError: null,
         configJson: config,
         updatedAt: now
-      }).where(eq25(trafficSources.id, activeSource.id)).run();
-      sourceRow = app.db.select().from(trafficSources).where(eq25(trafficSources.id, activeSource.id)).get();
+      }).where(eq26(trafficSources.id, activeSource.id)).run();
+      sourceRow = app.db.select().from(trafficSources).where(eq26(trafficSources.id, activeSource.id)).get();
     } else {
-      const newId = crypto23.randomUUID();
+      const newId = crypto24.randomUUID();
       app.db.insert(trafficSources).values({
         id: newId,
         projectId: project.id,
@@ -28452,7 +29257,7 @@ async function trafficRoutes(app, opts) {
         createdAt: now,
         updatedAt: now
       }).run();
-      sourceRow = app.db.select().from(trafficSources).where(eq25(trafficSources.id, newId)).get();
+      sourceRow = app.db.select().from(trafficSources).where(eq26(trafficSources.id, newId)).get();
     }
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -28504,7 +29309,7 @@ async function trafficRoutes(app, opts) {
       createdAt: existing?.createdAt ?? now,
       updatedAt: now
     });
-    const activeSource = app.db.select().from(trafficSources).where(eq25(trafficSources.projectId, project.id)).all().find((row) => row.sourceType === TrafficSourceTypes.wordpress && row.status !== TrafficSourceStatuses.archived);
+    const activeSource = app.db.select().from(trafficSources).where(eq26(trafficSources.projectId, project.id)).all().find((row) => row.sourceType === TrafficSourceTypes.wordpress && row.status !== TrafficSourceStatuses.archived);
     const config = { baseUrl, username };
     const fallbackName = displayName ?? `WordPress \xB7 ${new URL(baseUrl).host}`;
     let sourceRow;
@@ -28515,10 +29320,10 @@ async function trafficRoutes(app, opts) {
         lastError: null,
         configJson: config,
         updatedAt: now
-      }).where(eq25(trafficSources.id, activeSource.id)).run();
-      sourceRow = app.db.select().from(trafficSources).where(eq25(trafficSources.id, activeSource.id)).get();
+      }).where(eq26(trafficSources.id, activeSource.id)).run();
+      sourceRow = app.db.select().from(trafficSources).where(eq26(trafficSources.id, activeSource.id)).get();
     } else {
-      const newId = crypto23.randomUUID();
+      const newId = crypto24.randomUUID();
       app.db.insert(trafficSources).values({
         id: newId,
         projectId: project.id,
@@ -28533,7 +29338,7 @@ async function trafficRoutes(app, opts) {
         createdAt: now,
         updatedAt: now
       }).run();
-      sourceRow = app.db.select().from(trafficSources).where(eq25(trafficSources.id, newId)).get();
+      sourceRow = app.db.select().from(trafficSources).where(eq26(trafficSources.id, newId)).get();
     }
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -28587,7 +29392,7 @@ async function trafficRoutes(app, opts) {
       createdAt: existing?.createdAt ?? now,
       updatedAt: now
     });
-    const activeSource = app.db.select().from(trafficSources).where(eq25(trafficSources.projectId, project.id)).all().find((row) => row.sourceType === TrafficSourceTypes.vercel && row.status !== TrafficSourceStatuses.archived);
+    const activeSource = app.db.select().from(trafficSources).where(eq26(trafficSources.projectId, project.id)).all().find((row) => row.sourceType === TrafficSourceTypes.vercel && row.status !== TrafficSourceStatuses.archived);
     const config = { projectId, teamId, environment };
     const fallbackName = displayName ?? `Vercel \xB7 ${projectId}`;
     const { sourceRow, scheduleCreated } = app.db.transaction((tx) => {
@@ -28599,10 +29404,10 @@ async function trafficRoutes(app, opts) {
           lastError: null,
           configJson: config,
           updatedAt: now
-        }).where(eq25(trafficSources.id, activeSource.id)).run();
-        row = tx.select().from(trafficSources).where(eq25(trafficSources.id, activeSource.id)).get();
+        }).where(eq26(trafficSources.id, activeSource.id)).run();
+        row = tx.select().from(trafficSources).where(eq26(trafficSources.id, activeSource.id)).get();
       } else {
-        const newId = crypto23.randomUUID();
+        const newId = crypto24.randomUUID();
         tx.insert(trafficSources).values({
           id: newId,
           projectId: project.id,
@@ -28625,18 +29430,18 @@ async function trafficRoutes(app, opts) {
           createdAt: now,
           updatedAt: now
         }).run();
-        row = tx.select().from(trafficSources).where(eq25(trafficSources.id, newId)).get();
+        row = tx.select().from(trafficSources).where(eq26(trafficSources.id, newId)).get();
       }
       const existingSchedule = tx.select().from(schedules).where(
-        and19(
-          eq25(schedules.projectId, project.id),
-          eq25(schedules.kind, SchedulableRunKinds["traffic-sync"])
+        and20(
+          eq26(schedules.projectId, project.id),
+          eq26(schedules.kind, SchedulableRunKinds["traffic-sync"])
         )
       ).get();
       let created = false;
       if (!existingSchedule) {
         tx.insert(schedules).values({
-          id: crypto23.randomUUID(),
+          id: crypto24.randomUUID(),
           projectId: project.id,
           kind: SchedulableRunKinds["traffic-sync"],
           cronExpr: DEFAULT_TRAFFIC_SYNC_CRON,
@@ -28679,7 +29484,7 @@ async function trafficRoutes(app, opts) {
   });
   app.post("/projects/:name/traffic/sources/:id/sync", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const sourceRow = app.db.select().from(trafficSources).where(eq25(trafficSources.id, request.params.id)).get();
+    const sourceRow = app.db.select().from(trafficSources).where(eq26(trafficSources.id, request.params.id)).get();
     if (!sourceRow || sourceRow.projectId !== project.id) {
       throw notFound("Traffic source", request.params.id);
     }
@@ -28691,7 +29496,7 @@ async function trafficRoutes(app, opts) {
     const windowEnd = /* @__PURE__ */ new Date();
     const startedAt = windowEnd.toISOString();
     const syncStartedAtMs = windowEnd.getTime();
-    const runId = crypto23.randomUUID();
+    const runId = crypto24.randomUUID();
     app.db.insert(runs).values({
       id: runId,
       projectId: project.id,
@@ -28705,8 +29510,8 @@ async function trafficRoutes(app, opts) {
     const markFailed = (msg, errorCode) => {
       const failedAt = (/* @__PURE__ */ new Date()).toISOString();
       app.db.transaction((tx) => {
-        tx.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: failedAt }).where(eq25(runs.id, runId)).run();
-        tx.update(trafficSources).set({ status: TrafficSourceStatuses.error, lastError: msg, updatedAt: failedAt }).where(eq25(trafficSources.id, sourceRow.id)).run();
+        tx.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: failedAt }).where(eq26(runs.id, runId)).run();
+        tx.update(trafficSources).set({ status: TrafficSourceStatuses.error, lastError: msg, updatedAt: failedAt }).where(eq26(trafficSources.id, sourceRow.id)).run();
       });
       try {
         opts.onTrafficSynced?.({
@@ -28787,7 +29592,7 @@ async function trafficRoutes(app, opts) {
       }
       const credential = credentialStore.getConnection(project.name);
       if (!credential) {
-        app.db.delete(runs).where(eq25(runs.id, runId)).run();
+        app.db.delete(runs).where(eq26(runs.id, runId)).run();
         throw validationError(
           `No WordPress credential found for project "${project.name}". Run "canonry traffic connect wordpress" first.`
         );
@@ -28836,12 +29641,12 @@ async function trafficRoutes(app, opts) {
       auditAction = "traffic.vercel.synced";
       const credentialStore = opts.vercelTrafficCredentialStore;
       if (!credentialStore) {
-        app.db.delete(runs).where(eq25(runs.id, runId)).run();
+        app.db.delete(runs).where(eq26(runs.id, runId)).run();
         throw validationError("Vercel traffic credential storage is not configured for this deployment");
       }
       const credential = credentialStore.getConnection(project.name);
       if (!credential) {
-        app.db.delete(runs).where(eq25(runs.id, runId)).run();
+        app.db.delete(runs).where(eq26(runs.id, runId)).run();
         throw validationError(
           `No Vercel credential found for project "${project.name}". Run "canonry traffic connect vercel" first.`
         );
@@ -28941,7 +29746,7 @@ async function trafficRoutes(app, opts) {
     let aiReferralHitsCount = 0;
     let unknownHitsCount = 0;
     app.db.transaction((tx) => {
-      const latestRow = tx.select().from(trafficSources).where(eq25(trafficSources.id, sourceRow.id)).get();
+      const latestRow = tx.select().from(trafficSources).where(eq26(trafficSources.id, sourceRow.id)).get();
       const previousIds = latestRow.lastEventIds ?? [];
       const seenEventIds = new Set(previousIds);
       const dedupedEvents = seenEventIds.size === 0 ? allEvents : allEvents.filter((e) => !seenEventIds.has(e.eventId));
@@ -29074,7 +29879,7 @@ async function trafficRoutes(app, opts) {
           }
         })();
         tx.insert(rawEventSamples).values({
-          id: crypto23.randomUUID(),
+          id: crypto24.randomUUID(),
           projectId: project.id,
           sourceId: sourceRow.id,
           ts: sample.observedAt,
@@ -29109,8 +29914,8 @@ async function trafficRoutes(app, opts) {
       if (sourceRow.sourceType === TrafficSourceTypes.wordpress) {
         sourceUpdate.lastCursor = nextCursor ?? null;
       }
-      tx.update(trafficSources).set(sourceUpdate).where(eq25(trafficSources.id, sourceRow.id)).run();
-      tx.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq25(runs.id, runId)).run();
+      tx.update(trafficSources).set(sourceUpdate).where(eq26(trafficSources.id, sourceRow.id)).run();
+      tx.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq26(runs.id, runId)).run();
     });
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -29162,7 +29967,7 @@ async function trafficRoutes(app, opts) {
   });
   app.post("/projects/:name/traffic/sources/:id/backfill", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const sourceRow = app.db.select().from(trafficSources).where(eq25(trafficSources.id, request.params.id)).get();
+    const sourceRow = app.db.select().from(trafficSources).where(eq26(trafficSources.id, request.params.id)).get();
     if (!sourceRow || sourceRow.projectId !== project.id) {
       throw notFound("Traffic source", request.params.id);
     }
@@ -29312,7 +30117,7 @@ async function trafficRoutes(app, opts) {
       };
     }
     const startedAt = windowEnd.toISOString();
-    const runId = crypto23.randomUUID();
+    const runId = crypto24.randomUUID();
     app.db.insert(runs).values({
       id: runId,
       projectId: project.id,
@@ -29347,34 +30152,34 @@ async function trafficRoutes(app, opts) {
   });
   function buildSourceDetail(projectId, row, since) {
     const crawlerTotals = app.db.select({ total: sql11`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(
-      and19(
-        eq25(crawlerEventsHourly.sourceId, row.id),
-        gte3(crawlerEventsHourly.tsHour, since)
+      and20(
+        eq26(crawlerEventsHourly.sourceId, row.id),
+        gte4(crawlerEventsHourly.tsHour, since)
       )
     ).get();
     const aiUserFetchTotals = app.db.select({ total: sql11`COALESCE(SUM(${aiUserFetchEventsHourly.hits}), 0)` }).from(aiUserFetchEventsHourly).where(
-      and19(
-        eq25(aiUserFetchEventsHourly.sourceId, row.id),
-        gte3(aiUserFetchEventsHourly.tsHour, since)
+      and20(
+        eq26(aiUserFetchEventsHourly.sourceId, row.id),
+        gte4(aiUserFetchEventsHourly.tsHour, since)
       )
     ).get();
     const aiTotals = app.db.select({ total: sql11`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(
-      and19(
-        eq25(aiReferralEventsHourly.sourceId, row.id),
-        gte3(aiReferralEventsHourly.tsHour, since)
+      and20(
+        eq26(aiReferralEventsHourly.sourceId, row.id),
+        gte4(aiReferralEventsHourly.tsHour, since)
       )
     ).get();
     const sampleTotals = app.db.select({ total: sql11`COUNT(*)` }).from(rawEventSamples).where(
-      and19(
-        eq25(rawEventSamples.sourceId, row.id),
-        gte3(rawEventSamples.ts, since)
+      and20(
+        eq26(rawEventSamples.sourceId, row.id),
+        gte4(rawEventSamples.ts, since)
       )
     ).get();
     const latestRun = app.db.select().from(runs).where(
-      and19(
-        eq25(runs.projectId, projectId),
-        eq25(runs.kind, RunKinds["traffic-sync"]),
-        eq25(runs.sourceId, row.id)
+      and20(
+        eq26(runs.projectId, projectId),
+        eq26(runs.kind, RunKinds["traffic-sync"]),
+        eq26(runs.sourceId, row.id)
       )
     ).orderBy(desc14(runs.startedAt)).limit(1).get();
     return {
@@ -29402,7 +30207,7 @@ async function trafficRoutes(app, opts) {
         "`advanceToNow` must be `true`. There is no implicit reset."
       );
     }
-    const sourceRow = app.db.select().from(trafficSources).where(and19(eq25(trafficSources.projectId, project.id), eq25(trafficSources.id, request.params.id))).get();
+    const sourceRow = app.db.select().from(trafficSources).where(and20(eq26(trafficSources.projectId, project.id), eq26(trafficSources.id, request.params.id))).get();
     if (!sourceRow) {
       throw notFound("traffic source", request.params.id);
     }
@@ -29419,7 +30224,7 @@ async function trafficRoutes(app, opts) {
         status: TrafficSourceStatuses.connected,
         lastError: null,
         updatedAt: now
-      }).where(eq25(trafficSources.id, sourceRow.id)).run();
+      }).where(eq26(trafficSources.id, sourceRow.id)).run();
       writeAuditLog(tx, auditFromRequest(request, {
         projectId: project.id,
         actor: "api",
@@ -29427,20 +30232,20 @@ async function trafficRoutes(app, opts) {
         entityType: "traffic_source",
         entityId: sourceRow.id
       }));
-      updatedRow = tx.select().from(trafficSources).where(eq25(trafficSources.id, sourceRow.id)).get();
+      updatedRow = tx.select().from(trafficSources).where(eq26(trafficSources.id, sourceRow.id)).get();
     });
     return buildSourceDetail(project.id, updatedRow, new Date(Date.now() - 24 * 60 * 6e4).toISOString());
   });
   app.get("/projects/:name/traffic/sources", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const rows = app.db.select().from(trafficSources).where(eq25(trafficSources.projectId, project.id)).orderBy(desc14(trafficSources.createdAt)).all();
+    const rows = app.db.select().from(trafficSources).where(eq26(trafficSources.projectId, project.id)).orderBy(desc14(trafficSources.createdAt)).all();
     const sources = rows.filter((row) => row.status !== TrafficSourceStatuses.archived).map(rowToDto);
     const response = { sources };
     return response;
   });
   app.get("/projects/:name/traffic/status", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const rows = app.db.select().from(trafficSources).where(eq25(trafficSources.projectId, project.id)).orderBy(desc14(trafficSources.createdAt)).all();
+    const rows = app.db.select().from(trafficSources).where(eq26(trafficSources.projectId, project.id)).orderBy(desc14(trafficSources.createdAt)).all();
     const since = new Date(Date.now() - 24 * 60 * 6e4).toISOString();
     const sources = rows.filter((row) => row.status !== TrafficSourceStatuses.archived).map((row) => buildSourceDetail(project.id, row, since));
     const response = { sources };
@@ -29450,7 +30255,7 @@ async function trafficRoutes(app, opts) {
     "/projects/:name/traffic/sources/:id",
     async (request) => {
       const project = resolveProject(app.db, request.params.name);
-      const row = app.db.select().from(trafficSources).where(eq25(trafficSources.id, request.params.id)).get();
+      const row = app.db.select().from(trafficSources).where(eq26(trafficSources.id, request.params.id)).get();
       if (!row || row.projectId !== project.id) {
         throw notFound("Traffic source", request.params.id);
       }
@@ -29501,12 +30306,12 @@ async function trafficRoutes(app, opts) {
     let aiReferralTotal = 0;
     if (kind === "all" || kind === TrafficEventKinds.crawler) {
       const crawlerFilters = [
-        eq25(crawlerEventsHourly.projectId, project.id),
-        gte3(crawlerEventsHourly.tsHour, sinceIso),
-        lte2(crawlerEventsHourly.tsHour, untilIso)
+        eq26(crawlerEventsHourly.projectId, project.id),
+        gte4(crawlerEventsHourly.tsHour, sinceIso),
+        lte3(crawlerEventsHourly.tsHour, untilIso)
       ];
-      if (sourceIdParam) crawlerFilters.push(eq25(crawlerEventsHourly.sourceId, sourceIdParam));
-      const crawlerWhere = and19(...crawlerFilters);
+      if (sourceIdParam) crawlerFilters.push(eq26(crawlerEventsHourly.sourceId, sourceIdParam));
+      const crawlerWhere = and20(...crawlerFilters);
       const total = app.db.select({ total: sql11`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(crawlerWhere).get();
       crawlerTotal = Number(total?.total ?? 0);
       const rows = app.db.select().from(crawlerEventsHourly).where(crawlerWhere).orderBy(desc14(crawlerEventsHourly.tsHour)).limit(limit).all();
@@ -29526,12 +30331,12 @@ async function trafficRoutes(app, opts) {
     }
     if (kind === "all" || kind === TrafficEventKinds["ai-user-fetch"]) {
       const userFetchFilters = [
-        eq25(aiUserFetchEventsHourly.projectId, project.id),
-        gte3(aiUserFetchEventsHourly.tsHour, sinceIso),
-        lte2(aiUserFetchEventsHourly.tsHour, untilIso)
+        eq26(aiUserFetchEventsHourly.projectId, project.id),
+        gte4(aiUserFetchEventsHourly.tsHour, sinceIso),
+        lte3(aiUserFetchEventsHourly.tsHour, untilIso)
       ];
-      if (sourceIdParam) userFetchFilters.push(eq25(aiUserFetchEventsHourly.sourceId, sourceIdParam));
-      const userFetchWhere = and19(...userFetchFilters);
+      if (sourceIdParam) userFetchFilters.push(eq26(aiUserFetchEventsHourly.sourceId, sourceIdParam));
+      const userFetchWhere = and20(...userFetchFilters);
       const total = app.db.select({ total: sql11`COALESCE(SUM(${aiUserFetchEventsHourly.hits}), 0)` }).from(aiUserFetchEventsHourly).where(userFetchWhere).get();
       aiUserFetchTotal = Number(total?.total ?? 0);
       const rows = app.db.select().from(aiUserFetchEventsHourly).where(userFetchWhere).orderBy(desc14(aiUserFetchEventsHourly.tsHour)).limit(limit).all();
@@ -29551,12 +30356,12 @@ async function trafficRoutes(app, opts) {
     }
     if (kind === "all" || kind === TrafficEventKinds["ai-referral"]) {
       const aiFilters = [
-        eq25(aiReferralEventsHourly.projectId, project.id),
-        gte3(aiReferralEventsHourly.tsHour, sinceIso),
-        lte2(aiReferralEventsHourly.tsHour, untilIso)
+        eq26(aiReferralEventsHourly.projectId, project.id),
+        gte4(aiReferralEventsHourly.tsHour, sinceIso),
+        lte3(aiReferralEventsHourly.tsHour, untilIso)
       ];
-      if (sourceIdParam) aiFilters.push(eq25(aiReferralEventsHourly.sourceId, sourceIdParam));
-      const aiWhere = and19(...aiFilters);
+      if (sourceIdParam) aiFilters.push(eq26(aiReferralEventsHourly.sourceId, sourceIdParam));
+      const aiWhere = and20(...aiFilters);
       const total = app.db.select({ total: sql11`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(aiWhere).get();
       aiReferralTotal = Number(total?.total ?? 0);
       const rows = app.db.select().from(aiReferralEventsHourly).where(aiWhere).orderBy(desc14(aiReferralEventsHourly.tsHour)).limit(limit).all();
@@ -29592,7 +30397,7 @@ async function trafficRoutes(app, opts) {
 }
 
 // ../api-routes/src/doctor/checks/agent.ts
-import crypto24 from "crypto";
+import crypto25 from "crypto";
 import fs6 from "fs";
 import path7 from "path";
 var REQUIRED_SKILLS = ["canonry", "aero"];
@@ -29745,7 +30550,7 @@ function isInstalled(dir) {
 }
 function hashInstalledFile(filePath) {
   try {
-    return crypto24.createHash("sha256").update(fs6.readFileSync(filePath)).digest("hex");
+    return crypto25.createHash("sha256").update(fs6.readFileSync(filePath)).digest("hex");
   } catch {
     return void 0;
   }
@@ -29759,6 +30564,54 @@ function readInstalledManifest(skillDir) {
 }
 var AGENT_CHECKS = [skillsInstalledCheck, skillsCurrentCheck];
 
+// ../api-routes/src/doctor/checks/backlinks.ts
+import { and as and21, eq as eq27 } from "drizzle-orm";
+function skippedNoProject() {
+  return {
+    status: CheckStatuses.skipped,
+    code: "backlinks.source.no-project",
+    summary: "Project context required."
+  };
+}
+var BACKLINKS_CHECKS = [
+  {
+    id: "backlinks.source.connected",
+    category: CheckCategories.integrations,
+    scope: CheckScopes.project,
+    title: "Backlinks source connected",
+    run: (ctx) => {
+      if (!ctx.project) return skippedNoProject();
+      const projectRow = ctx.db.select({ autoExtract: projects.autoExtractBacklinks }).from(projects).where(eq27(projects.id, ctx.project.id)).get();
+      const readySync = ctx.db.select({ id: ccReleaseSyncs.id }).from(ccReleaseSyncs).where(eq27(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).limit(1).get();
+      const ccConnected = projectRow?.autoExtract === true && !!readySync;
+      const bingConnected = !!ctx.bingConnectionStore?.getConnection(ctx.project.canonicalDomain);
+      const connected = [];
+      if (ccConnected) connected.push(BacklinkSources.commoncrawl);
+      if (bingConnected) connected.push(BacklinkSources["bing-webmaster"]);
+      if (connected.length === 0) {
+        return {
+          status: CheckStatuses.warn,
+          code: "backlinks.source.none",
+          summary: `No backlink source is set up for ${ctx.project.name}.`,
+          remediation: `Enable Common Crawl (set autoExtractBacklinks on the project + run \`canonry backlinks sync\`) or connect Bing Webmaster (\`canonry bing connect ${ctx.project.name} --api-key <key>\` then \`canonry backlinks bing-sync ${ctx.project.name}\`).`,
+          details: { commoncrawl: ccConnected, bingWebmaster: bingConnected }
+        };
+      }
+      const ccHasData = ccConnected ? !!ctx.db.select({ id: backlinkSummaries.id }).from(backlinkSummaries).where(and21(
+        eq27(backlinkSummaries.projectId, ctx.project.id),
+        eq27(backlinkSummaries.source, BacklinkSources.commoncrawl)
+      )).limit(1).get() : false;
+      return {
+        status: CheckStatuses.ok,
+        code: "backlinks.source.connected",
+        summary: `${connected.length} backlink source${connected.length === 1 ? "" : "s"} set up: ${connected.join(", ")}.`,
+        remediation: ccConnected && !ccHasData ? `Common Crawl is ready but no backlinks have been extracted for ${ctx.project.name} yet \u2014 run \`canonry backlinks extract ${ctx.project.name}\`.` : null,
+        details: { commoncrawl: ccConnected, bingWebmaster: bingConnected, connected, commoncrawlHasData: ccHasData }
+      };
+    }
+  }
+];
+
 // ../api-routes/src/doctor/checks/bing-auth.ts
 var BING_AUTH_CHECKS = [
   {
@@ -29906,10 +30759,10 @@ var BING_AUTH_CHECKS = [
 ];
 
 // ../api-routes/src/doctor/checks/content.ts
-import { eq as eq26 } from "drizzle-orm";
+import { eq as eq28 } from "drizzle-orm";
 var WINNABILITY_COVERAGE_WARN_THRESHOLD = 0.8;
 var UNCLASSIFIED_DOMAIN_SAMPLE_LIMIT = 10;
-function skippedNoProject() {
+function skippedNoProject2() {
   return {
     status: CheckStatuses.skipped,
     code: "content.winnability.no-project",
@@ -29919,7 +30772,7 @@ function skippedNoProject() {
 }
 function loadProject(ctx) {
   if (!ctx.project) return null;
-  return ctx.db.select().from(projects).where(eq26(projects.id, ctx.project.id)).get() ?? null;
+  return ctx.db.select().from(projects).where(eq28(projects.id, ctx.project.id)).get() ?? null;
 }
 function percent(value) {
   return Math.round(value * 100);
@@ -29930,7 +30783,7 @@ var winnabilityCoverageCheck = {
   scope: CheckScopes.project,
   title: "Content winnability classification coverage",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject();
+    if (!ctx.project) return skippedNoProject2();
     const project = loadProject(ctx);
     if (!project) {
       return {
@@ -30010,6 +30863,123 @@ var CONTENT_CHECK_BY_ID = Object.fromEntries(
   CONTENT_CHECKS.map((check) => [check.id, check])
 );
 
+// ../api-routes/src/doctor/checks/ads.ts
+import { eq as eq29 } from "drizzle-orm";
+var RECENT_SYNC_WARN_DAYS = 7;
+var RECENT_SYNC_FAIL_DAYS = 30;
+var adsConnectionCheck = {
+  id: "ads.auth.connection",
+  category: CheckCategories.auth,
+  scope: CheckScopes.project,
+  title: "OpenAI ads connection",
+  run: (ctx) => {
+    if (!ctx.project) {
+      return {
+        status: CheckStatuses.skipped,
+        code: "ads.auth.no-project",
+        summary: "Project context required.",
+        remediation: null
+      };
+    }
+    const row = ctx.db.select().from(adsConnections).where(eq29(adsConnections.projectId, ctx.project.id)).get();
+    if (!row) {
+      return {
+        status: CheckStatuses.skipped,
+        code: "ads.auth.not-connected",
+        summary: "No OpenAI ads connection for this project.",
+        remediation: null
+      };
+    }
+    if (!ctx.adsCredentialStore) {
+      return {
+        status: CheckStatuses.skipped,
+        code: "ads.auth.store-unavailable",
+        summary: "No ads credential store configured for this deployment.",
+        remediation: null
+      };
+    }
+    const cfg = ctx.adsCredentialStore.getConnection(ctx.project.name);
+    if (!cfg?.apiKey) {
+      return {
+        status: CheckStatuses.fail,
+        code: "ads.auth.missing-key",
+        summary: "An ads connection row exists but no SDK key is stored in the local config.",
+        remediation: `Re-run \`canonry ads connect ${ctx.project.name} --api-key <sdk-key>\` to restore the credential.`,
+        details: { adAccountId: row.adAccountId }
+      };
+    }
+    return {
+      status: CheckStatuses.ok,
+      code: "ads.auth.ok",
+      summary: `Connected to ad account ${row.displayName ?? row.adAccountId}.`,
+      remediation: null,
+      details: { adAccountId: row.adAccountId }
+    };
+  }
+};
+var adsRecentSyncCheck = {
+  id: "ads.data.recent-sync",
+  category: CheckCategories.integrations,
+  scope: CheckScopes.project,
+  title: "OpenAI ads recent sync",
+  run: (ctx) => {
+    if (!ctx.project) {
+      return {
+        status: CheckStatuses.skipped,
+        code: "ads.data.no-project",
+        summary: "Project context required.",
+        remediation: null
+      };
+    }
+    const row = ctx.db.select().from(adsConnections).where(eq29(adsConnections.projectId, ctx.project.id)).get();
+    if (!row) {
+      return {
+        status: CheckStatuses.skipped,
+        code: "ads.data.not-connected",
+        summary: "No OpenAI ads connection for this project.",
+        remediation: null
+      };
+    }
+    if (!row.lastSyncedAt) {
+      return {
+        status: CheckStatuses.warn,
+        code: "ads.data.never-synced",
+        summary: "The connected ad account has never been synced.",
+        remediation: `Run \`canonry ads sync ${ctx.project.name}\` (and schedule it: \`canonry schedule set ${ctx.project.name} --kind ads-sync --preset daily\`).`
+      };
+    }
+    const syncedAtMs = new Date(row.lastSyncedAt).getTime();
+    const ageDays = (Date.now() - syncedAtMs) / (1e3 * 60 * 60 * 24);
+    const details = { lastSyncedAt: row.lastSyncedAt, ageDays: Math.round(ageDays) };
+    if (ageDays > RECENT_SYNC_FAIL_DAYS) {
+      return {
+        status: CheckStatuses.fail,
+        code: "ads.data.stale",
+        summary: `Last ads sync was ${Math.round(ageDays)} days ago (> ${RECENT_SYNC_FAIL_DAYS}d).`,
+        remediation: `Run \`canonry ads sync ${ctx.project.name}\` and check the ads-sync schedule.`,
+        details
+      };
+    }
+    if (ageDays > RECENT_SYNC_WARN_DAYS) {
+      return {
+        status: CheckStatuses.warn,
+        code: "ads.data.aging",
+        summary: `Last ads sync was ${Math.round(ageDays)} days ago (> ${RECENT_SYNC_WARN_DAYS}d).`,
+        remediation: `Schedule daily syncs: \`canonry schedule set ${ctx.project.name} --kind ads-sync --preset daily\`.`,
+        details
+      };
+    }
+    return {
+      status: CheckStatuses.ok,
+      code: "ads.data.ok",
+      summary: `Last ads sync ${Math.round(ageDays)} day(s) ago.`,
+      remediation: null,
+      details
+    };
+  }
+};
+var ADS_CHECKS = [adsConnectionCheck, adsRecentSyncCheck];
+
 // ../api-routes/src/doctor/checks/ga-auth.ts
 async function checkServiceAccount(conn) {
   if (!conn.propertyId) {
@@ -30152,10 +31122,10 @@ var ga4ConnectionCheck = {
 var GA_AUTH_CHECKS = [ga4ConnectionCheck];
 
 // ../api-routes/src/doctor/checks/gbp-auth.ts
-import { and as and20, eq as eq27 } from "drizzle-orm";
-var RECENT_SYNC_WARN_DAYS = 7;
-var RECENT_SYNC_FAIL_DAYS = 30;
-function skippedNoProject2() {
+import { and as and22, eq as eq30 } from "drizzle-orm";
+var RECENT_SYNC_WARN_DAYS2 = 7;
+var RECENT_SYNC_FAIL_DAYS2 = 30;
+function skippedNoProject3() {
   return {
     status: CheckStatuses.skipped,
     code: "gbp.auth.no-project",
@@ -30172,7 +31142,7 @@ function storeUnavailable() {
   };
 }
 async function resolveGbpToken(ctx) {
-  if (!ctx.project) return { ok: false, output: skippedNoProject2() };
+  if (!ctx.project) return { ok: false, output: skippedNoProject3() };
   const store = ctx.googleConnectionStore;
   if (!store) return { ok: false, output: storeUnavailable() };
   const auth = ctx.getGoogleAuthConfig?.() ?? {};
@@ -30250,7 +31220,7 @@ var scopesCheck = {
   scope: CheckScopes.project,
   title: "GBP granted scopes",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject2();
+    if (!ctx.project) return skippedNoProject3();
     const store = ctx.googleConnectionStore;
     if (!store) return storeUnavailable();
     const conn = store.getConnection(ctx.project.canonicalDomain, "gbp");
@@ -30287,7 +31257,7 @@ var accountAccessCheck = {
   scope: CheckScopes.project,
   title: "GBP account access",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject2();
+    if (!ctx.project) return skippedNoProject3();
     const store = ctx.googleConnectionStore;
     if (!store) return storeUnavailable();
     const conn = store.getConnection(ctx.project.canonicalDomain, "gbp");
@@ -30384,8 +31354,8 @@ var recentSyncCheck = {
   scope: CheckScopes.project,
   title: "GBP recent sync",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject2();
-    const selected = ctx.db.select({ locationName: gbpLocations.locationName, syncedAt: gbpLocations.syncedAt }).from(gbpLocations).where(and20(eq27(gbpLocations.projectId, ctx.project.id), eq27(gbpLocations.selected, true))).all();
+    if (!ctx.project) return skippedNoProject3();
+    const selected = ctx.db.select({ locationName: gbpLocations.locationName, syncedAt: gbpLocations.syncedAt }).from(gbpLocations).where(and22(eq30(gbpLocations.projectId, ctx.project.id), eq30(gbpLocations.selected, true))).all();
     if (selected.length === 0) {
       return {
         status: CheckStatuses.skipped,
@@ -30407,20 +31377,20 @@ var recentSyncCheck = {
     const newest = Math.max(...syncTimes);
     const ageDays = (Date.now() - newest) / (1e3 * 60 * 60 * 24);
     const details = { selectedLocations: selected.length, newestSyncAgeDays: Math.round(ageDays) };
-    if (ageDays > RECENT_SYNC_FAIL_DAYS) {
+    if (ageDays > RECENT_SYNC_FAIL_DAYS2) {
       return {
         status: CheckStatuses.fail,
         code: "gbp.data.stale",
-        summary: `Most recent GBP sync was ${Math.round(ageDays)} days ago (> ${RECENT_SYNC_FAIL_DAYS}d).`,
+        summary: `Most recent GBP sync was ${Math.round(ageDays)} days ago (> ${RECENT_SYNC_FAIL_DAYS2}d).`,
         remediation: `Run \`canonry gbp sync ${ctx.project.name}\` or set a gbp-sync schedule.`,
         details
       };
     }
-    if (ageDays > RECENT_SYNC_WARN_DAYS) {
+    if (ageDays > RECENT_SYNC_WARN_DAYS2) {
       return {
         status: CheckStatuses.warn,
         code: "gbp.data.aging",
-        summary: `Most recent GBP sync was ${Math.round(ageDays)} days ago (> ${RECENT_SYNC_WARN_DAYS}d).`,
+        summary: `Most recent GBP sync was ${Math.round(ageDays)} days ago (> ${RECENT_SYNC_WARN_DAYS2}d).`,
         remediation: `Run \`canonry gbp sync ${ctx.project.name}\` or set a gbp-sync schedule to keep data fresh.`,
         details
       };
@@ -30445,7 +31415,7 @@ var GBP_AUTH_CHECK_BY_ID = Object.fromEntries(
 );
 
 // ../api-routes/src/doctor/checks/places.ts
-import { eq as eq28 } from "drizzle-orm";
+import { eq as eq31 } from "drizzle-orm";
 var apiKeyCheck = {
   id: "gbp.places.api-key",
   category: CheckCategories.auth,
@@ -30490,7 +31460,7 @@ var apiKeyCheck = {
         details: { tier: cfg.tier }
       };
     }
-    const rows = ctx.db.select({ placeId: gbpLocations.placeId, selected: gbpLocations.selected }).from(gbpLocations).where(eq28(gbpLocations.projectId, ctx.project.id)).all();
+    const rows = ctx.db.select({ placeId: gbpLocations.placeId, selected: gbpLocations.selected }).from(gbpLocations).where(eq31(gbpLocations.projectId, ctx.project.id)).all();
     const selected = rows.filter((r) => r.selected);
     const locationsWithPlaceId = selected.filter((r) => Boolean(r.placeId)).length;
     const details = {
@@ -30526,7 +31496,7 @@ var PLACES_CHECK_BY_ID = Object.fromEntries(
 var REQUIRED_GSC_SCOPES = [GSC_SCOPE, INDEXING_SCOPE];
 async function resolveAccessToken(ctx) {
   if (!ctx.project) {
-    return { ok: false, output: skippedNoProject3() };
+    return { ok: false, output: skippedNoProject4() };
   }
   const store = ctx.googleConnectionStore;
   if (!store) {
@@ -30593,7 +31563,7 @@ async function resolveAccessToken(ctx) {
     };
   }
 }
-function skippedNoProject3() {
+function skippedNoProject4() {
   return {
     status: CheckStatuses.skipped,
     code: "google.auth.no-project",
@@ -30623,7 +31593,7 @@ var propertyAccessCheck = {
   scope: CheckScopes.project,
   title: "GSC property access",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const store = ctx.googleConnectionStore;
     if (!store) {
       return {
@@ -30724,7 +31694,7 @@ var redirectUriCheck = {
   scope: CheckScopes.project,
   title: "OAuth redirect URI",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const auth = ctx.getGoogleAuthConfig?.() ?? {};
     if (!auth.clientId || !auth.clientSecret) {
       return {
@@ -30778,7 +31748,7 @@ var scopesCheck2 = {
   scope: CheckScopes.project,
   title: "GSC granted scopes",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const store = ctx.googleConnectionStore;
     if (!store) {
       return {
@@ -30941,10 +31911,10 @@ var RUNTIME_STATE_CHECKS = [
 ];
 
 // ../api-routes/src/doctor/checks/traffic-source.ts
-import { and as and21, eq as eq29, gte as gte4, ne as ne4, sql as sql12 } from "drizzle-orm";
+import { and as and23, eq as eq32, gte as gte5, ne as ne4, sql as sql12 } from "drizzle-orm";
 var RECENT_DATA_WARN_DAYS = 7;
 var RECENT_DATA_FAIL_DAYS = 30;
-function skippedNoProject4() {
+function skippedNoProject5() {
   return {
     status: CheckStatuses.skipped,
     code: "traffic.no-project",
@@ -30955,8 +31925,8 @@ function skippedNoProject4() {
 function loadProbes(ctx) {
   if (!ctx.project) return [];
   const rows = ctx.db.select().from(trafficSources).where(
-    and21(
-      eq29(trafficSources.projectId, ctx.project.id),
+    and23(
+      eq32(trafficSources.projectId, ctx.project.id),
       ne4(trafficSources.status, TrafficSourceStatuses.archived)
     )
   ).all();
@@ -30978,7 +31948,7 @@ var sourceConnectedCheck = {
   scope: CheckScopes.project,
   title: "Traffic source connected",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject4();
+    if (!ctx.project) return skippedNoProject5();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -31022,7 +31992,7 @@ var recentDataCheck = {
   scope: CheckScopes.project,
   title: "Traffic source recent data",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject4();
+    if (!ctx.project) return skippedNoProject5();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -31036,17 +32006,17 @@ var recentDataCheck = {
     const failCutoff = new Date(now.getTime() - RECENT_DATA_FAIL_DAYS * 24 * 60 * 6e4).toISOString();
     const recentCrawlers = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(
-        and21(
-          eq29(crawlerEventsHourly.projectId, ctx.project.id),
-          gte4(crawlerEventsHourly.tsHour, warnCutoff)
+        and23(
+          eq32(crawlerEventsHourly.projectId, ctx.project.id),
+          gte5(crawlerEventsHourly.tsHour, warnCutoff)
         )
       ).get()?.total ?? 0
     );
     const recentReferrals = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(
-        and21(
-          eq29(aiReferralEventsHourly.projectId, ctx.project.id),
-          gte4(aiReferralEventsHourly.tsHour, warnCutoff)
+        and23(
+          eq32(aiReferralEventsHourly.projectId, ctx.project.id),
+          gte5(aiReferralEventsHourly.tsHour, warnCutoff)
         )
       ).get()?.total ?? 0
     );
@@ -31060,17 +32030,17 @@ var recentDataCheck = {
     }
     const olderCrawlers = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(
-        and21(
-          eq29(crawlerEventsHourly.projectId, ctx.project.id),
-          gte4(crawlerEventsHourly.tsHour, failCutoff)
+        and23(
+          eq32(crawlerEventsHourly.projectId, ctx.project.id),
+          gte5(crawlerEventsHourly.tsHour, failCutoff)
         )
       ).get()?.total ?? 0
     );
     const olderReferrals = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(
-        and21(
-          eq29(aiReferralEventsHourly.projectId, ctx.project.id),
-          gte4(aiReferralEventsHourly.tsHour, failCutoff)
+        and23(
+          eq32(aiReferralEventsHourly.projectId, ctx.project.id),
+          gte5(aiReferralEventsHourly.tsHour, failCutoff)
         )
       ).get()?.total ?? 0
     );
@@ -31184,7 +32154,7 @@ var credentialsCheck = {
   scope: CheckScopes.project,
   title: "Traffic source credentials",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject4();
+    if (!ctx.project) return skippedNoProject5();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -31213,7 +32183,7 @@ var scopesCheck3 = {
   scope: CheckScopes.project,
   title: "Traffic source scopes",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject4();
+    if (!ctx.project) return skippedNoProject5();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -31242,7 +32212,7 @@ var cacheBlindSpotCheck = {
   scope: CheckScopes.project,
   title: "WordPress traffic cache blind spot",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject4();
+    if (!ctx.project) return skippedNoProject5();
     const wpSources = loadProbes(ctx).filter(
       (s) => s.sourceType === TrafficSourceTypes.wordpress
     );
@@ -31354,8 +32324,10 @@ var ALL_CHECKS = [
   ...BING_AUTH_CHECKS,
   ...WORDPRESS_PUBLISH_CHECKS,
   ...GA_AUTH_CHECKS,
+  ...ADS_CHECKS,
   ...PROVIDERS_CHECKS,
   ...TRAFFIC_SOURCE_CHECKS,
+  ...BACKLINKS_CHECKS,
   ...CONTENT_CHECKS,
   ...AGENT_CHECKS
 ];
@@ -31440,6 +32412,7 @@ async function doctorRoutes(app, opts) {
       bingConnectionStore: opts.bingConnectionStore,
       wordpressConnectionStore: opts.wordpressConnectionStore,
       ga4CredentialStore: opts.ga4CredentialStore,
+      adsCredentialStore: opts.adsCredentialStore,
       getGoogleAuthConfig: opts.getGoogleAuthConfig,
       getPlacesConfig: opts.getPlacesConfig,
       redirectUri,
@@ -31465,6 +32438,7 @@ async function doctorRoutes(app, opts) {
       bingConnectionStore: opts.bingConnectionStore,
       wordpressConnectionStore: opts.wordpressConnectionStore,
       ga4CredentialStore: opts.ga4CredentialStore,
+      adsCredentialStore: opts.adsCredentialStore,
       getGoogleAuthConfig: opts.getGoogleAuthConfig,
       getPlacesConfig: opts.getPlacesConfig,
       redirectUri,
@@ -31478,8 +32452,8 @@ async function doctorRoutes(app, opts) {
 }
 
 // ../api-routes/src/discovery/routes.ts
-import crypto25 from "crypto";
-import { and as and22, desc as desc15, eq as eq30, gte as gte5, inArray as inArray10 } from "drizzle-orm";
+import crypto26 from "crypto";
+import { and as and24, desc as desc15, eq as eq33, gte as gte6, inArray as inArray11 } from "drizzle-orm";
 var MAX_INFLIGHT_DISCOVERY_AGE_MS = 2 * 60 * 60 * 1e3;
 async function discoveryRoutes(app, opts) {
   app.post("/projects/:name/discover/run", async (request, reply) => {
@@ -31511,21 +32485,21 @@ async function discoveryRoutes(app, opts) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const ageFloorIso = new Date(Date.now() - MAX_INFLIGHT_DISCOVERY_AGE_MS).toISOString();
     const decision = app.db.transaction((tx) => {
-      const existing = tx.select({ id: discoverySessions.id, runId: discoverySessions.runId }).from(discoverySessions).where(and22(
-        eq30(discoverySessions.projectId, project.id),
-        eq30(discoverySessions.icpDescription, icpDescription),
-        inArray10(discoverySessions.status, [
+      const existing = tx.select({ id: discoverySessions.id, runId: discoverySessions.runId }).from(discoverySessions).where(and24(
+        eq33(discoverySessions.projectId, project.id),
+        eq33(discoverySessions.icpDescription, icpDescription),
+        inArray11(discoverySessions.status, [
           DiscoverySessionStatuses.queued,
           DiscoverySessionStatuses.seeding,
           DiscoverySessionStatuses.probing
         ]),
-        gte5(discoverySessions.createdAt, ageFloorIso)
+        gte6(discoverySessions.createdAt, ageFloorIso)
       )).orderBy(desc15(discoverySessions.createdAt)).get();
       if (existing && existing.runId) {
         return { reused: true, sessionId: existing.id, runId: existing.runId };
       }
-      const sessionId = crypto25.randomUUID();
-      const runId = crypto25.randomUUID();
+      const sessionId = crypto26.randomUUID();
+      const runId = crypto26.randomUUID();
       tx.insert(discoverySessions).values({
         id: sessionId,
         projectId: project.id,
@@ -31583,7 +32557,7 @@ async function discoveryRoutes(app, opts) {
       const project = resolveProject(app.db, request.params.name);
       const parsedLimit = parseInt(request.query.limit ?? "", 10);
       const limit = Number.isNaN(parsedLimit) || parsedLimit <= 0 ? 50 : parsedLimit;
-      const rows = app.db.select().from(discoverySessions).where(eq30(discoverySessions.projectId, project.id)).orderBy(desc15(discoverySessions.createdAt)).limit(limit).all();
+      const rows = app.db.select().from(discoverySessions).where(eq33(discoverySessions.projectId, project.id)).orderBy(desc15(discoverySessions.createdAt)).limit(limit).all();
       return reply.send(rows.map(serializeSession));
     }
   );
@@ -31591,11 +32565,11 @@ async function discoveryRoutes(app, opts) {
     "/projects/:name/discover/sessions/:id",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const session = app.db.select().from(discoverySessions).where(eq30(discoverySessions.id, request.params.id)).get();
+      const session = app.db.select().from(discoverySessions).where(eq33(discoverySessions.id, request.params.id)).get();
       if (!session || session.projectId !== project.id) {
         throw notFound("Discovery session", request.params.id);
       }
-      const probeRows = app.db.select().from(discoveryProbes).where(eq30(discoveryProbes.sessionId, session.id)).all();
+      const probeRows = app.db.select().from(discoveryProbes).where(eq33(discoveryProbes.sessionId, session.id)).all();
       const detail = {
         ...serializeSession(session),
         probes: probeRows.map(serializeProbe)
@@ -31607,12 +32581,12 @@ async function discoveryRoutes(app, opts) {
     "/projects/:name/discover/sessions/:id/promote",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const session = app.db.select().from(discoverySessions).where(eq30(discoverySessions.id, request.params.id)).get();
+      const session = app.db.select().from(discoverySessions).where(eq33(discoverySessions.id, request.params.id)).get();
       if (!session || session.projectId !== project.id) {
         throw notFound("Discovery session", request.params.id);
       }
-      const probeRows = app.db.select().from(discoveryProbes).where(eq30(discoveryProbes.sessionId, session.id)).all();
-      const existingCompetitors = app.db.select({ domain: competitors.domain }).from(competitors).where(eq30(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase());
+      const probeRows = app.db.select().from(discoveryProbes).where(eq33(discoveryProbes.sessionId, session.id)).all();
+      const existingCompetitors = app.db.select({ domain: competitors.domain }).from(competitors).where(eq33(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase());
       const seenCompetitors = new Set(existingCompetitors);
       const cited = /* @__PURE__ */ new Set();
       const aspirational = /* @__PURE__ */ new Set();
@@ -31641,7 +32615,7 @@ async function discoveryRoutes(app, opts) {
   );
   app.post("/projects/:name/discover/sessions/:id/promote", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const session = app.db.select().from(discoverySessions).where(eq30(discoverySessions.id, request.params.id)).get();
+    const session = app.db.select().from(discoverySessions).where(eq33(discoverySessions.id, request.params.id)).get();
     if (!session || session.projectId !== project.id) {
       throw notFound("Discovery session", request.params.id);
     }
@@ -31664,7 +32638,7 @@ async function discoveryRoutes(app, opts) {
     const bucketSet = new Set(buckets);
     const includeCompetitors = parsed.data.includeCompetitors ?? true;
     const competitorTypes = parsed.data.competitorTypes ?? DEFAULT_DISCOVERY_PROMOTE_COMPETITOR_TYPES;
-    const probeRows = app.db.select().from(discoveryProbes).where(eq30(discoveryProbes.sessionId, session.id)).all();
+    const probeRows = app.db.select().from(discoveryProbes).where(eq33(discoveryProbes.sessionId, session.id)).all();
     const candidateQueries = /* @__PURE__ */ new Set();
     for (const probe of probeRows) {
       if (!probe.bucket) continue;
@@ -31672,7 +32646,7 @@ async function discoveryRoutes(app, opts) {
       if (bucket.success && bucketSet.has(bucket.data)) candidateQueries.add(probe.query);
     }
     const existingQueries = new Set(
-      app.db.select({ query: queries.query }).from(queries).where(eq30(queries.projectId, project.id)).all().map((r) => r.query.toLowerCase())
+      app.db.select({ query: queries.query }).from(queries).where(eq33(queries.projectId, project.id)).all().map((r) => r.query.toLowerCase())
     );
     const promotedQueries = [];
     const skippedQueries = [];
@@ -31688,7 +32662,7 @@ async function discoveryRoutes(app, opts) {
     const skippedCompetitors = [];
     if (includeCompetitors) {
       const existingCompetitors = new Set(
-        app.db.select({ domain: competitors.domain }).from(competitors).where(eq30(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase())
+        app.db.select({ domain: competitors.domain }).from(competitors).where(eq33(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase())
       );
       const competitorMap = parseCompetitorMap(session.competitorMap);
       for (const entry of selectEligibleCompetitors(competitorMap, competitorTypes)) {
@@ -31707,7 +32681,7 @@ async function discoveryRoutes(app, opts) {
       app.db.transaction((tx) => {
         for (const query of promotedQueries) {
           tx.insert(queries).values({
-            id: crypto25.randomUUID(),
+            id: crypto26.randomUUID(),
             projectId: project.id,
             query,
             provenance,
@@ -31716,7 +32690,7 @@ async function discoveryRoutes(app, opts) {
         }
         for (const domain of promotedCompetitors) {
           tx.insert(competitors).values({
-            id: crypto25.randomUUID(),
+            id: crypto26.randomUUID(),
             projectId: project.id,
             domain,
             provenance,
@@ -31791,8 +32765,8 @@ function selectEligibleCompetitors(competitorMap, competitorTypes) {
 }
 
 // ../api-routes/src/discovery/orchestrate.ts
-import crypto26 from "crypto";
-import { eq as eq31 } from "drizzle-orm";
+import crypto27 from "crypto";
+import { eq as eq34 } from "drizzle-orm";
 var DEFAULT_MAX_PROBES = 100;
 var ABSOLUTE_MAX_PROBES = 500;
 function classifyProbeBucket(input) {
@@ -31846,7 +32820,7 @@ async function executeDiscovery(opts) {
     status: DiscoverySessionStatuses.seeding,
     dedupThreshold,
     startedAt
-  }).where(eq31(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq34(discoverySessions.id, opts.sessionId)).run();
   const seedResult = await opts.deps.seed({
     project: opts.project,
     icpDescription: opts.icpDescription,
@@ -31872,7 +32846,7 @@ async function executeDiscovery(opts) {
     seedCountRaw,
     seedCount,
     warning
-  }).where(eq31(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq34(discoverySessions.id, opts.sessionId)).run();
   const probeRows = [];
   const buckets = { cited: 0, aspirational: 0, "wasted-surface": 0 };
   for (const query of probedCanonicals) {
@@ -31885,7 +32859,7 @@ async function executeDiscovery(opts) {
     probeRows.push({ citedDomains: probe.citedDomains, bucket });
     buckets[bucket]++;
     opts.db.insert(discoveryProbes).values({
-      id: crypto26.randomUUID(),
+      id: crypto27.randomUUID(),
       sessionId: opts.sessionId,
       projectId: opts.project.id,
       query,
@@ -31912,7 +32886,7 @@ async function executeDiscovery(opts) {
     wastedCount: buckets["wasted-surface"],
     competitorMap,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq31(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq34(discoverySessions.id, opts.sessionId)).run();
   upsertDomainClassifications(opts.db, opts.project.id, opts.sessionId, competitorMap);
   return {
     buckets,
@@ -31929,7 +32903,7 @@ function upsertDomainClassifications(db, projectId, sessionId, competitorMap) {
     const domain = normalizeDomain(entry.domain);
     if (!domain) continue;
     db.insert(domainClassifications).values({
-      id: crypto26.randomUUID(),
+      id: crypto27.randomUUID(),
       projectId,
       domain,
       competitorType: entry.competitorType,
@@ -31952,7 +32926,7 @@ function markSessionFailed(db, sessionId, error) {
     status: DiscoverySessionStatuses.failed,
     error,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq31(discoverySessions.id, sessionId)).run();
+  }).where(eq34(discoverySessions.id, sessionId)).run();
 }
 function dedupeStrings(input) {
   const seen = /* @__PURE__ */ new Set();
@@ -31969,8 +32943,8 @@ function dedupeStrings(input) {
 }
 
 // ../api-routes/src/technical-aeo.ts
-import crypto27 from "crypto";
-import { and as and23, asc as asc3, count, desc as desc16, eq as eq32, inArray as inArray11 } from "drizzle-orm";
+import crypto28 from "crypto";
+import { and as and25, asc as asc4, count, desc as desc16, eq as eq35, inArray as inArray12 } from "drizzle-orm";
 var SURFACEABLE_STATUSES = [RunStatuses.completed, RunStatuses.partial];
 function emptyScore(projectName) {
   return {
@@ -32002,10 +32976,10 @@ function parsePositiveInt(value, fallback, max) {
 async function technicalAeoRoutes(app, opts) {
   app.get("/projects/:name/technical-aeo", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const rows = app.db.select({ snap: siteAuditSnapshots, runStatus: runs.status }).from(siteAuditSnapshots).innerJoin(runs, eq32(siteAuditSnapshots.runId, runs.id)).where(and23(
-      eq32(siteAuditSnapshots.projectId, project.id),
-      eq32(runs.kind, RunKinds["site-audit"]),
-      inArray11(runs.status, SURFACEABLE_STATUSES),
+    const rows = app.db.select({ snap: siteAuditSnapshots, runStatus: runs.status }).from(siteAuditSnapshots).innerJoin(runs, eq35(siteAuditSnapshots.runId, runs.id)).where(and25(
+      eq35(siteAuditSnapshots.projectId, project.id),
+      eq35(runs.kind, RunKinds["site-audit"]),
+      inArray12(runs.status, SURFACEABLE_STATUSES),
       notProbeRun()
     )).orderBy(desc16(siteAuditSnapshots.createdAt)).limit(2).all();
     const latest = rows[0];
@@ -32037,24 +33011,24 @@ async function technicalAeoRoutes(app, opts) {
   });
   app.get("/projects/:name/technical-aeo/pages", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const latest = app.db.select({ runId: siteAuditSnapshots.runId, auditedAt: siteAuditSnapshots.auditedAt }).from(siteAuditSnapshots).innerJoin(runs, eq32(siteAuditSnapshots.runId, runs.id)).where(and23(
-      eq32(siteAuditSnapshots.projectId, project.id),
-      eq32(runs.kind, RunKinds["site-audit"]),
-      inArray11(runs.status, SURFACEABLE_STATUSES),
+    const latest = app.db.select({ runId: siteAuditSnapshots.runId, auditedAt: siteAuditSnapshots.auditedAt }).from(siteAuditSnapshots).innerJoin(runs, eq35(siteAuditSnapshots.runId, runs.id)).where(and25(
+      eq35(siteAuditSnapshots.projectId, project.id),
+      eq35(runs.kind, RunKinds["site-audit"]),
+      inArray12(runs.status, SURFACEABLE_STATUSES),
       notProbeRun()
     )).orderBy(desc16(siteAuditSnapshots.createdAt)).limit(1).get();
     if (!latest) {
       return { project: project.name, runId: null, auditedAt: null, total: 0, pages: [] };
     }
     const statusFilter = request.query.status === "success" || request.query.status === "error" ? request.query.status : null;
-    const conds = [eq32(siteAuditPages.runId, latest.runId)];
-    if (statusFilter) conds.push(eq32(siteAuditPages.status, statusFilter));
-    const where = and23(...conds);
+    const conds = [eq35(siteAuditPages.runId, latest.runId)];
+    if (statusFilter) conds.push(eq35(siteAuditPages.status, statusFilter));
+    const where = and25(...conds);
     const totalRow = app.db.select({ value: count() }).from(siteAuditPages).where(where).get();
     const total = totalRow?.value ?? 0;
     const limit = parsePositiveInt(request.query.limit, 100, 500);
     const offset = parsePositiveInt(request.query.offset, 0, Number.MAX_SAFE_INTEGER);
-    const orderBy = request.query.sort === "score-desc" ? desc16(siteAuditPages.overallScore) : request.query.sort === "url" ? asc3(siteAuditPages.url) : asc3(siteAuditPages.overallScore);
+    const orderBy = request.query.sort === "score-desc" ? desc16(siteAuditPages.overallScore) : request.query.sort === "url" ? asc4(siteAuditPages.url) : asc4(siteAuditPages.overallScore);
     const rows = app.db.select().from(siteAuditPages).where(where).orderBy(orderBy).limit(limit).offset(offset).all();
     const pages = rows.map((row) => ({
       url: row.url,
@@ -32073,10 +33047,10 @@ async function technicalAeoRoutes(app, opts) {
       auditedAt: siteAuditSnapshots.auditedAt,
       aggregateScore: siteAuditSnapshots.aggregateScore,
       pagesAudited: siteAuditSnapshots.pagesAudited
-    }).from(siteAuditSnapshots).innerJoin(runs, eq32(siteAuditSnapshots.runId, runs.id)).where(and23(
-      eq32(siteAuditSnapshots.projectId, project.id),
-      eq32(runs.kind, RunKinds["site-audit"]),
-      inArray11(runs.status, SURFACEABLE_STATUSES),
+    }).from(siteAuditSnapshots).innerJoin(runs, eq35(siteAuditSnapshots.runId, runs.id)).where(and25(
+      eq35(siteAuditSnapshots.projectId, project.id),
+      eq35(runs.kind, RunKinds["site-audit"]),
+      inArray12(runs.status, SURFACEABLE_STATUSES),
       notProbeRun()
     )).orderBy(desc16(siteAuditSnapshots.createdAt)).limit(limit).all();
     return { project: project.name, points: rows.reverse() };
@@ -32087,16 +33061,16 @@ async function technicalAeoRoutes(app, opts) {
     if (!parsed.success) {
       throw validationError(parsed.error.issues[0]?.message ?? "Invalid site-audit request");
     }
-    const existing = app.db.select({ id: runs.id, status: runs.status }).from(runs).where(and23(
-      eq32(runs.projectId, project.id),
-      eq32(runs.kind, RunKinds["site-audit"]),
-      inArray11(runs.status, [RunStatuses.queued, RunStatuses.running])
+    const existing = app.db.select({ id: runs.id, status: runs.status }).from(runs).where(and25(
+      eq35(runs.projectId, project.id),
+      eq35(runs.kind, RunKinds["site-audit"]),
+      inArray12(runs.status, [RunStatuses.queued, RunStatuses.running])
     )).get();
     if (existing) {
       return { runId: existing.id, status: existing.status };
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const runId = crypto27.randomUUID();
+    const runId = crypto28.randomUUID();
     app.db.insert(runs).values({
       id: runId,
       projectId: project.id,
@@ -32223,6 +33197,11 @@ async function apiRoutes(app, opts) {
       getTelemetryStatus: opts.getTelemetryStatus,
       setTelemetryEnabled: opts.setTelemetryEnabled
     });
+    await api.register(adsRoutes, {
+      adsCredentialStore: opts.adsCredentialStore,
+      verifyAdsAccount: opts.verifyAdsAccount,
+      onAdsSyncRequested: opts.onAdsSyncRequested
+    });
     await api.register(bingRoutes, {
       bingConnectionStore: opts.bingConnectionStore,
       onInspectSitemapRequested: opts.onBingInspectSitemapRequested
@@ -32271,6 +33250,8 @@ async function apiRoutes(app, opts) {
       onInstallBacklinks: opts.onInstallBacklinks,
       onReleaseSyncRequested: opts.onReleaseSyncRequested,
       onBacklinkExtractRequested: opts.onBacklinkExtractRequested,
+      onBingBacklinkSyncRequested: opts.onBingBacklinkSyncRequested,
+      bingConnectionStore: opts.bingConnectionStore,
       onBacklinksPruneCache: opts.onBacklinksPruneCache,
       listCachedReleases: opts.listCachedReleases,
       discoverLatestRelease: opts.discoverLatestRelease
@@ -32286,6 +33267,7 @@ async function apiRoutes(app, opts) {
       bingConnectionStore: opts.bingConnectionStore,
       wordpressConnectionStore: opts.wordpressConnectionStore,
       ga4CredentialStore: opts.ga4CredentialStore,
+      adsCredentialStore: opts.adsCredentialStore,
       getGoogleAuthConfig: opts.getGoogleAuthConfig,
       getPlacesConfig: opts.getPlacesConfig,
       publicUrl: opts.publicUrl,
@@ -32436,7 +33418,7 @@ function buildTrafficSourceValidators(opts) {
 }
 
 // src/intelligence-service.ts
-import crypto28 from "crypto";
+import crypto29 from "crypto";
 
 // src/logger.ts
 var IS_TTY = process.stdout.isTTY === true;
@@ -32668,9 +33650,9 @@ var IntelligenceService = class {
    */
   analyzeAndPersist(runId, projectId) {
     const recentRuns = this.db.select().from(runs).where(
-      and24(
-        eq33(runs.projectId, projectId),
-        or5(eq33(runs.status, "completed"), eq33(runs.status, "partial")),
+      and26(
+        eq36(runs.projectId, projectId),
+        or5(eq36(runs.status, "completed"), eq36(runs.status, "partial")),
         // Defensive: RunCoordinator already skips probes before this is
         // called, but if a future call site invokes analyzeAndPersist
         // directly for a probe, probes still must not pollute the
@@ -32752,7 +33734,7 @@ var IntelligenceService = class {
    * Returns the persisted insights so the coordinator can count critical/high.
    */
   analyzeAndPersistGbp(runId, projectId) {
-    const runRow = this.db.select({ createdAt: runs.createdAt, startedAt: runs.startedAt, finishedAt: runs.finishedAt }).from(runs).where(eq33(runs.id, runId)).get();
+    const runRow = this.db.select({ createdAt: runs.createdAt, startedAt: runs.startedAt, finishedAt: runs.finishedAt }).from(runs).where(eq36(runs.id, runId)).get();
     if (!runRow) {
       log.info("gbp-intelligence.skip", { runId, reason: "run not found" });
       this.persistGbpInsights(runId, projectId, [], []);
@@ -32760,11 +33742,11 @@ var IntelligenceService = class {
     }
     const windowStart = runRow.startedAt ?? runRow.createdAt;
     const windowEnd = runRow.finishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-    const selected = this.db.select().from(gbpLocations).where(and24(
-      eq33(gbpLocations.projectId, projectId),
-      eq33(gbpLocations.selected, true),
-      gte6(gbpLocations.syncedAt, windowStart),
-      lte3(gbpLocations.syncedAt, windowEnd)
+    const selected = this.db.select().from(gbpLocations).where(and26(
+      eq36(gbpLocations.projectId, projectId),
+      eq36(gbpLocations.selected, true),
+      gte7(gbpLocations.syncedAt, windowStart),
+      lte4(gbpLocations.syncedAt, windowEnd)
     )).all();
     if (selected.length === 0) {
       log.info("gbp-intelligence.skip", { runId, reason: "no locations synced during run" });
@@ -32797,10 +33779,10 @@ var IntelligenceService = class {
   }
   /** Build the per-location signal bundle the GBP analyzer consumes. */
   buildGbpLocationSignals(projectId, locationName, displayName, fallbackDate) {
-    const metricRows = this.db.select({ metric: gbpDailyMetrics.metric, date: gbpDailyMetrics.date, value: gbpDailyMetrics.value }).from(gbpDailyMetrics).where(and24(eq33(gbpDailyMetrics.projectId, projectId), eq33(gbpDailyMetrics.locationName, locationName))).all();
-    const placeActionRows = this.db.select({ placeActionType: gbpPlaceActions.placeActionType, providerType: gbpPlaceActions.providerType }).from(gbpPlaceActions).where(and24(eq33(gbpPlaceActions.projectId, projectId), eq33(gbpPlaceActions.locationName, locationName))).all();
-    const lodgingRow = this.db.select({ populatedGroupCount: gbpLodgingSnapshots.populatedGroupCount }).from(gbpLodgingSnapshots).where(and24(eq33(gbpLodgingSnapshots.projectId, projectId), eq33(gbpLodgingSnapshots.locationName, locationName))).orderBy(desc17(gbpLodgingSnapshots.syncedAt)).limit(1).get();
-    const placeRow = this.db.select({ attributes: gbpPlaceDetails.attributes }).from(gbpPlaceDetails).where(and24(eq33(gbpPlaceDetails.projectId, projectId), eq33(gbpPlaceDetails.locationName, locationName))).orderBy(desc17(gbpPlaceDetails.syncedAt)).limit(1).get();
+    const metricRows = this.db.select({ metric: gbpDailyMetrics.metric, date: gbpDailyMetrics.date, value: gbpDailyMetrics.value }).from(gbpDailyMetrics).where(and26(eq36(gbpDailyMetrics.projectId, projectId), eq36(gbpDailyMetrics.locationName, locationName))).all();
+    const placeActionRows = this.db.select({ placeActionType: gbpPlaceActions.placeActionType, providerType: gbpPlaceActions.providerType }).from(gbpPlaceActions).where(and26(eq36(gbpPlaceActions.projectId, projectId), eq36(gbpPlaceActions.locationName, locationName))).all();
+    const lodgingRow = this.db.select({ populatedGroupCount: gbpLodgingSnapshots.populatedGroupCount }).from(gbpLodgingSnapshots).where(and26(eq36(gbpLodgingSnapshots.projectId, projectId), eq36(gbpLodgingSnapshots.locationName, locationName))).orderBy(desc17(gbpLodgingSnapshots.syncedAt)).limit(1).get();
+    const placeRow = this.db.select({ attributes: gbpPlaceDetails.attributes }).from(gbpPlaceDetails).where(and26(eq36(gbpPlaceDetails.projectId, projectId), eq36(gbpPlaceDetails.locationName, locationName))).orderBy(desc17(gbpPlaceDetails.syncedAt)).limit(1).get();
     const placesAmenities = placeRow ? extractPlaceAmenities(placeRow.attributes) : [];
     const summary = buildGbpSummary({
       locationName,
@@ -32832,7 +33814,7 @@ var IntelligenceService = class {
   /** Build the month-over-month keyword series for a location from the
    *  accumulating gbp_keyword_monthly table (latest complete month vs prior). */
   buildGbpKeywordTrend(projectId, locationName) {
-    const rows = this.db.select({ month: gbpKeywordMonthly.month, keyword: gbpKeywordMonthly.keyword, valueCount: gbpKeywordMonthly.valueCount }).from(gbpKeywordMonthly).where(and24(eq33(gbpKeywordMonthly.projectId, projectId), eq33(gbpKeywordMonthly.locationName, locationName))).all();
+    const rows = this.db.select({ month: gbpKeywordMonthly.month, keyword: gbpKeywordMonthly.keyword, valueCount: gbpKeywordMonthly.valueCount }).from(gbpKeywordMonthly).where(and26(eq36(gbpKeywordMonthly.projectId, projectId), eq36(gbpKeywordMonthly.locationName, locationName))).all();
     if (rows.length === 0) return { recentMonth: null, priorMonth: null, points: [] };
     const months = [...new Set(rows.map((r) => r.month))].sort().reverse();
     const recentMonth = months[0] ?? null;
@@ -32863,7 +33845,7 @@ var IntelligenceService = class {
    */
   persistGbpInsights(runId, projectId, gbpInsights, coveredLocationNames) {
     const covered = new Set(coveredLocationNames);
-    const existing = this.db.select({ id: insights.id, dismissed: insights.dismissed }).from(insights).where(and24(eq33(insights.projectId, projectId), eq33(insights.provider, GBP_INSIGHT_PROVIDER))).all();
+    const existing = this.db.select({ id: insights.id, dismissed: insights.dismissed }).from(insights).where(and26(eq36(insights.projectId, projectId), eq36(insights.provider, GBP_INSIGHT_PROVIDER))).all();
     const staleIds = [];
     const dismissedSlots = /* @__PURE__ */ new Set();
     for (const row of existing) {
@@ -32874,7 +33856,7 @@ var IntelligenceService = class {
     }
     this.db.transaction((tx) => {
       for (const id of staleIds) {
-        tx.delete(insights).where(eq33(insights.id, id)).run();
+        tx.delete(insights).where(eq36(insights.id, id)).run();
       }
       for (const insight of gbpInsights) {
         const parsed = parseGbpInsightId(insight.id);
@@ -32952,7 +33934,7 @@ var IntelligenceService = class {
    *     create per run + aggregate). DB is left untouched.
    */
   backfill(projectName, opts, onProgress) {
-    const project = this.db.select().from(projects).where(eq33(projects.name, projectName)).get();
+    const project = this.db.select().from(projects).where(eq36(projects.name, projectName)).get();
     if (!project) {
       throw new Error(`Project "${projectName}" not found`);
     }
@@ -32965,13 +33947,13 @@ var IntelligenceService = class {
       sinceTimestamp = parsed;
     }
     const allRuns = this.db.select().from(runs).where(
-      and24(
-        eq33(runs.projectId, project.id),
-        or5(eq33(runs.status, "completed"), eq33(runs.status, "partial")),
+      and26(
+        eq36(runs.projectId, project.id),
+        or5(eq36(runs.status, "completed"), eq36(runs.status, "partial")),
         // Backfill must not replay probe runs as if they were real sweeps.
         ne5(runs.trigger, RunTriggers.probe)
       )
-    ).orderBy(asc4(runs.finishedAt)).all();
+    ).orderBy(asc5(runs.finishedAt)).all();
     let startIdx = 0;
     let endIdx = allRuns.length;
     if (opts?.fromRunId) {
@@ -33000,7 +33982,7 @@ var IntelligenceService = class {
     let wouldDeleteTotal = 0;
     const existingByRunId = /* @__PURE__ */ new Map();
     if (isDryRun && targetRuns.length > 0) {
-      const rows = this.db.select({ runId: insights.runId }).from(insights).where(inArray12(insights.runId, targetRuns.map((r) => r.id))).all();
+      const rows = this.db.select({ runId: insights.runId }).from(insights).where(inArray13(insights.runId, targetRuns.map((r) => r.id))).all();
       for (const r of rows) {
         if (r.runId == null) continue;
         existingByRunId.set(r.runId, (existingByRunId.get(r.runId) ?? 0) + 1);
@@ -33046,7 +34028,7 @@ var IntelligenceService = class {
     return { processed, skipped, totalInsights };
   }
   loadTrackedCompetitors(projectId) {
-    return this.db.select({ domain: competitors.domain }).from(competitors).where(eq33(competitors.projectId, projectId)).all().map((r) => r.domain);
+    return this.db.select({ domain: competitors.domain }).from(competitors).where(eq36(competitors.projectId, projectId)).all().map((r) => r.domain);
   }
   /**
    * Wipe transition signals from an analysis result while keeping health.
@@ -33067,15 +34049,15 @@ var IntelligenceService = class {
   }
   persistResult(result, runId, projectId) {
     const previouslyDismissed = /* @__PURE__ */ new Set();
-    const existingInsights = this.db.select({ query: insights.query, provider: insights.provider, type: insights.type, dismissed: insights.dismissed }).from(insights).where(eq33(insights.runId, runId)).all();
+    const existingInsights = this.db.select({ query: insights.query, provider: insights.provider, type: insights.type, dismissed: insights.dismissed }).from(insights).where(eq36(insights.runId, runId)).all();
     for (const row of existingInsights) {
       if (row.dismissed) {
         previouslyDismissed.add(`${row.query}:${row.provider}:${row.type}`);
       }
     }
     this.db.transaction((tx) => {
-      tx.delete(insights).where(eq33(insights.runId, runId)).run();
-      tx.delete(healthSnapshots).where(eq33(healthSnapshots.runId, runId)).run();
+      tx.delete(insights).where(eq36(insights.runId, runId)).run();
+      tx.delete(healthSnapshots).where(eq36(healthSnapshots.runId, runId)).run();
       const now = (/* @__PURE__ */ new Date()).toISOString();
       for (const insight of result.insights) {
         const wasDismissed = previouslyDismissed.has(`${insight.query}:${insight.provider}:${insight.type}`);
@@ -33095,7 +34077,7 @@ var IntelligenceService = class {
         }).run();
       }
       tx.insert(healthSnapshots).values({
-        id: crypto28.randomUUID(),
+        id: crypto29.randomUUID(),
         projectId,
         runId,
         overallCitedRate: String(result.health.overallCitedRate),
@@ -33126,24 +34108,24 @@ var IntelligenceService = class {
   applySeverityTiering(rawInsights, excludeRunId, projectId) {
     const regressions = rawInsights.filter((i) => i.type === "regression");
     if (regressions.length === 0) return rawInsights;
-    const gscRows = this.db.select({ query: gscSearchData.query, impressions: gscSearchData.impressions }).from(gscSearchData).where(eq33(gscSearchData.projectId, projectId)).all();
+    const gscRows = this.db.select({ query: gscSearchData.query, impressions: gscSearchData.impressions }).from(gscSearchData).where(eq36(gscSearchData.projectId, projectId)).all();
     const gscConnected = gscRows.length > 0;
     const gscImpressionsByQuery = /* @__PURE__ */ new Map();
     for (const row of gscRows) {
       const key = row.query.toLowerCase();
       gscImpressionsByQuery.set(key, (gscImpressionsByQuery.get(key) ?? 0) + row.impressions);
     }
-    const projectRow = this.db.select({ locations: projects.locations }).from(projects).where(eq33(projects.id, projectId)).get();
+    const projectRow = this.db.select({ locations: projects.locations }).from(projects).where(eq36(projects.id, projectId)).get();
     const locationCount = Math.max(
       1,
       (projectRow?.locations ?? []).length
     );
     const ROWS_PER_GROUP_BUDGET = Math.max(2, locationCount);
     const recentRunRows = this.db.select({ id: runs.id, createdAt: runs.createdAt }).from(runs).where(
-      and24(
-        eq33(runs.projectId, projectId),
-        eq33(runs.kind, RunKinds["answer-visibility"]),
-        or5(eq33(runs.status, "completed"), eq33(runs.status, "partial")),
+      and26(
+        eq36(runs.projectId, projectId),
+        eq36(runs.kind, RunKinds["answer-visibility"]),
+        or5(eq36(runs.status, "completed"), eq36(runs.status, "partial")),
         // Defensive — see top of file.
         ne5(runs.trigger, RunTriggers.probe)
       )
@@ -33163,7 +34145,7 @@ var IntelligenceService = class {
     const haveHistory = recentRunIds.length > 0;
     const priorRegressionsByPair = /* @__PURE__ */ new Map();
     if (haveHistory) {
-      const priorRows = this.db.select({ query: insights.query, provider: insights.provider, runId: insights.runId }).from(insights).where(and24(eq33(insights.type, "regression"), inArray12(insights.runId, recentRunIds))).all();
+      const priorRows = this.db.select({ query: insights.query, provider: insights.provider, runId: insights.runId }).from(insights).where(and26(eq36(insights.type, "regression"), inArray13(insights.runId, recentRunIds))).all();
       const regressionGroups = /* @__PURE__ */ new Map();
       for (const row of priorRows) {
         if (!row.runId) continue;
@@ -33192,7 +34174,7 @@ var IntelligenceService = class {
     });
   }
   buildRunData(runId, projectId, completedAt, location = null) {
-    const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq33(projects.id, projectId)).get();
+    const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq36(projects.id, projectId)).get();
     const projectDomains = projectDomainRow ? effectiveDomains({
       canonicalDomain: projectDomainRow.canonicalDomain,
       ownedDomains: projectDomainRow.ownedDomains
@@ -33208,7 +34190,7 @@ var IntelligenceService = class {
       citedDomains: querySnapshots.citedDomains,
       competitorOverlap: querySnapshots.competitorOverlap,
       snapshotLocation: querySnapshots.location
-    }).from(querySnapshots).leftJoin(queries, eq33(querySnapshots.queryId, queries.id)).where(eq33(querySnapshots.runId, runId)).all();
+    }).from(querySnapshots).leftJoin(queries, eq36(querySnapshots.queryId, queries.id)).where(eq36(querySnapshots.runId, runId)).all();
     const snapshots = [];
     let orphanCount = 0;
     for (const r of rows) {
@@ -33283,6 +34265,11 @@ export {
   gbpPlaceActions,
   gbpLodgingSnapshots,
   gbpPlaceDetails,
+  adsConnections,
+  adsCampaigns,
+  adsAdGroups,
+  adsAds,
+  adsInsightsDaily,
   createClient,
   parseJsonColumn,
   extractLegacyCredentials,
@@ -33315,6 +34302,8 @@ export {
   hashLodging,
   getUrlInfo,
   getCrawlIssues,
+  getLinkCounts,
+  getUrlLinks,
   PLUGIN_DIR,
   DUCKDB_SPEC,
   CC_CACHE_DIR,