@ainyc/canonry 4.78.0 → 4.81.0

package/dist/{chunk-QKTIP6GC.js → chunk-VX5C7DK7.js}

@@ -9,7 +9,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-XI6YSTGE.js";
+} from "./chunk-6XOZSS3Y.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -17,6 +17,11 @@ import {
   GSC_DATA_LAG_DAYS,
   IntelligenceService,
   PLUGIN_DIR,
+  adsAdGroups,
+  adsAds,
+  adsCampaigns,
+  adsConnections,
+  adsInsightsDaily,
   agentMemory,
   agentSessions,
   aiUserFetchEventsHourly,
@@ -57,9 +62,11 @@ import {
   gbpPlaceActions,
   gbpPlaceDetails,
   getCrawlIssues,
+  getLinkCounts,
   getLodging,
   getPlaceDetails,
   getUrlInfo,
+  getUrlLinks,
   groupRunsByCreatedAt,
   gscCoverageSnapshots,
   gscSearchData,
@@ -97,13 +104,14 @@ import {
   siteAuditPages,
   siteAuditSnapshots,
   usageCounters
-} from "./chunk-3WXARKUE.js";
+} from "./chunk-UAQ42NVJ.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
   AI_ENGINE_DOMAINS,
   AI_ENGINE_SELF_DOMAINS,
   AgentProviderIds,
+  BacklinkSources,
   CcReleaseSyncStatuses,
   CodingAgents,
   DiscoveryCompetitorTypes,
@@ -131,12 +139,15 @@ import {
   buildRunErrorFromMessages,
   classifySkillFile,
   coerceSkillManifest,
+  computeBacklinkSummaryMetrics,
   contentActionLabel,
   contentBriefDtoSchema,
   determineAnswerMentioned,
+  dollarsToMicros,
   effectiveBrandNames,
   effectiveDomains,
   factorStatusFromScore,
+  hostOf,
   isAgentProviderId,
   isBrowserProvider,
   isRetryableHttpError,
@@ -149,7 +160,7 @@ import {
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-KPN22EWK.js";
+} from "./chunk-GMT3YPLT.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -437,11 +448,11 @@ function checkLatestVersionForServer(opts) {
 
 // src/server.ts
 import { createRequire as createRequire3 } from "module";
-import crypto18 from "crypto";
+import crypto20 from "crypto";
 import fs8 from "fs";
 import path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { and as and13, eq as eq18 } from "drizzle-orm";
+import { and as and14, eq as eq20 } from "drizzle-orm";
 import Fastify from "fastify";
 import os5 from "os";
 
@@ -4077,12 +4088,361 @@ function monthKey(m) {
   return `${m.year}-${String(m.month).padStart(2, "0")}`;
 }
 
-// src/gsc-inspect-sitemap.ts
+// src/ads-sync.ts
 import crypto6 from "crypto";
-import { eq as eq4, and as and4 } from "drizzle-orm";
+import { eq as eq4 } from "drizzle-orm";
+
+// ../integration-openai-ads/src/constants.ts
+var OPENAI_ADS_API_BASE = "https://api.ads.openai.com/v1";
+var OPENAI_ADS_REQUEST_TIMEOUT_MS = 3e4;
+var OPENAI_ADS_MAX_PAGES = 100;
+
+// ../integration-openai-ads/src/types.ts
+var OpenAiAdsApiError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code = null) {
+    super(message);
+    this.name = "OpenAiAdsApiError";
+    this.status = status;
+    this.code = code;
+  }
+};
+function parseErrorEnvelope(body) {
+  try {
+    const parsed = JSON.parse(body);
+    return {
+      message: parsed.error?.message ?? null,
+      code: parsed.error?.code ?? null
+    };
+  } catch {
+    return { message: null, code: null };
+  }
+}
+
+// ../integration-openai-ads/src/ads-client.ts
+function validateApiKey(apiKey) {
+  if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length === 0) {
+    throw new OpenAiAdsApiError("API key is required and must be a non-empty string", 400);
+  }
+}
+function validateId(value, label) {
+  if (!value || typeof value !== "string" || value.trim().length === 0) {
+    throw new OpenAiAdsApiError(`${label} is required and must be a non-empty string`, 400);
+  }
+}
+function adsClientLog(level, action, ctx) {
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    module: "OpenAiAdsClient",
+    action,
+    ...ctx
+  };
+  if (entry.apiKey) entry.apiKey = "***";
+  const stream = level === "error" ? process.stderr : process.stdout;
+  stream.write(JSON.stringify(entry) + "\n");
+}
+function buildUrl(path10, queryPairs) {
+  const qs = queryPairs.join("&");
+  return qs ? `${OPENAI_ADS_API_BASE}/${path10}?${qs}` : `${OPENAI_ADS_API_BASE}/${path10}`;
+}
+async function adsFetch(apiKey, path10, queryPairs = []) {
+  const url = buildUrl(path10, queryPairs);
+  const res = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    signal: AbortSignal.timeout(OPENAI_ADS_REQUEST_TIMEOUT_MS)
+  });
+  if (res.status === 401 || res.status === 403) {
+    const { code } = parseErrorEnvelope(await res.text());
+    adsClientLog("error", "http.auth-failed", { path: path10, httpStatus: res.status, code });
+    throw new OpenAiAdsApiError("OpenAI Ads API key is invalid or unauthorized", res.status, code);
+  }
+  if (res.status === 429) {
+    const { code } = parseErrorEnvelope(await res.text());
+    adsClientLog("error", "http.rate-limited", { path: path10, httpStatus: 429, code });
+    throw new OpenAiAdsApiError("OpenAI Ads API rate limit exceeded", 429, code);
+  }
+  if (!res.ok) {
+    const body = await res.text();
+    const { message, code } = parseErrorEnvelope(body);
+    adsClientLog("error", "http.error", { path: path10, httpStatus: res.status, code });
+    const detail = message ?? (body.length <= 500 ? body : `${body.slice(0, 500)}... [truncated]`);
+    throw new OpenAiAdsApiError(`OpenAI Ads API error (${res.status}): ${detail}`, res.status, code);
+  }
+  const text = await res.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new OpenAiAdsApiError("OpenAI Ads API returned invalid JSON", 502);
+  }
+}
+async function fetchAllPages(apiKey, path10, queryPairs) {
+  const items = [];
+  let after = null;
+  for (let page = 0; page < OPENAI_ADS_MAX_PAGES; page++) {
+    const pairs = after ? [...queryPairs, `after=${encodeURIComponent(after)}`] : [...queryPairs];
+    const response = await adsFetch(apiKey, path10, pairs);
+    items.push(...response.data);
+    if (!response.has_more || !response.last_id) {
+      return items;
+    }
+    after = response.last_id;
+  }
+  adsClientLog("error", "pagination.cap-reached", { path: path10, pages: OPENAI_ADS_MAX_PAGES, items: items.length });
+  return items;
+}
+function insightsPairs(opts) {
+  return (opts?.fields ?? []).map((field) => `fields[]=${encodeURIComponent(field)}`);
+}
+async function getAdAccount(apiKey) {
+  validateApiKey(apiKey);
+  return adsFetch(apiKey, "ad_account");
+}
+async function listCampaigns(apiKey) {
+  validateApiKey(apiKey);
+  return fetchAllPages(apiKey, "campaigns", []);
+}
+async function listAdGroups(apiKey, campaignId) {
+  validateApiKey(apiKey);
+  validateId(campaignId, "Campaign id");
+  return fetchAllPages(apiKey, "ad_groups", [`campaign_id=${encodeURIComponent(campaignId)}`]);
+}
+async function listAds(apiKey, adGroupId) {
+  validateApiKey(apiKey);
+  validateId(adGroupId, "Ad group id");
+  return fetchAllPages(apiKey, "ads", [`ad_group_id=${encodeURIComponent(adGroupId)}`]);
+}
+async function getCampaignInsights(apiKey, campaignId, opts) {
+  validateApiKey(apiKey);
+  validateId(campaignId, "Campaign id");
+  return fetchAllPages(
+    apiKey,
+    `campaigns/${encodeURIComponent(campaignId)}/insights`,
+    insightsPairs(opts)
+  );
+}
+async function getAdGroupInsights(apiKey, adGroupId, opts) {
+  validateApiKey(apiKey);
+  validateId(adGroupId, "Ad group id");
+  return fetchAllPages(
+    apiKey,
+    `ad_groups/${encodeURIComponent(adGroupId)}/insights`,
+    insightsPairs(opts)
+  );
+}
+
+// src/ads-config.ts
+function ensureConnections7(config) {
+  if (!config.openaiAds) config.openaiAds = {};
+  if (!config.openaiAds.connections) config.openaiAds.connections = [];
+  return config.openaiAds.connections;
+}
+function getOpenAiAdsConnection(config, projectName) {
+  return (config.openaiAds?.connections ?? []).find((c) => c.projectName === projectName);
+}
+function upsertOpenAiAdsConnection(config, connection) {
+  const connections = ensureConnections7(config);
+  const index = connections.findIndex((c) => c.projectName === connection.projectName);
+  if (index === -1) {
+    connections.push(connection);
+    return connection;
+  }
+  connections[index] = connection;
+  return connection;
+}
+function removeOpenAiAdsConnection(config, projectName) {
+  const connections = config.openaiAds?.connections;
+  if (!connections?.length) return false;
+  const next = connections.filter((c) => c.projectName !== projectName);
+  if (next.length === connections.length) return false;
+  if (!config.openaiAds) return false;
+  config.openaiAds.connections = next;
+  if (next.length === 0) {
+    delete config.openaiAds;
+  }
+  return true;
+}
+
+// src/ads-sync.ts
+var log4 = createLogger("AdsSync");
+var CAMPAIGN_INSIGHT_FIELDS = ["campaign.impressions", "campaign.clicks", "campaign.spend", "metadata.readable_time"];
+var AD_GROUP_INSIGHT_FIELDS = ["ad_group.impressions", "ad_group.clicks", "ad_group.spend", "metadata.readable_time"];
+function toInsightUpserts(level, entityId, rows) {
+  const upserts = [];
+  for (const row of rows) {
+    if (!row.readable_time) {
+      log4.warn("insights.row-missing-date", { level, entityId, rowId: row.id });
+      continue;
+    }
+    upserts.push({
+      level,
+      entityId,
+      date: row.readable_time,
+      impressions: row.impressions ?? 0,
+      clicks: row.clicks ?? 0,
+      spendMicros: dollarsToMicros(row.spend ?? 0)
+    });
+  }
+  return upserts;
+}
+async function executeAdsSync(db, runId, projectId, opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq4(runs.id, runId)).run();
+  try {
+    const project = db.select().from(projects).where(eq4(projects.id, projectId)).get();
+    if (!project) throw new Error(`Project not found: ${projectId}`);
+    const connRow = db.select().from(adsConnections).where(eq4(adsConnections.projectId, projectId)).get();
+    if (!connRow) {
+      throw new Error('No ads connection found for this project. Run "canonry ads connect" first.');
+    }
+    const cfgConn = getOpenAiAdsConnection(opts.config, project.name);
+    if (!cfgConn?.apiKey) {
+      throw new Error('No OpenAI Ads API key in the local Canonry config. Run "canonry ads connect" first.');
+    }
+    const apiKey = cfgConn.apiKey;
+    log4.info("sync.start", { runId, projectId, adAccountId: connRow.adAccountId });
+    const account = await getAdAccount(apiKey);
+    const campaigns = await listCampaigns(apiKey);
+    const errors = /* @__PURE__ */ new Map();
+    const adGroupsByCampaign = /* @__PURE__ */ new Map();
+    const adsByGroup = /* @__PURE__ */ new Map();
+    const insightUpserts = [];
+    const syncedCampaigns = [];
+    for (const campaign of campaigns) {
+      try {
+        const [adGroups, campaignInsights] = await Promise.all([
+          listAdGroups(apiKey, campaign.id),
+          getCampaignInsights(apiKey, campaign.id, { fields: CAMPAIGN_INSIGHT_FIELDS })
+        ]);
+        const groupResults = await Promise.all(adGroups.map(async (group) => ({
+          group,
+          ads: await listAds(apiKey, group.id),
+          insights: await getAdGroupInsights(apiKey, group.id, { fields: AD_GROUP_INSIGHT_FIELDS })
+        })));
+        syncedCampaigns.push(campaign);
+        adGroupsByCampaign.set(campaign.id, adGroups);
+        insightUpserts.push(...toInsightUpserts("campaign", campaign.id, campaignInsights));
+        for (const { group, ads, insights: insights2 } of groupResults) {
+          adsByGroup.set(group.id, ads);
+          insightUpserts.push(...toInsightUpserts("ad_group", group.id, insights2));
+        }
+      } catch (err) {
+        errors.set(campaign.name, err instanceof Error ? err.message : String(err));
+        log4.error("campaign.failed", { runId, campaignId: campaign.id, error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    const insertNow = (/* @__PURE__ */ new Date()).toISOString();
+    db.transaction((tx) => {
+      tx.delete(adsCampaigns).where(eq4(adsCampaigns.projectId, projectId)).run();
+      for (const campaign of syncedCampaigns) {
+        tx.insert(adsCampaigns).values({
+          id: campaign.id,
+          projectId,
+          name: campaign.name,
+          status: campaign.status,
+          biddingType: campaign.bidding_type,
+          dailySpendLimitMicros: campaign.budget?.daily_spend_limit_micros ?? null,
+          lifetimeSpendLimitMicros: campaign.budget?.lifetime_spend_limit_micros ?? null,
+          targeting: campaign.targeting,
+          upstreamCreatedAt: campaign.created_at,
+          upstreamUpdatedAt: campaign.updated_at,
+          syncRunId: runId,
+          syncedAt: insertNow
+        }).run();
+        for (const group of adGroupsByCampaign.get(campaign.id) ?? []) {
+          tx.insert(adsAdGroups).values({
+            id: group.id,
+            projectId,
+            campaignId: campaign.id,
+            name: group.name,
+            status: group.status,
+            billingEventType: group.bidding_config?.billing_event_type ?? null,
+            maxBidMicros: group.bidding_config?.max_bid_micros ?? null,
+            contextHints: group.context_hints,
+            upstreamCreatedAt: group.created_at,
+            upstreamUpdatedAt: group.updated_at,
+            syncRunId: runId,
+            syncedAt: insertNow
+          }).run();
+          for (const ad of adsByGroup.get(group.id) ?? []) {
+            tx.insert(adsAds).values({
+              id: ad.id,
+              projectId,
+              adGroupId: group.id,
+              name: ad.name,
+              status: ad.status,
+              creative: ad.creative,
+              reviewStatus: ad.review_status ?? ad.review?.status ?? null,
+              upstreamCreatedAt: ad.created_at,
+              upstreamUpdatedAt: ad.updated_at,
+              syncRunId: runId,
+              syncedAt: insertNow
+            }).run();
+          }
+        }
+      }
+      for (const upsert of insightUpserts) {
+        tx.insert(adsInsightsDaily).values({
+          id: crypto6.randomUUID(),
+          projectId,
+          ...upsert,
+          syncRunId: runId
+        }).onConflictDoUpdate({
+          target: [adsInsightsDaily.projectId, adsInsightsDaily.level, adsInsightsDaily.entityId, adsInsightsDaily.date],
+          set: {
+            impressions: upsert.impressions,
+            clicks: upsert.clicks,
+            spendMicros: upsert.spendMicros,
+            syncRunId: runId
+          }
+        }).run();
+      }
+      tx.update(adsConnections).set({
+        adAccountId: account.id,
+        displayName: account.name,
+        currencyCode: account.currency_code,
+        timezone: account.timezone,
+        status: account.status,
+        lastSyncedAt: insertNow,
+        updatedAt: insertNow
+      }).where(eq4(adsConnections.projectId, projectId)).run();
+    });
+    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (errors.size === 0) {
+      db.update(runs).set({ status: "completed", finishedAt }).where(eq4(runs.id, runId)).run();
+    } else if (syncedCampaigns.length > 0) {
+      db.update(runs).set({
+        status: "partial",
+        error: serializeRunError(buildRunErrorFromMessages(errors)),
+        finishedAt
+      }).where(eq4(runs.id, runId)).run();
+    } else {
+      db.update(runs).set({
+        status: "failed",
+        error: serializeRunError(buildRunErrorFromMessages(errors)),
+        finishedAt
+      }).where(eq4(runs.id, runId)).run();
+    }
+    log4.info("sync.done", { runId, projectId, campaigns: syncedCampaigns.length, insightRows: insightUpserts.length, failed: errors.size });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    db.update(runs).set({ status: "failed", error: serializeRunError({ message: errorMsg }), finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq4(runs.id, runId)).run();
+    log4.error("sync.failed", { runId, projectId, error: errorMsg });
+    throw err;
+  }
+}
+
+// src/gsc-inspect-sitemap.ts
+import crypto7 from "crypto";
+import { eq as eq5, and as and4 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
-var log4 = createLogger("SitemapParser");
+var log5 = createLogger("SitemapParser");
 var LOC_REGEX = /<loc>([^<]+)<\/loc>/gi;
 var SITEMAP_TAG_REGEX = /<sitemap>[\s\S]*?<\/sitemap>/gi;
 async function validateSitemapUrl(url) {
@@ -4124,7 +4484,7 @@ async function parseSitemapRecursive(url, urls, visited, depth, isChild) {
     res = await fetch(url);
   } catch (err) {
     if (!isChild) throw err;
-    log4.warn("child-sitemap.fetch-failed", {
+    log5.warn("child-sitemap.fetch-failed", {
       url,
       error: err instanceof Error ? err.message : String(err)
     });
@@ -4134,7 +4494,7 @@ async function parseSitemapRecursive(url, urls, visited, depth, isChild) {
     if (!isChild) {
       throw new Error(`Failed to fetch sitemap at ${url}: ${res.status} ${res.statusText}`);
     }
-    log4.warn("child-sitemap.http-error", { url, status: res.status, statusText: res.statusText });
+    log5.warn("child-sitemap.http-error", { url, status: res.status, statusText: res.statusText });
     return;
   }
   let xml;
@@ -4142,7 +4502,7 @@ async function parseSitemapRecursive(url, urls, visited, depth, isChild) {
     xml = await readSitemapBody(res);
   } catch (err) {
     if (!isChild) throw err;
-    log4.warn("child-sitemap.parse-failed", {
+    log5.warn("child-sitemap.parse-failed", {
       url,
       error: err instanceof Error ? err.message : String(err)
     });
@@ -4178,16 +4538,16 @@ async function parseSitemapRecursive(url, urls, visited, depth, isChild) {
 }
 
 // src/gsc-inspect-sitemap.ts
-var log5 = createLogger("InspectSitemap");
+var log6 = createLogger("InspectSitemap");
 async function executeInspectSitemap(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt: now }).where(eq4(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq5(runs.id, runId)).run();
   try {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getGoogleAuthConfig(opts.config);
     if (!googleClientId || !googleClientSecret) {
       throw new Error("Google OAuth is not configured in the local Canonry config");
     }
-    const project = db.select().from(projects).where(eq4(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq5(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -4212,9 +4572,9 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       saveConfigPatch(opts.config);
     }
     const sitemapUrl = opts.sitemapUrl || conn.sitemapUrl || `https://${project.canonicalDomain}/sitemap.xml`;
-    log5.info("sitemap.fetch", { runId, projectId, sitemapUrl });
+    log6.info("sitemap.fetch", { runId, projectId, sitemapUrl });
     const urls = await fetchAndParseSitemap(sitemapUrl);
-    log5.info("sitemap.parsed", { runId, projectId, urlCount: urls.length, sitemapUrl });
+    log6.info("sitemap.parsed", { runId, projectId, urlCount: urls.length, sitemapUrl });
     if (urls.length === 0) {
       throw new Error("No URLs found in sitemap");
     }
@@ -4229,7 +4589,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
           const rich = ir.richResultsResult;
           const inspectedAt = (/* @__PURE__ */ new Date()).toISOString();
           db.insert(gscUrlInspections).values({
-            id: crypto6.randomUUID(),
+            id: crypto7.randomUUID(),
             projectId,
             syncRunId: runId,
             url: pageUrl,
@@ -4246,16 +4606,16 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
             inspectedAt,
             createdAt: inspectedAt
           }).run();
-          log5.info("inspect.url-done", { runId, projectId, url: pageUrl, progress: `${index + 1}/${urls.length}` });
+          log6.info("inspect.url-done", { runId, projectId, url: pageUrl, progress: `${index + 1}/${urls.length}` });
         },
         onError: (pageUrl, err) => {
-          log5.error("inspect.url-failed", { runId, projectId, url: pageUrl, error: err instanceof Error ? err.message : String(err) });
+          log6.error("inspect.url-failed", { runId, projectId, url: pageUrl, error: err instanceof Error ? err.message : String(err) });
         }
       },
       {
         log: {
-          info: (action, ctx) => log5.info(action, { runId, projectId, ...ctx }),
-          error: (action, ctx) => log5.error(action, { runId, projectId, ...ctx })
+          info: (action, ctx) => log6.info(action, { runId, projectId, ...ctx }),
+          error: (action, ctx) => log6.error(action, { runId, projectId, ...ctx })
         }
       }
     );
@@ -4265,7 +4625,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
         `URL inspection aborted after ${INSPECT_FAILFAST_THRESHOLD} consecutive rate/access failures (likely GSC URL Inspection quota exhaustion or property access loss). Last error: ${detail}`
       );
     }
-    const allInspections = db.select().from(gscUrlInspections).where(eq4(gscUrlInspections.projectId, projectId)).all();
+    const allInspections = db.select().from(gscUrlInspections).where(eq5(gscUrlInspections.projectId, projectId)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
       const existing = latestByUrl.get(row.url);
@@ -4286,9 +4646,9 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    db.delete(gscCoverageSnapshots).where(and4(eq4(gscCoverageSnapshots.projectId, projectId), eq4(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and4(eq5(gscCoverageSnapshots.projectId, projectId), eq5(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
-      id: crypto6.randomUUID(),
+      id: crypto7.randomUUID(),
       projectId,
       syncRunId: runId,
       date: snapshotDate,
@@ -4298,20 +4658,20 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }).run();
     const status = errors > 0 && inspected > 0 ? "partial" : errors === urls.length ? "failed" : "completed";
-    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq4(runs.id, runId)).run();
-    log5.info("inspect.completed", { runId, projectId, inspected, errors, total: urls.length, indexed: snapIndexed, notIndexed: snapNotIndexed });
+    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq5(runs.id, runId)).run();
+    log6.info("inspect.completed", { runId, projectId, inspected, errors, total: urls.length, indexed: snapIndexed, notIndexed: snapNotIndexed });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq4(runs.id, runId)).run();
-    log5.error("inspect.failed", { runId, projectId, error: errorMsg });
+    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq5(runs.id, runId)).run();
+    log6.error("inspect.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/bing-inspect-sitemap.ts
-import crypto7 from "crypto";
-import { eq as eq5, desc as desc2 } from "drizzle-orm";
-var log6 = createLogger("BingInspectSitemap");
+import crypto8 from "crypto";
+import { eq as eq6, desc as desc2 } from "drizzle-orm";
+var log7 = createLogger("BingInspectSitemap");
 function parseBingDate(value) {
   if (!value) return null;
   const match = /\/Date\((-?\d+)(?:[-+]\d+)?\)\//.exec(value);
@@ -4328,9 +4688,9 @@ function isBlockingIssueType(issueType) {
 }
 async function executeBingInspectSitemap(db, runId, projectId, opts) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq5(runs.id, runId)).run();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq6(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq5(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq6(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -4342,16 +4702,16 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
       throw new Error('No Bing site configured. Run "canonry bing set-site <project> <url>" first.');
     }
     const sitemapUrl = opts.sitemapUrl ?? `https://${project.canonicalDomain}/sitemap.xml`;
-    log6.info("sitemap.fetch", { runId, projectId, sitemapUrl });
+    log7.info("sitemap.fetch", { runId, projectId, sitemapUrl });
     const sitemapUrls = await fetchAndParseSitemap(sitemapUrl);
-    log6.info("sitemap.parsed", { runId, projectId, urlCount: sitemapUrls.length, sitemapUrl });
+    log7.info("sitemap.parsed", { runId, projectId, urlCount: sitemapUrls.length, sitemapUrl });
     if (sitemapUrls.length === 0) {
       throw new Error("No URLs found in sitemap");
     }
-    const trackedRows = db.select({ url: bingUrlInspections.url }).from(bingUrlInspections).where(eq5(bingUrlInspections.projectId, projectId)).all();
+    const trackedRows = db.select({ url: bingUrlInspections.url }).from(bingUrlInspections).where(eq6(bingUrlInspections.projectId, projectId)).all();
     const trackedUrls = new Set(trackedRows.map((r) => r.url));
     const discovered = sitemapUrls.filter((u) => !trackedUrls.has(u));
-    log6.info("sitemap.diff", {
+    log7.info("sitemap.diff", {
       runId,
       projectId,
       sitemapTotal: sitemapUrls.length,
@@ -4366,9 +4726,9 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
           blockedUrls.add(issue.Url);
         }
       }
-      log6.info("crawl-issues.loaded", { runId, projectId, blockedCount: blockedUrls.size });
+      log7.info("crawl-issues.loaded", { runId, projectId, blockedCount: blockedUrls.size });
     } catch (err) {
-      log6.warn("crawl-issues.lookup-failed", {
+      log7.warn("crawl-issues.lookup-failed", {
         runId,
         projectId,
         error: err instanceof Error ? err.message : String(err)
@@ -4397,7 +4757,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
           derivedInIndex = false;
         }
         db.insert(bingUrlInspections).values({
-          id: crypto7.randomUUID(),
+          id: crypto8.randomUUID(),
           projectId,
           url: pageUrl,
           httpCode,
@@ -4412,7 +4772,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
           discoveryDate
         }).run();
         inspected++;
-        log6.info("inspect.url-done", {
+        log7.info("inspect.url-done", {
           runId,
           projectId,
           url: pageUrl,
@@ -4420,7 +4780,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
         });
       } catch (err) {
         errors++;
-        log6.error("inspect.url-failed", {
+        log7.error("inspect.url-failed", {
           runId,
           projectId,
           url: pageUrl,
@@ -4431,7 +4791,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
         await new Promise((r) => setTimeout(r, 1e3));
       }
     }
-    const allInspections = db.select().from(bingUrlInspections).where(eq5(bingUrlInspections.projectId, projectId)).orderBy(desc2(bingUrlInspections.inspectedAt)).all();
+    const allInspections = db.select().from(bingUrlInspections).where(eq6(bingUrlInspections.projectId, projectId)).orderBy(desc2(bingUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     const definitiveByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
@@ -4455,7 +4815,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const snapNow = (/* @__PURE__ */ new Date()).toISOString();
     db.insert(bingCoverageSnapshots).values({
-      id: crypto7.randomUUID(),
+      id: crypto8.randomUUID(),
       projectId,
       syncRunId: runId,
       date: snapshotDate,
@@ -4474,8 +4834,8 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
       }
     }).run();
     const status = errors === sitemapUrls.length ? RunStatuses.failed : errors > 0 ? RunStatuses.partial : RunStatuses.completed;
-    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq5(runs.id, runId)).run();
-    log6.info("inspect.completed", {
+    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq6(runs.id, runId)).run();
+    log7.info("inspect.completed", {
       runId,
       projectId,
       inspected,
@@ -4488,16 +4848,16 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
     });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq5(runs.id, runId)).run();
-    log6.error("inspect.failed", { runId, projectId, error: errorMsg });
+    db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq6(runs.id, runId)).run();
+    log7.error("inspect.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/coverage-refresh.ts
-import crypto8 from "crypto";
-import { and as and5, desc as desc3, eq as eq6, inArray as inArray3 } from "drizzle-orm";
-var log7 = createLogger("CoverageRefresh");
+import crypto9 from "crypto";
+import { and as and5, desc as desc3, eq as eq7, inArray as inArray3 } from "drizzle-orm";
+var log8 = createLogger("CoverageRefresh");
 var COVERAGE_REFRESH_MIN_INTERVAL_MS = 60 * 60 * 1e3;
 var ACTIVE_OR_DONE_STATUSES = [
   RunStatuses.queued,
@@ -4507,7 +4867,7 @@ var ACTIVE_OR_DONE_STATUSES = [
 ];
 var defaultDeps = { executeInspectSitemap };
 async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps, nowMs = Date.now()) {
-  const project = db.select({ canonicalDomain: projects.canonicalDomain }).from(projects).where(eq6(projects.id, projectId)).get();
+  const project = db.select({ canonicalDomain: projects.canonicalDomain }).from(projects).where(eq7(projects.id, projectId)).get();
   if (!project) return null;
   const { clientId, clientSecret } = getGoogleAuthConfig(config);
   if (!clientId || !clientSecret) return null;
@@ -4515,19 +4875,19 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
   if (!conn?.refreshToken || !conn.propertyId) return null;
   const recent = db.select({ createdAt: runs.createdAt }).from(runs).where(
     and5(
-      eq6(runs.projectId, projectId),
-      eq6(runs.kind, RunKinds["inspect-sitemap"]),
+      eq7(runs.projectId, projectId),
+      eq7(runs.kind, RunKinds["inspect-sitemap"]),
       inArray3(runs.status, ACTIVE_OR_DONE_STATUSES)
     )
   ).orderBy(desc3(runs.createdAt)).limit(1).get();
   if (recent) {
     const ageMs = nowMs - Date.parse(recent.createdAt);
     if (Number.isFinite(ageMs) && ageMs < COVERAGE_REFRESH_MIN_INTERVAL_MS) {
-      log7.info("skip.recent", { projectId, ageMs });
+      log8.info("skip.recent", { projectId, ageMs });
       return null;
     }
   }
-  const runId = crypto8.randomUUID();
+  const runId = crypto9.randomUUID();
   db.insert(runs).values({
     id: runId,
     projectId,
@@ -4536,11 +4896,11 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
     trigger: RunTriggers.scheduled,
     createdAt: new Date(nowMs).toISOString()
   }).run();
-  log7.info("refresh.start", { projectId, runId });
+  log8.info("refresh.start", { projectId, runId });
   try {
     await deps.executeInspectSitemap(db, runId, projectId, { config });
   } catch (err) {
-    log7.error("refresh.failed", {
+    log8.error("refresh.failed", {
       projectId,
       runId,
       error: err instanceof Error ? err.message : String(err)
@@ -4550,10 +4910,10 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
 }
 
 // src/commoncrawl-sync.ts
-import crypto9 from "crypto";
+import crypto10 from "crypto";
 import path4 from "path";
-import { and as and6, eq as eq7, sql as sql3 } from "drizzle-orm";
-var log8 = createLogger("CommonCrawlSync");
+import { and as and6, eq as eq8, sql as sql3 } from "drizzle-orm";
+var log9 = createLogger("CommonCrawlSync");
 var INSERT_CHUNK_SIZE = 1e4;
 function defaultDeps2() {
   return {
@@ -4578,7 +4938,7 @@ async function executeReleaseSync(db, syncId, opts) {
       phaseDetail: "downloading vertices + edges",
       updatedAt: downloadStartedAt,
       error: null
-    }).where(eq7(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq8(ccReleaseSyncs.id, syncId)).run();
     const paths = ccReleasePaths(release);
     const releaseCacheDir = path4.join(deps.cacheDir, release);
     const vertexPath = path4.join(releaseCacheDir, paths.vertexFilename);
@@ -4601,7 +4961,7 @@ async function executeReleaseSync(db, syncId, opts) {
       vertexSha256: vertex.sha256,
       edgesSha256: edges.sha256,
       updatedAt: downloadFinishedAt
-    }).where(eq7(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq8(ccReleaseSyncs.id, syncId)).run();
     const allProjects = db.select().from(projects).all();
     const targets = Array.from(new Set(allProjects.map((p) => p.canonicalDomain)));
     let rows = [];
@@ -4617,15 +4977,15 @@ async function executeReleaseSync(db, syncId, opts) {
     }
     const queriedAt = deps.now().toISOString();
     db.transaction((tx) => {
-      tx.delete(backlinkDomains).where(eq7(backlinkDomains.releaseSyncId, syncId)).run();
-      tx.delete(backlinkSummaries).where(eq7(backlinkSummaries.releaseSyncId, syncId)).run();
+      tx.delete(backlinkDomains).where(eq8(backlinkDomains.releaseSyncId, syncId)).run();
+      tx.delete(backlinkSummaries).where(eq8(backlinkSummaries.releaseSyncId, syncId)).run();
       const expanded = [];
       for (const r of rows) {
         const projectIds = projectsByDomain.get(r.targetDomain);
         if (!projectIds) continue;
         for (const projectId of projectIds) {
           expanded.push({
-            id: crypto9.randomUUID(),
+            id: crypto10.randomUUID(),
             projectId,
             releaseSyncId: syncId,
             release,
@@ -4645,9 +5005,10 @@ async function executeReleaseSync(db, syncId, opts) {
         const projectRows = rowsByProject.get(p.id) ?? [];
         const summary = computeSummary(projectRows);
         tx.insert(backlinkSummaries).values({
-          id: crypto9.randomUUID(),
+          id: crypto10.randomUUID(),
           projectId: p.id,
           releaseSyncId: syncId,
+          source: BacklinkSources.commoncrawl,
           release,
           targetDomain: p.canonicalDomain,
           totalLinkingDomains: summary.totalLinkingDomains,
@@ -4656,7 +5017,7 @@ async function executeReleaseSync(db, syncId, opts) {
           queriedAt,
           createdAt: queriedAt
         }).onConflictDoUpdate({
-          target: [backlinkSummaries.projectId, backlinkSummaries.release],
+          target: [backlinkSummaries.projectId, backlinkSummaries.source, backlinkSummaries.release],
           set: {
             releaseSyncId: syncId,
             targetDomain: p.canonicalDomain,
@@ -4677,8 +5038,8 @@ async function executeReleaseSync(db, syncId, opts) {
       domainsDiscovered: rows.length,
       updatedAt: finishedAt,
       error: null
-    }).where(eq7(ccReleaseSyncs.id, syncId)).run();
-    log8.info("sync.completed", {
+    }).where(eq8(ccReleaseSyncs.id, syncId)).run();
+    log9.info("sync.completed", {
       syncId,
       release,
       projectsProcessed: allProjects.length,
@@ -4690,7 +5051,7 @@ async function executeReleaseSync(db, syncId, opts) {
         try {
           deps.enqueueAutoExtract({ projectId: p.id, release });
         } catch (err) {
-          log8.error("auto-extract.enqueue-failed", {
+          log9.error("auto-extract.enqueue-failed", {
             syncId,
             release,
             projectId: p.id,
@@ -4707,8 +5068,8 @@ async function executeReleaseSync(db, syncId, opts) {
       error: errorMsg,
       phaseDetail: null,
       updatedAt: finishedAt
-    }).where(eq7(ccReleaseSyncs.id, syncId)).run();
-    log8.error("sync.failed", { syncId, release, error: errorMsg });
+    }).where(eq8(ccReleaseSyncs.id, syncId)).run();
+    log9.error("sync.failed", { syncId, release, error: errorMsg });
     throw err;
   }
 }
@@ -4741,10 +5102,10 @@ function computeSummary(rows) {
 }
 
 // src/backlink-extract.ts
-import crypto10 from "crypto";
+import crypto11 from "crypto";
 import fs3 from "fs";
-import { and as and7, desc as desc4, eq as eq8 } from "drizzle-orm";
-var log9 = createLogger("BacklinkExtract");
+import { and as and7, desc as desc4, eq as eq9 } from "drizzle-orm";
+var log10 = createLogger("BacklinkExtract");
 function defaultDeps3() {
   return {
     queryBacklinks,
@@ -4755,13 +5116,13 @@ function defaultDeps3() {
 async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
   const deps = { ...defaultDeps3(), ...opts.deps };
   const startedAt = deps.now().toISOString();
-  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq8(runs.id, runId)).run();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq9(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq8(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq9(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
-    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq8(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq8(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc4(ccReleaseSyncs.createdAt)).limit(1).get();
+    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq9(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq9(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc4(ccReleaseSyncs.createdAt)).limit(1).get();
     if (!sync) {
       throw new Error("No ready release sync available \u2014 run `canonry backlinks sync` first");
     }
@@ -4789,13 +5150,18 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
     const targetDomain = project.canonicalDomain;
     db.transaction((tx) => {
       tx.delete(backlinkDomains).where(
-        and7(eq8(backlinkDomains.projectId, projectId), eq8(backlinkDomains.release, release))
+        and7(
+          eq9(backlinkDomains.projectId, projectId),
+          eq9(backlinkDomains.source, BacklinkSources.commoncrawl),
+          eq9(backlinkDomains.release, release)
+        )
       ).run();
       if (rows.length > 0) {
         const values = rows.map((r) => ({
-          id: crypto10.randomUUID(),
+          id: crypto11.randomUUID(),
           projectId,
           releaseSyncId: syncId,
+          source: BacklinkSources.commoncrawl,
           release,
           targetDomain,
           linkingDomain: r.linkingDomain,
@@ -4806,9 +5172,10 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       }
       const summary = computeSummary2(rows);
       tx.insert(backlinkSummaries).values({
-        id: crypto10.randomUUID(),
+        id: crypto11.randomUUID(),
         projectId,
         releaseSyncId: syncId,
+        source: BacklinkSources.commoncrawl,
         release,
         targetDomain,
         totalLinkingDomains: summary.totalLinkingDomains,
@@ -4817,7 +5184,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
         queriedAt,
         createdAt: queriedAt
       }).onConflictDoUpdate({
-        target: [backlinkSummaries.projectId, backlinkSummaries.release],
+        target: [backlinkSummaries.projectId, backlinkSummaries.source, backlinkSummaries.release],
         set: {
           releaseSyncId: syncId,
           targetDomain,
@@ -4829,8 +5196,8 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       }).run();
     });
     const finishedAt = deps.now().toISOString();
-    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq8(runs.id, runId)).run();
-    log9.info("extract.completed", { runId, projectId, release, rows: rows.length });
+    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq9(runs.id, runId)).run();
+    log10.info("extract.completed", { runId, projectId, release, rows: rows.length });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
     const finishedAt = deps.now().toISOString();
@@ -4838,39 +5205,173 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       status: RunStatuses.failed,
       error: errorMsg,
       finishedAt
-    }).where(eq8(runs.id, runId)).run();
-    log9.error("extract.failed", { runId, projectId, error: errorMsg });
+    }).where(eq9(runs.id, runId)).run();
+    log10.error("extract.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 function computeSummary2(rows) {
-  if (rows.length === 0) {
-    return { totalLinkingDomains: 0, totalHosts: 0, top10HostsShare: "0" };
+  return computeBacklinkSummaryMetrics(rows);
+}
+
+// src/bing-backlinks-sync.ts
+import crypto12 from "crypto";
+import { and as and8, eq as eq10 } from "drizzle-orm";
+var log11 = createLogger("BingBacklinkSync");
+var DEFAULT_MAX_PAGES = 200;
+var LINK_COUNTS_MAX_PAGES = 50;
+var URL_LINKS_MAX_PAGES = 20;
+function bingReleaseId(date) {
+  return `bing-${date.toISOString().slice(0, 10)}`;
+}
+function aggregateInboundLinksByDomain(links, targetDomain) {
+  const target = hostOf(targetDomain);
+  const byHost = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const host = hostOf(link.Url);
+    if (!host) continue;
+    if (target && (host === target || host.endsWith(`.${target}`))) continue;
+    let urls = byHost.get(host);
+    if (!urls) {
+      urls = /* @__PURE__ */ new Set();
+      byHost.set(host, urls);
+    }
+    urls.add(link.Url);
+  }
+  return [...byHost.entries()].map(([linkingDomain, urls]) => ({ linkingDomain, numHosts: urls.size })).sort((a, b) => b.numHosts - a.numHosts || a.linkingDomain.localeCompare(b.linkingDomain));
+}
+function computeBingSummary(rows) {
+  return computeBacklinkSummaryMetrics(rows);
+}
+function defaultDeps4() {
+  return { getLinkCounts, getUrlLinks, now: () => /* @__PURE__ */ new Date() };
+}
+async function executeBingBacklinkSync(db, runId, projectId, opts) {
+  const deps = { ...defaultDeps4(), ...opts.deps };
+  const startedAt = deps.now().toISOString();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq10(runs.id, runId)).run();
+  try {
+    const project = db.select().from(projects).where(eq10(projects.id, projectId)).get();
+    if (!project) throw new Error(`Project not found: ${projectId}`);
+    const conn = opts.resolveConnection(project.canonicalDomain);
+    if (!conn) throw new Error(`No Bing Webmaster connection for ${project.canonicalDomain}`);
+    const siteUrl = conn.siteUrl;
+    if (!siteUrl) {
+      throw new Error(`Bing connection for ${project.canonicalDomain} has no verified site selected`);
+    }
+    const pages = await deps.getLinkCounts(conn.apiKey, siteUrl, { maxPages: LINK_COUNTS_MAX_PAGES });
+    const maxPages = Math.max(1, opts.maxPages ?? DEFAULT_MAX_PAGES);
+    const targetPages = [...pages].sort((a, b) => b.Count - a.Count).slice(0, maxPages);
+    if (pages.length > targetPages.length) {
+      log11.info("bing-sync.pages-capped", {
+        runId,
+        projectId,
+        sitePagesFound: pages.length,
+        sitePagesPulled: targetPages.length
+      });
+    }
+    const allLinks = [];
+    let pageFailures = 0;
+    for (const page of targetPages) {
+      try {
+        const links = await deps.getUrlLinks(conn.apiKey, siteUrl, page.Url, { maxPages: URL_LINKS_MAX_PAGES });
+        allLinks.push(...links);
+      } catch (err) {
+        pageFailures++;
+        log11.warn("bing-sync.page-failed", {
+          runId,
+          projectId,
+          page: page.Url,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    if (targetPages.length > 0 && pageFailures === targetPages.length) {
+      throw new Error(`All ${targetPages.length} Bing inbound-link page fetch(es) failed`);
+    }
+    const rows = aggregateInboundLinksByDomain(allLinks, project.canonicalDomain);
+    const summary = computeBingSummary(rows);
+    const queriedAt = deps.now().toISOString();
+    const release = bingReleaseId(deps.now());
+    const targetDomain = project.canonicalDomain;
+    const source = BacklinkSources["bing-webmaster"];
+    const existing = db.select({ id: backlinkSummaries.id }).from(backlinkSummaries).where(and8(
+      eq10(backlinkSummaries.projectId, projectId),
+      eq10(backlinkSummaries.source, source),
+      eq10(backlinkSummaries.release, release)
+    )).get();
+    const preserveExisting = pageFailures > 0 && !!existing;
+    if (!preserveExisting) {
+      db.transaction((tx) => {
+        tx.delete(backlinkDomains).where(and8(
+          eq10(backlinkDomains.projectId, projectId),
+          eq10(backlinkDomains.source, source),
+          eq10(backlinkDomains.release, release)
+        )).run();
+        if (rows.length > 0) {
+          tx.insert(backlinkDomains).values(rows.map((r) => ({
+            id: crypto12.randomUUID(),
+            projectId,
+            releaseSyncId: null,
+            source,
+            release,
+            targetDomain,
+            linkingDomain: r.linkingDomain,
+            numHosts: r.numHosts,
+            createdAt: queriedAt
+          }))).run();
+        }
+        tx.insert(backlinkSummaries).values({
+          id: crypto12.randomUUID(),
+          projectId,
+          releaseSyncId: null,
+          source,
+          release,
+          targetDomain,
+          totalLinkingDomains: summary.totalLinkingDomains,
+          totalHosts: summary.totalHosts,
+          top10HostsShare: summary.top10HostsShare,
+          queriedAt,
+          createdAt: queriedAt
+        }).onConflictDoUpdate({
+          target: [backlinkSummaries.projectId, backlinkSummaries.source, backlinkSummaries.release],
+          set: {
+            targetDomain,
+            totalLinkingDomains: summary.totalLinkingDomains,
+            totalHosts: summary.totalHosts,
+            top10HostsShare: summary.top10HostsShare,
+            queriedAt
+          }
+        }).run();
+      });
+    }
+    const finishedAt = deps.now().toISOString();
+    const status = pageFailures > 0 ? RunStatuses.partial : RunStatuses.completed;
+    const error = preserveExisting ? `Kept existing ${release} snapshot; ${pageFailures} of ${targetPages.length} inbound-link page fetches failed` : pageFailures > 0 ? `${pageFailures} of ${targetPages.length} inbound-link page fetches failed` : null;
+    db.update(runs).set({ status, error, finishedAt }).where(eq10(runs.id, runId)).run();
+    log11.info("bing-sync.completed", { runId, projectId, release, rows: rows.length, status, pageFailures, preserveExisting });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    const finishedAt = deps.now().toISOString();
+    db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt }).where(eq10(runs.id, runId)).run();
+    log11.error("bing-sync.failed", { runId, projectId, error: errorMsg });
+    throw err;
   }
-  const sorted = [...rows].sort((a, b) => b.numHosts - a.numHosts);
-  const totalHosts = sorted.reduce((acc, r) => acc + r.numHosts, 0);
-  const top10Hosts = sorted.slice(0, 10).reduce((acc, r) => acc + r.numHosts, 0);
-  const share = totalHosts > 0 ? top10Hosts / totalHosts : 0;
-  return {
-    totalLinkingDomains: rows.length,
-    totalHosts,
-    top10HostsShare: share.toFixed(6)
-  };
 }
 
 // src/discovery-run.ts
-import crypto11 from "crypto";
-import { and as and8, eq as eq9 } from "drizzle-orm";
-var log10 = createLogger("DiscoveryRun");
+import crypto13 from "crypto";
+import { and as and9, eq as eq11 } from "drizzle-orm";
+var log12 = createLogger("DiscoveryRun");
 var DEFAULT_SEED_COUNT = 30;
 var QUERIES_PER_INTENT_BUCKET = 6;
 async function executeDiscoveryRun(opts) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  opts.db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq9(runs.id, opts.runId)).run();
+  opts.db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq11(runs.id, opts.runId)).run();
   try {
-    const projectRow = opts.db.select().from(projects).where(eq9(projects.id, opts.projectId)).get();
+    const projectRow = opts.db.select().from(projects).where(eq11(projects.id, opts.projectId)).get();
     if (!projectRow) throw new Error(`Project ${opts.projectId} not found`);
-    const projectCompetitors = opts.db.select({ domain: competitors.domain }).from(competitors).where(eq9(competitors.projectId, opts.projectId)).all().map((r) => r.domain.toLowerCase());
+    const projectCompetitors = opts.db.select({ domain: competitors.domain }).from(competitors).where(eq11(competitors.projectId, opts.projectId)).all().map((r) => r.domain.toLowerCase());
     const canonicalDomains = effectiveDomains({
       canonicalDomain: projectRow.canonicalDomain,
       ownedDomains: projectRow.ownedDomains
@@ -4900,8 +5401,8 @@ async function executeDiscoveryRun(opts) {
       seedProvider: result.seedProvider,
       result
     });
-    opts.db.update(runs).set({ status: RunStatuses.completed, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq9(runs.id, opts.runId)).run();
-    log10.info("discovery.completed", {
+    opts.db.update(runs).set({ status: RunStatuses.completed, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq11(runs.id, opts.runId)).run();
+    log12.info("discovery.completed", {
       runId: opts.runId,
       sessionId: opts.sessionId,
       buckets: result.buckets,
@@ -4909,13 +5410,13 @@ async function executeDiscoveryRun(opts) {
     });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    log10.error("discovery.failed", { runId: opts.runId, sessionId: opts.sessionId, error: errorMsg });
+    log12.error("discovery.failed", { runId: opts.runId, sessionId: opts.sessionId, error: errorMsg });
     markSessionFailed(opts.db, opts.sessionId, errorMsg);
     opts.db.update(runs).set({
       status: RunStatuses.failed,
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
       error: errorMsg
-    }).where(eq9(runs.id, opts.runId)).run();
+    }).where(eq11(runs.id, opts.runId)).run();
   }
 }
 function buildDefaultDeps(registry) {
@@ -5120,13 +5621,13 @@ function writeDiscoveryInsight(db, input) {
     totalProbes
   });
   db.transaction((tx) => {
-    tx.update(insights).set({ dismissed: true }).where(and8(
-      eq9(insights.projectId, input.projectId),
-      eq9(insights.type, "discovery.basket-divergence"),
-      eq9(insights.dismissed, false)
+    tx.update(insights).set({ dismissed: true }).where(and9(
+      eq11(insights.projectId, input.projectId),
+      eq11(insights.type, "discovery.basket-divergence"),
+      eq11(insights.dismissed, false)
     )).run();
     tx.insert(insights).values({
-      id: crypto11.randomUUID(),
+      id: crypto13.randomUUID(),
       projectId: input.projectId,
       runId: input.runId,
       type: "discovery.basket-divergence",
@@ -5162,10 +5663,10 @@ function buildDiscoveryInsightTitle(input) {
 }
 
 // src/execute-site-audit.ts
-import crypto12 from "crypto";
-import { eq as eq10 } from "drizzle-orm";
+import crypto14 from "crypto";
+import { eq as eq12 } from "drizzle-orm";
 import { runSitemapAudit } from "@ainyc/aeo-audit";
-var log11 = createLogger("SiteAudit");
+var log13 = createLogger("SiteAudit");
 var SITE_AUDIT_DEFAULT_PAGE_LIMIT = 500;
 var SITE_AUDIT_MAX_PAGE_LIMIT = 2e3;
 function toHomepageUrl(canonicalDomain) {
@@ -5226,15 +5727,15 @@ function computeFactorAverages(pages) {
 }
 async function executeSiteAudit(db, runId, projectId, opts = {}) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt }).where(eq10(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt }).where(eq12(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq10(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq12(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
     const homepageUrl = toHomepageUrl(project.canonicalDomain);
     const limit = clampSiteAuditLimit(opts.limit);
-    log11.info("start", { runId, projectId, homepageUrl, sitemapUrl: opts.sitemapUrl ?? null, limit });
+    log13.info("start", { runId, projectId, homepageUrl, sitemapUrl: opts.sitemapUrl ?? null, limit });
     await assertSiteAuditUrlAllowed(homepageUrl, "canonicalDomain");
     if (opts.sitemapUrl) await assertSiteAuditUrlAllowed(opts.sitemapUrl, "sitemapUrl");
     const report = await runSitemapAudit(homepageUrl, { sitemapUrl: opts.sitemapUrl, limit });
@@ -5242,7 +5743,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     const pagesErrored = report.pages.filter((page) => page.status === "error").length;
     const auditable = report.pagesDiscovered - report.pagesSkipped;
     if (auditable > report.pagesAudited) {
-      log11.info("truncated", {
+      log13.info("truncated", {
         runId,
         projectId,
         auditable,
@@ -5261,7 +5762,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
     db.transaction((tx) => {
       tx.insert(siteAuditSnapshots).values({
-        id: crypto12.randomUUID(),
+        id: crypto14.randomUUID(),
         projectId,
         runId,
         sitemapUrl: report.sitemapUrl,
@@ -5290,7 +5791,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       }).run();
       for (const page of report.pages) {
         tx.insert(siteAuditPages).values({
-          id: crypto12.randomUUID(),
+          id: crypto14.randomUUID(),
           projectId,
           runId,
           url: page.url,
@@ -5301,9 +5802,9 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
           createdAt: finishedAt
         }).run();
       }
-      tx.update(runs).set({ status, finishedAt }).where(eq10(runs.id, runId)).run();
+      tx.update(runs).set({ status, finishedAt }).where(eq12(runs.id, runId)).run();
     });
-    log11.info("completed", {
+    log13.info("completed", {
       runId,
       projectId,
       status,
@@ -5313,14 +5814,14 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq10(runs.id, runId)).run();
-    log11.error("failed", { runId, projectId, error: errorMsg });
+    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq12(runs.id, runId)).run();
+    log13.error("failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/commands/backfill.ts
-import { and as and9, eq as eq11, inArray as inArray4, isNull, sql as sql4 } from "drizzle-orm";
+import { and as and10, eq as eq13, inArray as inArray4, isNull, sql as sql4 } from "drizzle-orm";
 var SNAPSHOT_BATCH_SIZE = 500;
 async function backfillAnswerVisibilityCommand(opts) {
   const config = loadConfig();
@@ -5328,7 +5829,7 @@ async function backfillAnswerVisibilityCommand(opts) {
   migrate(db);
   const projectFilter = opts?.project?.trim();
   const isDryRun = opts?.dryRun === true;
-  const scopedProjects = projectFilter ? db.select().from(projects).where(eq11(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq13(projects.name, projectFilter)).all() : db.select().from(projects).all();
   let examined = 0;
   let updated = 0;
   let wouldUpdate = 0;
@@ -5336,10 +5837,10 @@ async function backfillAnswerVisibilityCommand(opts) {
   let reparsed = 0;
   let providerErrors = 0;
   if (scopedProjects.length > 0) {
-    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and9(
-      eq11(runs.kind, RunKinds["answer-visibility"]),
+    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and10(
+      eq13(runs.kind, RunKinds["answer-visibility"]),
       inArray4(runs.projectId, scopedProjects.map((project) => project.id))
-    )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq11(runs.kind, RunKinds["answer-visibility"])).all();
+    )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq13(runs.kind, RunKinds["answer-visibility"])).all();
     const runIdsByProject = /* @__PURE__ */ new Map();
     for (const run of runRows) {
       const existing = runIdsByProject.get(run.projectId);
@@ -5347,7 +5848,7 @@ async function backfillAnswerVisibilityCommand(opts) {
       else runIdsByProject.set(run.projectId, [run.id]);
     }
     for (const project of scopedProjects) {
-      const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq11(competitors.projectId, project.id)).all().map((row) => row.domain);
+      const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq13(competitors.projectId, project.id)).all().map((row) => row.domain);
       const runIds = runIdsByProject.get(project.id) ?? [];
       if (runIds.length === 0) continue;
       const projectDomains = effectiveDomains({
@@ -5435,7 +5936,7 @@ async function backfillAnswerVisibilityCommand(opts) {
           } else {
             db.transaction((tx) => {
               for (const update of pendingUpdates) {
-                tx.update(querySnapshots).set(update.patch).where(eq11(querySnapshots.id, update.id)).run();
+                tx.update(querySnapshots).set(update.patch).where(eq13(querySnapshots.id, update.id)).run();
               }
             });
             updated += pendingUpdates.length;
@@ -5484,13 +5985,13 @@ No DB writes performed. Re-run without --dry-run to apply.`);
 function backfillNormalizedPaths(db, opts) {
   const baseConditions = [];
   if (opts?.projectId) {
-    baseConditions.push(eq11(gaTrafficSnapshots.projectId, opts.projectId));
+    baseConditions.push(eq13(gaTrafficSnapshots.projectId, opts.projectId));
   }
   const rows = db.select({
     id: gaTrafficSnapshots.id,
     landingPage: gaTrafficSnapshots.landingPage,
     landingPageNormalized: gaTrafficSnapshots.landingPageNormalized
-  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and9(...baseConditions) : void 0).all();
+  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and10(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -5505,7 +6006,7 @@ function backfillNormalizedPaths(db, opts) {
           unchanged++;
           continue;
         }
-        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq11(gaTrafficSnapshots.id, row.id)).run();
+        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq13(gaTrafficSnapshots.id, row.id)).run();
         updated++;
       }
     });
@@ -5519,7 +6020,7 @@ async function backfillNormalizedPathsCommand(opts) {
   const projectFilter = opts?.project?.trim();
   let projectId;
   if (projectFilter) {
-    const project = db.select({ id: projects.id }).from(projects).where(eq11(projects.name, projectFilter)).get();
+    const project = db.select({ id: projects.id }).from(projects).where(eq13(projects.name, projectFilter)).get();
     if (!project) {
       const result2 = {
         project: projectFilter,
@@ -5556,13 +6057,13 @@ async function backfillNormalizedPathsCommand(opts) {
 function backfillAiReferralPaths(db, opts) {
   const baseConditions = [];
   if (opts?.projectId) {
-    baseConditions.push(eq11(gaAiReferrals.projectId, opts.projectId));
+    baseConditions.push(eq13(gaAiReferrals.projectId, opts.projectId));
   }
   const rows = db.select({
     id: gaAiReferrals.id,
     landingPage: gaAiReferrals.landingPage,
     landingPageNormalized: gaAiReferrals.landingPageNormalized
-  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and9(...baseConditions) : void 0).all();
+  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and10(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -5577,7 +6078,7 @@ function backfillAiReferralPaths(db, opts) {
           unchanged++;
           continue;
         }
-        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq11(gaAiReferrals.id, row.id)).run();
+        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq13(gaAiReferrals.id, row.id)).run();
         updated++;
       }
     });
@@ -5591,7 +6092,7 @@ async function backfillAiReferralPathsCommand(opts) {
   const projectFilter = opts?.project?.trim();
   let projectId;
   if (projectFilter) {
-    const project = db.select({ id: projects.id }).from(projects).where(eq11(projects.name, projectFilter)).get();
+    const project = db.select({ id: projects.id }).from(projects).where(eq13(projects.name, projectFilter)).get();
     if (!project) {
       const result2 = {
         project: projectFilter,
@@ -5627,10 +6128,10 @@ async function backfillAiReferralPathsCommand(opts) {
 }
 function backfillProjectAnswerMentions(db, projectId, opts) {
   const isDryRun = opts?.dryRun === true;
-  const project = db.select().from(projects).where(eq11(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq13(projects.id, projectId)).get();
   if (!project) return { examined: 0, updated: 0, mentioned: 0 };
-  const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq11(competitors.projectId, projectId)).all().map((row) => row.domain);
-  const runRows = db.select({ id: runs.id }).from(runs).where(and9(eq11(runs.kind, RunKinds["answer-visibility"]), eq11(runs.projectId, projectId))).all();
+  const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq13(competitors.projectId, projectId)).all().map((row) => row.domain);
+  const runRows = db.select({ id: runs.id }).from(runs).where(and10(eq13(runs.kind, RunKinds["answer-visibility"]), eq13(runs.projectId, projectId))).all();
   const runIds = runRows.map((r) => r.id);
   let examined = 0;
   let updated = 0;
@@ -5702,7 +6203,7 @@ function backfillProjectAnswerMentions(db, projectId, opts) {
       } else {
         db.transaction((tx) => {
           for (const update of pendingUpdates) {
-            tx.update(querySnapshots).set(update.patch).where(eq11(querySnapshots.id, update.id)).run();
+            tx.update(querySnapshots).set(update.patch).where(eq13(querySnapshots.id, update.id)).run();
           }
         });
         updated += pendingUpdates.length;
@@ -5717,7 +6218,7 @@ async function backfillAnswerMentionsCommand(opts) {
   migrate(db);
   const projectFilter = opts?.project?.trim();
   const isDryRun = opts?.dryRun === true;
-  const scopedProjects = projectFilter ? db.select().from(projects).where(eq11(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq13(projects.name, projectFilter)).all() : db.select().from(projects).all();
   let examined = 0;
   let updated = 0;
   let wouldUpdate = 0;
@@ -5777,7 +6278,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-CDVUUG7O.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-CAAQAKPN.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -5936,7 +6437,7 @@ async function backfillSnapshotAttributionCommand(opts) {
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
-  const project = db.select().from(projects).where(eq11(projects.name, opts.project)).get();
+  const project = db.select().from(projects).where(eq13(projects.name, opts.project)).get();
   if (!project) {
     throw new Error(`Project "${opts.project}" not found`);
   }
@@ -5947,8 +6448,8 @@ async function backfillSnapshotAttributionCommand(opts) {
     process.stderr.write(`Recovering orphan snapshot attribution for "${project.name}"${mode}...
 `);
   }
-  const events = db.select({ createdAt: auditLog.createdAt, action: auditLog.action, diff: auditLog.diff }).from(auditLog).where(and9(
-    eq11(auditLog.projectId, project.id),
+  const events = db.select({ createdAt: auditLog.createdAt, action: auditLog.action, diff: auditLog.diff }).from(auditLog).where(and10(
+    eq13(auditLog.projectId, project.id),
     inArray4(auditLog.action, ["keywords.appended", "keywords.deleted", "queries.appended", "queries.deleted", "queries.replaced"])
   )).orderBy(auditLog.createdAt).all();
   const history = replayQueryAuditLog(events);
@@ -5956,8 +6457,8 @@ async function backfillSnapshotAttributionCommand(opts) {
     runId: runs.id,
     createdAt: runs.createdAt,
     location: runs.location
-  }).from(runs).innerJoin(querySnapshots, eq11(querySnapshots.runId, runs.id)).where(and9(
-    eq11(runs.projectId, project.id),
+  }).from(runs).innerJoin(querySnapshots, eq13(querySnapshots.runId, runs.id)).where(and10(
+    eq13(runs.projectId, project.id),
     isNull(querySnapshots.queryId),
     isNull(querySnapshots.queryText)
   )).groupBy(runs.id).orderBy(runs.createdAt).all();
@@ -5979,8 +6480,8 @@ async function backfillSnapshotAttributionCommand(opts) {
       provider: querySnapshots.provider,
       createdAt: querySnapshots.createdAt,
       answerText: querySnapshots.answerText
-    }).from(querySnapshots).where(and9(
-      eq11(querySnapshots.runId, run.runId),
+    }).from(querySnapshots).where(and10(
+      eq13(querySnapshots.runId, run.runId),
       isNull(querySnapshots.queryId),
       isNull(querySnapshots.queryText)
     )).orderBy(querySnapshots.provider, querySnapshots.createdAt).all();
@@ -6046,7 +6547,7 @@ async function backfillSnapshotAttributionCommand(opts) {
   if (!isDryRun && updates.length > 0) {
     db.transaction((tx) => {
       for (const u of updates) {
-        tx.update(querySnapshots).set({ queryText: u.queryText }).where(eq11(querySnapshots.id, u.id)).run();
+        tx.update(querySnapshots).set({ queryText: u.queryText }).where(eq13(querySnapshots.id, u.id)).run();
       }
     });
   }
@@ -6120,7 +6621,7 @@ async function backfillTrafficClassificationCommand(opts) {
   const projectFilter = opts?.project?.trim();
   const isDryRun = opts?.dryRun === true;
   const isJson = isMachineFormat(opts?.format);
-  const scopedProjects = projectFilter ? db.select().from(projects).where(eq11(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq13(projects.name, projectFilter)).all() : db.select().from(projects).all();
   if (scopedProjects.length === 0) {
     if (projectFilter && !isJson) {
       process.stderr.write(`No project named "${projectFilter}".
@@ -6145,8 +6646,8 @@ async function backfillTrafficClassificationCommand(opts) {
     dryRun: isDryRun,
     byBot: {}
   };
-  const unknownCountRow = db.select({ n: sql4`count(*)` }).from(rawEventSamples).where(and9(
-    eq11(rawEventSamples.eventType, "unknown"),
+  const unknownCountRow = db.select({ n: sql4`count(*)` }).from(rawEventSamples).where(and10(
+    eq13(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).get();
   result.unknownBefore = Number(unknownCountRow?.n ?? 0);
@@ -6158,8 +6659,8 @@ async function backfillTrafficClassificationCommand(opts) {
     userAgent: rawEventSamples.userAgent,
     pathNormalized: rawEventSamples.pathNormalized,
     status: rawEventSamples.status
-  }).from(rawEventSamples).where(and9(
-    eq11(rawEventSamples.eventType, "unknown"),
+  }).from(rawEventSamples).where(and10(
+    eq13(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).all();
   result.examined = unknownSamples.length;
@@ -6198,7 +6699,7 @@ async function backfillTrafficClassificationCommand(opts) {
     result.reclassified++;
     result.byBot[classified.botId] = (result.byBot[classified.botId] ?? 0) + 1;
     if (isDryRun) continue;
-    db.update(rawEventSamples).set({ eventType: userFetch ? TrafficEventKinds["ai-user-fetch"] : TrafficEventKinds.crawler }).where(eq11(rawEventSamples.id, snap.id)).run();
+    db.update(rawEventSamples).set({ eventType: userFetch ? TrafficEventKinds["ai-user-fetch"] : TrafficEventKinds.crawler }).where(eq13(rawEventSamples.id, snap.id)).run();
     const tsHour = new Date(snap.ts);
     tsHour.setUTCMinutes(0, 0, 0);
     if (userFetch) {
@@ -6262,8 +6763,8 @@ async function backfillTrafficClassificationCommand(opts) {
     }
   }
   if (!isDryRun) {
-    const afterRow = db.select({ n: sql4`count(*)` }).from(rawEventSamples).where(and9(
-      eq11(rawEventSamples.eventType, "unknown"),
+    const afterRow = db.select({ n: sql4`count(*)` }).from(rawEventSamples).where(and10(
+      eq13(rawEventSamples.eventType, "unknown"),
       inArray4(rawEventSamples.projectId, projectIds)
     )).get();
     result.unknownAfter = Number(afterRow?.n ?? 0);
@@ -6298,7 +6799,7 @@ No DB writes performed. Re-run without --dry-run to apply.`);
 }
 
 // src/commands/skills.ts
-import crypto13 from "crypto";
+import crypto15 from "crypto";
 import fs4 from "fs";
 import os4 from "os";
 import path5 from "path";
@@ -6353,7 +6854,7 @@ function walkRelative(dir, prefix = "") {
   return out.sort();
 }
 function sha256File(filePath) {
-  return crypto13.createHash("sha256").update(fs4.readFileSync(filePath)).digest("hex");
+  return crypto15.createHash("sha256").update(fs4.readFileSync(filePath)).digest("hex");
 }
 function readSkillManifest(skillDir) {
   try {
@@ -6676,10 +7177,10 @@ var ProviderRegistry = class {
 };
 
 // src/scheduler.ts
-import crypto14 from "crypto";
+import crypto16 from "crypto";
 import cron from "node-cron";
-import { and as and10, eq as eq12, inArray as inArray5 } from "drizzle-orm";
-var log12 = createLogger("Scheduler");
+import { and as and11, eq as eq14, inArray as inArray5 } from "drizzle-orm";
+var log14 = createLogger("Scheduler");
 function taskKey(projectId, kind) {
   return `${projectId}::${kind}`;
 }
@@ -6693,16 +7194,16 @@ var Scheduler = class {
   }
   /** Load all enabled schedules from DB and register cron jobs. */
   start() {
-    const allSchedules = this.db.select().from(schedules).where(eq12(schedules.enabled, true)).all();
+    const allSchedules = this.db.select().from(schedules).where(eq14(schedules.enabled, true)).all();
     for (const schedule of allSchedules) {
       const missedRunAt = schedule.nextRunAt;
       this.registerCronTask(schedule);
       if (missedRunAt && new Date(missedRunAt) < /* @__PURE__ */ new Date()) {
-        log12.info("run.catch-up", { projectId: schedule.projectId, kind: schedule.kind, missedRunAt });
+        log14.info("run.catch-up", { projectId: schedule.projectId, kind: schedule.kind, missedRunAt });
         this.triggerRun(schedule.id, schedule.projectId, schedule.kind);
       }
     }
-    log12.info("started", { scheduleCount: allSchedules.length });
+    log14.info("started", { scheduleCount: allSchedules.length });
   }
   /** Stop all cron tasks for graceful shutdown. */
   stop() {
@@ -6723,7 +7224,7 @@ var Scheduler = class {
       this.stopTask(key, existing, "Stopped");
       this.tasks.delete(key);
     }
-    const schedule = this.db.select().from(schedules).where(and10(eq12(schedules.projectId, projectId), eq12(schedules.kind, kind))).get();
+    const schedule = this.db.select().from(schedules).where(and11(eq14(schedules.projectId, projectId), eq14(schedules.kind, kind))).get();
     if (schedule && schedule.enabled) {
       this.registerCronTask(schedule);
     }
@@ -6746,13 +7247,13 @@ var Scheduler = class {
   stopTask(key, task, verb) {
     void task.stop();
     void task.destroy();
-    log12.info(`task.${verb.toLowerCase()}`, { key });
+    log14.info(`task.${verb.toLowerCase()}`, { key });
   }
   registerCronTask(schedule) {
     const { id: scheduleId, projectId, cronExpr, timezone } = schedule;
     const kind = schedule.kind;
     if (!cron.validate(cronExpr)) {
-      log12.error("cron.invalid", { projectId, kind, cronExpr });
+      log14.error("cron.invalid", { projectId, kind, cronExpr });
       return;
     }
     const task = cron.schedule(cronExpr, () => {
@@ -6764,51 +7265,51 @@ var Scheduler = class {
     this.db.update(schedules).set({
       nextRunAt: nextRunFromCron(cronExpr, timezone),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq12(schedules.id, scheduleId)).run();
+    }).where(eq14(schedules.id, scheduleId)).run();
     const label = schedule.preset ?? cronExpr;
-    log12.info("cron.registered", { projectId, kind, schedule: label, timezone });
+    log14.info("cron.registered", { projectId, kind, schedule: label, timezone });
   }
   triggerRun(scheduleId, projectId, kind) {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const currentSchedule = this.db.select().from(schedules).where(eq12(schedules.id, scheduleId)).get();
+      const currentSchedule = this.db.select().from(schedules).where(eq14(schedules.id, scheduleId)).get();
       if (!currentSchedule || !currentSchedule.enabled) {
-        log12.warn("schedule.stale", { scheduleId, projectId, kind, msg: "schedule no longer exists or is disabled" });
+        log14.warn("schedule.stale", { scheduleId, projectId, kind, msg: "schedule no longer exists or is disabled" });
         this.remove(projectId, kind);
         return;
       }
       const nextRunAt = nextRunFromCron(currentSchedule.cronExpr, currentSchedule.timezone);
-      const project = this.db.select().from(projects).where(eq12(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq14(projects.id, projectId)).get();
       if (!project) {
-        log12.error("project.not-found", { projectId, kind, msg: "skipping scheduled run" });
+        log14.error("project.not-found", { projectId, kind, msg: "skipping scheduled run" });
         this.remove(projectId, kind);
         return;
       }
       if (kind === SchedulableRunKinds["traffic-sync"]) {
         const sourceId = currentSchedule.sourceId;
         if (!sourceId) {
-          log12.warn("traffic-sync.missing-source", { scheduleId, projectId });
+          log14.warn("traffic-sync.missing-source", { scheduleId, projectId });
           return;
         }
         if (!this.callbacks.onTrafficSyncRequested) {
-          log12.warn("traffic-sync.no-callback", { scheduleId, projectId, msg: "host did not register onTrafficSyncRequested" });
+          log14.warn("traffic-sync.no-callback", { scheduleId, projectId, msg: "host did not register onTrafficSyncRequested" });
           return;
         }
         this.db.update(schedules).set({
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq12(schedules.id, currentSchedule.id)).run();
-        log12.info("traffic-sync.triggered", { projectName: project.name, sourceId });
+        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        log14.info("traffic-sync.triggered", { projectName: project.name, sourceId });
         this.callbacks.onTrafficSyncRequested(project.name, sourceId);
         return;
       }
       if (kind === SchedulableRunKinds["gbp-sync"]) {
         if (!this.callbacks.onGbpSyncRequested) {
-          log12.warn("gbp-sync.no-callback", { scheduleId, projectId, msg: "host did not register onGbpSyncRequested" });
+          log14.warn("gbp-sync.no-callback", { scheduleId, projectId, msg: "host did not register onGbpSyncRequested" });
           return;
         }
-        const runId2 = crypto14.randomUUID();
+        const runId2 = crypto16.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -6821,55 +7322,88 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq12(schedules.id, currentSchedule.id)).run();
-        log12.info("gbp-sync.triggered", { runId: runId2, projectName: project.name });
+        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        log14.info("gbp-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onGbpSyncRequested(runId2, projectId);
         return;
       }
+      if (kind === SchedulableRunKinds["ads-sync"]) {
+        if (!this.callbacks.onAdsSyncRequested) {
+          log14.warn("ads-sync.no-callback", { scheduleId, projectId, msg: "host did not register onAdsSyncRequested" });
+          return;
+        }
+        const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and11(
+          eq14(runs.projectId, projectId),
+          eq14(runs.kind, RunKinds["ads-sync"]),
+          inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
+        )).get();
+        if (activeAdsRun) {
+          log14.info("ads-sync.skipped-active", { projectName: project.name, activeRunId: activeAdsRun.id });
+          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq14(schedules.id, currentSchedule.id)).run();
+          return;
+        }
+        const runId2 = crypto16.randomUUID();
+        this.db.insert(runs).values({
+          id: runId2,
+          projectId,
+          kind: RunKinds["ads-sync"],
+          status: RunStatuses.queued,
+          trigger: RunTriggers.scheduled,
+          createdAt: now
+        }).run();
+        this.db.update(schedules).set({
+          lastRunAt: now,
+          nextRunAt,
+          updatedAt: now
+        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        log14.info("ads-sync.triggered", { runId: runId2, projectName: project.name });
+        this.callbacks.onAdsSyncRequested(runId2, projectId);
+        return;
+      }
       if (kind === SchedulableRunKinds["data-refresh"]) {
         if (!this.callbacks.onDataRefreshRequested) {
-          log12.warn("data-refresh.no-callback", { scheduleId, projectId, msg: "host did not register onDataRefreshRequested" });
+          log14.warn("data-refresh.no-callback", { scheduleId, projectId, msg: "host did not register onDataRefreshRequested" });
           return;
         }
         this.db.update(schedules).set({
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq12(schedules.id, currentSchedule.id)).run();
-        log12.info("data-refresh.triggered", { projectName: project.name });
+        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        log14.info("data-refresh.triggered", { projectName: project.name });
         this.callbacks.onDataRefreshRequested(project.name);
         return;
       }
       if (kind === SchedulableRunKinds["backlinks-sync"]) {
         if (!this.callbacks.onBacklinksSyncRequested) {
-          log12.warn("backlinks-sync.no-callback", { scheduleId, projectId, msg: "host did not register onBacklinksSyncRequested" });
+          log14.warn("backlinks-sync.no-callback", { scheduleId, projectId, msg: "host did not register onBacklinksSyncRequested" });
           return;
         }
         this.db.update(schedules).set({
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq12(schedules.id, currentSchedule.id)).run();
-        log12.info("backlinks-sync.triggered", { projectName: project.name });
+        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        log14.info("backlinks-sync.triggered", { projectName: project.name });
         this.callbacks.onBacklinksSyncRequested(project.name);
         return;
       }
       if (kind === SchedulableRunKinds["site-audit"]) {
         if (!this.callbacks.onSiteAuditRequested) {
-          log12.warn("site-audit.no-callback", { scheduleId, projectId, msg: "host did not register onSiteAuditRequested" });
+          log14.warn("site-audit.no-callback", { scheduleId, projectId, msg: "host did not register onSiteAuditRequested" });
           return;
         }
-        const active = this.db.select({ id: runs.id }).from(runs).where(and10(
-          eq12(runs.projectId, projectId),
-          eq12(runs.kind, RunKinds["site-audit"]),
+        const active = this.db.select({ id: runs.id }).from(runs).where(and11(
+          eq14(runs.projectId, projectId),
+          eq14(runs.kind, RunKinds["site-audit"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (active) {
-          log12.info("site-audit.skipped-active", { projectName: project.name, activeRunId: active.id });
-          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq12(schedules.id, currentSchedule.id)).run();
+          log14.info("site-audit.skipped-active", { projectName: project.name, activeRunId: active.id });
+          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq14(schedules.id, currentSchedule.id)).run();
           return;
         }
-        const runId2 = crypto14.randomUUID();
+        const runId2 = crypto16.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -6882,8 +7416,8 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq12(schedules.id, currentSchedule.id)).run();
-        log12.info("site-audit.triggered", { runId: runId2, projectName: project.name });
+        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        log14.info("site-audit.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onSiteAuditRequested(runId2, projectId);
         return;
       }
@@ -6892,7 +7426,7 @@ var Scheduler = class {
       if (project.defaultLocation) {
         const loc = projectLocations.find((l) => l.label === project.defaultLocation);
         if (!loc) {
-          log12.warn("default-location.stale", { scheduleId, projectId, label: project.defaultLocation });
+          log14.warn("default-location.stale", { scheduleId, projectId, label: project.defaultLocation });
           return;
         }
         resolvedLocation = loc;
@@ -6906,11 +7440,11 @@ var Scheduler = class {
         location: locationLabel
       });
       if (queueResult.conflict) {
-        log12.info("run.skipped-active", { projectName: project.name, activeRunId: queueResult.activeRunId });
+        log14.info("run.skipped-active", { projectName: project.name, activeRunId: queueResult.activeRunId });
         this.db.update(schedules).set({
           nextRunAt,
           updatedAt: now
-        }).where(eq12(schedules.id, currentSchedule.id)).run();
+        }).where(eq14(schedules.id, currentSchedule.id)).run();
         return;
       }
       const runId = queueResult.runId;
@@ -6918,43 +7452,44 @@ var Scheduler = class {
         lastRunAt: now,
         nextRunAt,
         updatedAt: now
-      }).where(eq12(schedules.id, currentSchedule.id)).run();
+      }).where(eq14(schedules.id, currentSchedule.id)).run();
       const scheduleProviders = currentSchedule.providers;
       const providers = scheduleProviders.length > 0 ? scheduleProviders : void 0;
-      log12.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
+      log14.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
       this.callbacks.onRunCreated(runId, projectId, providers, resolvedLocation);
     } catch (err) {
-      log12.error("trigger.error", { scheduleId, projectId, kind, error: err instanceof Error ? err.message : String(err) });
+      log14.error("trigger.error", { scheduleId, projectId, kind, error: err instanceof Error ? err.message : String(err) });
     }
   }
 };
 
 // src/data-refresh.ts
-var log13 = createLogger("DataRefresh");
+var log15 = createLogger("DataRefresh");
 async function refreshAllIntegrations(client, projectName) {
   const integrations = [
     { name: "gsc", run: () => client.gscSync(projectName, {}) },
     { name: "bing", run: () => client.bingInspectSitemap(projectName, {}) },
     { name: "ga", run: () => client.gaSync(projectName, { days: 30 }) },
-    { name: "gbp", run: () => client.triggerGbpSync(projectName, {}) }
+    { name: "gbp", run: () => client.triggerGbpSync(projectName, {}) },
+    { name: "ads", run: () => client.triggerAdsSync(projectName) }
   ];
   const results = await Promise.allSettled(integrations.map((i) => i.run()));
   results.forEach((result, idx) => {
     const integration = integrations[idx].name;
     if (result.status === "fulfilled") {
-      log13.info("integration.refreshed", { projectName, integration });
+      log15.info("integration.refreshed", { projectName, integration });
     } else {
       const reason = result.reason;
       const message = reason instanceof Error ? reason.message : String(reason);
-      log13.warn("integration.refresh-failed", { projectName, integration, error: message });
+      log15.warn("integration.refresh-failed", { projectName, integration, error: message });
     }
   });
 }
 
 // src/notifier.ts
-import { eq as eq13, desc as desc5, and as and11, inArray as inArray6, or } from "drizzle-orm";
-import crypto15 from "crypto";
-var log14 = createLogger("Notifier");
+import { eq as eq15, desc as desc5, and as and12, inArray as inArray6, or } from "drizzle-orm";
+import crypto17 from "crypto";
+var log16 = createLogger("Notifier");
 var Notifier = class {
   db;
   serverUrl;
@@ -6964,26 +7499,26 @@ var Notifier = class {
   }
   /** Called after a run completes (success, partial, or failed). */
   async onRunCompleted(runId, projectId) {
-    log14.info("run.completed", { runId, projectId });
-    const notifs = this.db.select().from(notifications).where(eq13(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    log16.info("run.completed", { runId, projectId });
+    const notifs = this.db.select().from(notifications).where(eq15(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) {
-      log14.info("notifications.none-enabled", { projectId });
+      log16.info("notifications.none-enabled", { projectId });
       return;
     }
-    log14.info("notifications.found", { projectId, count: notifs.length });
-    const run = this.db.select().from(runs).where(eq13(runs.id, runId)).get();
+    log16.info("notifications.found", { projectId, count: notifs.length });
+    const run = this.db.select().from(runs).where(eq15(runs.id, runId)).get();
     if (!run) {
-      log14.error("run.not-found", { runId, msg: "skipping notification dispatch" });
+      log16.error("run.not-found", { runId, msg: "skipping notification dispatch" });
       return;
     }
-    const project = this.db.select().from(projects).where(eq13(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq15(projects.id, projectId)).get();
     if (!project) {
-      log14.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
+      log16.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
       return;
     }
     const transitions = this.computeTransitions(runId, projectId);
     const events = [];
-    log14.info("run.status", { runId: run.id, status: run.status, projectId });
+    log16.info("run.status", { runId: run.id, status: run.status, projectId });
     if (run.status === "completed" || run.status === "partial") {
       events.push("run.completed");
     }
@@ -6999,7 +7534,7 @@ var Notifier = class {
       if (!config.url) continue;
       const subscribedEvents = config.events;
       const matchingEvents = events.filter((e) => subscribedEvents.includes(e));
-      log14.info("notification.match", { notificationId: notif.id, subscribedEvents, matchedEvents: matchingEvents });
+      log16.info("notification.match", { notificationId: notif.id, subscribedEvents, matchedEvents: matchingEvents });
       if (matchingEvents.length === 0) continue;
       for (const event of matchingEvents) {
         const relevantTransitions = event === "citation.lost" ? lostTransitions : event === "citation.gained" ? gainedTransitions : transitions;
@@ -7023,11 +7558,11 @@ var Notifier = class {
     if (criticalInsights.length > 0) insightEvents.push("insight.critical");
     if (highInsights.length > 0) insightEvents.push("insight.high");
     if (insightEvents.length === 0) return;
-    const notifs = this.db.select().from(notifications).where(eq13(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq15(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) return;
-    const run = this.db.select().from(runs).where(eq13(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq15(runs.id, runId)).get();
     if (!run) return;
-    const project = this.db.select().from(projects).where(eq13(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq15(projects.id, projectId)).get();
     if (!project) return;
     for (const notif of notifs) {
       const config = notif.config;
@@ -7057,12 +7592,12 @@ var Notifier = class {
     }
   }
   computeTransitions(runId, projectId) {
-    const thisRun = this.db.select().from(runs).where(eq13(runs.id, runId)).get();
+    const thisRun = this.db.select().from(runs).where(eq15(runs.id, runId)).get();
     if (!thisRun) return [];
-    const groupSiblings = this.db.select().from(runs).where(and11(
-      eq13(runs.projectId, projectId),
-      eq13(runs.kind, thisRun.kind),
-      eq13(runs.createdAt, thisRun.createdAt)
+    const groupSiblings = this.db.select().from(runs).where(and12(
+      eq15(runs.projectId, projectId),
+      eq15(runs.kind, thisRun.kind),
+      eq15(runs.createdAt, thisRun.createdAt)
     )).all();
     const stillPending = groupSiblings.some((r) => r.status === "queued" || r.status === "running");
     if (stillPending) return [];
@@ -7078,17 +7613,17 @@ var Notifier = class {
       return candidate.id > best.id ? candidate : best;
     });
     if (winner.id !== runId) return [];
-    const projectLocations = this.db.select({ locations: projects.locations }).from(projects).where(eq13(projects.id, projectId)).get();
+    const projectLocations = this.db.select({ locations: projects.locations }).from(projects).where(eq15(projects.id, projectId)).get();
     const locationCount = Math.max(
       1,
       (projectLocations?.locations ?? []).length
     );
     const RECENT_FETCH_LIMIT = Math.max(8, locationCount * 4);
     const recentRuns = this.db.select().from(runs).where(
-      and11(
-        eq13(runs.projectId, projectId),
-        eq13(runs.kind, thisRun.kind),
-        or(eq13(runs.status, "completed"), eq13(runs.status, "partial"))
+      and12(
+        eq15(runs.projectId, projectId),
+        eq15(runs.kind, thisRun.kind),
+        or(eq15(runs.status, "completed"), eq15(runs.status, "partial"))
       )
     ).orderBy(desc5(runs.createdAt), desc5(runs.id)).limit(RECENT_FETCH_LIMIT).all();
     const groups = groupRunsByCreatedAt(recentRuns);
@@ -7105,7 +7640,7 @@ var Notifier = class {
       provider: querySnapshots.provider,
       location: querySnapshots.location,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).leftJoin(queries, eq13(querySnapshots.queryId, queries.id)).where(inArray6(querySnapshots.runId, currentRunIds)).all();
+    }).from(querySnapshots).leftJoin(queries, eq15(querySnapshots.queryId, queries.id)).where(inArray6(querySnapshots.runId, currentRunIds)).all();
     const previousSnapshots = this.db.select({
       queryId: querySnapshots.queryId,
       provider: querySnapshots.provider,
@@ -7138,23 +7673,23 @@ var Notifier = class {
     const targetLabel = redactNotificationUrl(url).urlDisplay;
     const targetCheck = await resolveWebhookTarget(url);
     if (!targetCheck.ok) {
-      log14.error("webhook.ssrf-blocked", { url: targetLabel, reason: targetCheck.message });
+      log16.error("webhook.ssrf-blocked", { url: targetLabel, reason: targetCheck.message });
       this.logDelivery(projectId, notificationId, payload.event, "failed", `SSRF: ${targetCheck.message}`);
       return;
     }
-    log14.info("webhook.send", { event: payload.event, url: targetLabel });
+    log16.info("webhook.send", { event: payload.event, url: targetLabel });
     const maxRetries = 3;
     const delays = [1e3, 4e3, 16e3];
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       try {
         const response = await deliverWebhook(targetCheck.target, payload, webhookSecret);
         if (response.status >= 200 && response.status < 300) {
-          log14.info("webhook.delivered", { event: payload.event, url: targetLabel, httpStatus: response.status });
+          log16.info("webhook.delivered", { event: payload.event, url: targetLabel, httpStatus: response.status });
           this.logDelivery(projectId, notificationId, payload.event, "sent", null);
           return;
         }
         const errorDetail = response.error ?? `HTTP ${response.status}`;
-        log14.warn("webhook.attempt-failed", { event: payload.event, url: targetLabel, attempt: attempt + 1, maxRetries, httpStatus: response.status, error: errorDetail });
+        log16.warn("webhook.attempt-failed", { event: payload.event, url: targetLabel, attempt: attempt + 1, maxRetries, httpStatus: response.status, error: errorDetail });
         if (attempt === maxRetries - 1) {
           this.logDelivery(projectId, notificationId, payload.event, "failed", errorDetail);
         }
@@ -7162,7 +7697,7 @@ var Notifier = class {
         const errorDetail = err instanceof Error ? err.message : String(err);
         if (attempt === maxRetries - 1) {
           this.logDelivery(projectId, notificationId, payload.event, "failed", errorDetail);
-          log14.error("webhook.exhausted", { event: payload.event, url: targetLabel, maxRetries, error: errorDetail });
+          log16.error("webhook.exhausted", { event: payload.event, url: targetLabel, maxRetries, error: errorDetail });
         }
       }
       if (attempt < maxRetries - 1) {
@@ -7172,7 +7707,7 @@ var Notifier = class {
   }
   logDelivery(projectId, notificationId, event, status, error) {
     this.db.insert(auditLog).values({
-      id: crypto15.randomUUID(),
+      id: crypto17.randomUUID(),
       projectId,
       actor: "scheduler",
       action: `notification.${status}`,
@@ -7185,8 +7720,8 @@ var Notifier = class {
 };
 
 // src/run-coordinator.ts
-import { eq as eq14 } from "drizzle-orm";
-var log15 = createLogger("RunCoordinator");
+import { eq as eq16 } from "drizzle-orm";
+var log17 = createLogger("RunCoordinator");
 var RunCoordinator = class {
   constructor(db, notifier, intelligenceService, onInsightsGenerated, onAeroEvent) {
     this.db = db;
@@ -7201,10 +7736,10 @@ var RunCoordinator = class {
   onInsightsGenerated;
   onAeroEvent;
   async onRunCompleted(runId, projectId) {
-    const runRow = this.db.select().from(runs).where(eq14(runs.id, runId)).get();
+    const runRow = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
     const kind = runRow?.kind ?? RunKinds["answer-visibility"];
     if (runRow?.trigger === RunTriggers.probe) {
-      log15.info("probe.skip-side-effects", { runId, projectId, kind });
+      log17.info("probe.skip-side-effects", { runId, projectId, kind });
       return;
     }
     let insightCount = 0;
@@ -7221,12 +7756,12 @@ var RunCoordinator = class {
             try {
               await this.onInsightsGenerated(runId, projectId, result);
             } catch (err) {
-              log15.error("insight-webhook.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+              log17.error("insight-webhook.failed", { runId, error: err instanceof Error ? err.message : String(err) });
             }
           }
         }
       } catch (err) {
-        log15.error("intelligence.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+        log17.error("intelligence.failed", { runId, error: err instanceof Error ? err.message : String(err) });
       }
     } else if (kind === RunKinds["gbp-sync"]) {
       try {
@@ -7239,17 +7774,17 @@ var RunCoordinator = class {
           try {
             await this.onInsightsGenerated(runId, projectId, analysisResultFromInsights(gbpInsights));
           } catch (err) {
-            log15.error("gbp-insight-webhook.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+            log17.error("gbp-insight-webhook.failed", { runId, error: err instanceof Error ? err.message : String(err) });
           }
         }
       } catch (err) {
-        log15.error("gbp-intelligence.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+        log17.error("gbp-intelligence.failed", { runId, error: err instanceof Error ? err.message : String(err) });
       }
     }
     try {
       await this.notifier.onRunCompleted(runId, projectId);
     } catch (err) {
-      log15.error("notifier.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+      log17.error("notifier.failed", { runId, error: err instanceof Error ? err.message : String(err) });
     }
     if (this.onAeroEvent) {
       try {
@@ -7262,7 +7797,7 @@ var RunCoordinator = class {
         };
         await this.onAeroEvent(ctx);
       } catch (err) {
-        log15.error("aero.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+        log17.error("aero.failed", { runId, error: err instanceof Error ? err.message : String(err) });
       }
     }
   }
@@ -7277,7 +7812,7 @@ var RunCoordinator = class {
    * so the Aero queue is never starved of a follow-up.
    */
   buildDiscoveryAeroContext(runId, projectId, status, error) {
-    const session = this.db.select().from(discoverySessions).where(eq14(discoverySessions.runId, runId)).get();
+    const session = this.db.select().from(discoverySessions).where(eq16(discoverySessions.runId, runId)).get();
     const competitorMap = session ? session.competitorMap : [];
     return {
       kind: RunKinds["aeo-discover-probe"],
@@ -7317,8 +7852,8 @@ function analysisResultFromInsights(insights2) {
 }
 
 // src/agent/session-registry.ts
-import crypto17 from "crypto";
-import { eq as eq16 } from "drizzle-orm";
+import crypto19 from "crypto";
+import { eq as eq18 } from "drizzle-orm";
 
 // src/agent/session.ts
 import fs7 from "fs";
@@ -7706,8 +8241,8 @@ function resolveSessionProviderAndModel(config, opts) {
 }
 
 // src/agent/memory-store.ts
-import crypto16 from "crypto";
-import { and as and12, desc as desc6, eq as eq15, like, sql as sql5 } from "drizzle-orm";
+import crypto18 from "crypto";
+import { and as and13, desc as desc6, eq as eq17, like, sql as sql5 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -7721,7 +8256,7 @@ function rowToDto(row) {
   };
 }
 function listMemoryEntries(db, projectId, opts = {}) {
-  const query = db.select().from(agentMemory).where(eq15(agentMemory.projectId, projectId)).orderBy(desc6(agentMemory.updatedAt));
+  const query = db.select().from(agentMemory).where(eq17(agentMemory.projectId, projectId)).orderBy(desc6(agentMemory.updatedAt));
   const rows = opts.limit === void 0 ? query.all() : query.limit(opts.limit).all();
   return rows.map(rowToDto);
 }
@@ -7735,7 +8270,7 @@ function upsertMemoryEntry(db, args) {
     throw new Error(`memory key prefix "${COMPACTION_KEY_PREFIX}" is reserved for compaction notes`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const id = crypto16.randomUUID();
+  const id = crypto18.randomUUID();
   db.insert(agentMemory).values({
     id,
     projectId: args.projectId,
@@ -7752,12 +8287,12 @@ function upsertMemoryEntry(db, args) {
       updatedAt: now
     }
   }).run();
-  const row = db.select().from(agentMemory).where(and12(eq15(agentMemory.projectId, args.projectId), eq15(agentMemory.key, args.key))).get();
+  const row = db.select().from(agentMemory).where(and13(eq17(agentMemory.projectId, args.projectId), eq17(agentMemory.key, args.key))).get();
   if (!row) throw new Error("memory upsert produced no row");
   return rowToDto(row);
 }
 function deleteMemoryEntry(db, projectId, key) {
-  const result = db.delete(agentMemory).where(and12(eq15(agentMemory.projectId, projectId), eq15(agentMemory.key, key))).run();
+  const result = db.delete(agentMemory).where(and13(eq17(agentMemory.projectId, projectId), eq17(agentMemory.key, key))).run();
   const changes = result.changes ?? 0;
   return changes > 0;
 }
@@ -7772,7 +8307,7 @@ function writeCompactionNote(db, args) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const key = `${COMPACTION_KEY_PREFIX}${args.sessionId}:${now}`;
-  const id = crypto16.randomUUID();
+  const id = crypto18.randomUUID();
   let inserted;
   db.transaction((tx) => {
     tx.insert(agentMemory).values({
@@ -7786,8 +8321,8 @@ function writeCompactionNote(db, args) {
     }).run();
     const sessionPrefix = `${COMPACTION_KEY_PREFIX}${args.sessionId}:`;
     const existing = tx.select({ id: agentMemory.id, updatedAt: agentMemory.updatedAt }).from(agentMemory).where(
-      and12(
-        eq15(agentMemory.projectId, args.projectId),
+      and13(
+        eq17(agentMemory.projectId, args.projectId),
         like(agentMemory.key, `${sessionPrefix}%`)
       )
     ).orderBy(desc6(agentMemory.updatedAt)).all();
@@ -7795,7 +8330,7 @@ function writeCompactionNote(db, args) {
     if (stale.length > 0) {
       tx.delete(agentMemory).where(sql5`${agentMemory.id} IN (${sql5.join(stale.map((s) => sql5`${s}`), sql5`, `)})`).run();
     }
-    const row = tx.select().from(agentMemory).where(and12(eq15(agentMemory.projectId, args.projectId), eq15(agentMemory.key, key))).get();
+    const row = tx.select().from(agentMemory).where(and13(eq17(agentMemory.projectId, args.projectId), eq17(agentMemory.key, key))).get();
     if (row) inserted = rowToDto(row);
   });
   if (!inserted) throw new Error("compaction note write produced no row");
@@ -7928,7 +8463,7 @@ async function compactMessages(args) {
 }
 
 // src/agent/session-registry.ts
-var log16 = createLogger("SessionRegistry");
+var log18 = createLogger("SessionRegistry");
 var MAX_HYDRATE_NOTES = 20;
 var MAX_HYDRATE_BYTES = 32 * 1024;
 function escapeMemoryFragment(value) {
@@ -7977,7 +8512,7 @@ var SessionRegistry = class {
           modelProvider: effectiveProvider,
           modelId: effectiveModelId,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(eq16(agentSessions.projectId, projectId)).run();
+        }).where(eq18(agentSessions.projectId, projectId)).run();
       }
       const agent2 = createAeroSession({
         projectName,
@@ -8155,13 +8690,13 @@ ${lines.join("\n")}
       agent.state.messages = result.messages;
       agent.state.systemPrompt = this.buildHydratedSystemPrompt(projectId, row.systemPrompt);
       this.save(projectName);
-      log16.info("compaction.completed", {
+      log18.info("compaction.completed", {
         projectName,
         removedCount: result.removedCount,
         summaryBytes: Buffer.byteLength(result.summary, "utf8")
       });
     } catch (err) {
-      log16.error("compaction.failed", {
+      log18.error("compaction.failed", {
         projectName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -8191,7 +8726,7 @@ ${lines.join("\n")}
       modelProvider: nextProvider,
       modelId: nextModelId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq16(agentSessions.projectId, projectId)).run();
+    }).where(eq18(agentSessions.projectId, projectId)).run();
   }
   /** Persist a session's transcript back to the DB. Call after any run settles. */
   save(projectName) {
@@ -8258,7 +8793,7 @@ ${lines.join("\n")}
       await agent.prompt(msgs);
       this.save(projectName);
     } catch (err) {
-      log16.error("drain.failed", {
+      log18.error("drain.failed", {
         projectName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -8353,17 +8888,17 @@ ${lines.join("\n")}
     return id;
   }
   tryResolveProjectId(projectName) {
-    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq16(projects.name, projectName)).get();
+    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq18(projects.name, projectName)).get();
     return row?.id;
   }
   loadRow(projectId) {
-    const row = this.opts.db.select().from(agentSessions).where(eq16(agentSessions.projectId, projectId)).get();
+    const row = this.opts.db.select().from(agentSessions).where(eq18(agentSessions.projectId, projectId)).get();
     return row ?? null;
   }
   insertRow(params) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     this.opts.db.insert(agentSessions).values({
-      id: crypto17.randomUUID(),
+      id: crypto19.randomUUID(),
       projectId: params.projectId,
       systemPrompt: params.systemPrompt,
       modelProvider: params.provider ?? params.modelProvider ?? AgentProviderIds.claude,
@@ -8376,14 +8911,14 @@ ${lines.join("\n")}
   }
   updateRow(projectId, patch) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq16(agentSessions.projectId, projectId)).run();
+    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq18(agentSessions.projectId, projectId)).run();
   }
 };
 
 // src/agent/agent-routes.ts
-import { eq as eq17 } from "drizzle-orm";
+import { eq as eq19 } from "drizzle-orm";
 function resolveProject(db, name) {
-  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq17(projects.name, name)).get();
+  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq19(projects.name, name)).get();
   if (!row) throw notFound("project", name);
   return row;
 }
@@ -8392,7 +8927,7 @@ function registerAgentRoutes(app, opts) {
     "/projects/:name/agent/transcript",
     async (request) => {
       const project = resolveProject(opts.db, request.params.name);
-      const row = opts.db.select().from(agentSessions).where(eq17(agentSessions.projectId, project.id)).get();
+      const row = opts.db.select().from(agentSessions).where(eq19(agentSessions.projectId, project.id)).get();
       if (!row) {
         return { messages: [], modelProvider: null, modelId: null, updatedAt: null };
       }
@@ -8416,7 +8951,7 @@ function registerAgentRoutes(app, opts) {
     async (request) => {
       const project = resolveProject(opts.db, request.params.name);
       opts.sessionRegistry.reset(project.name);
-      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq17(agentSessions.projectId, project.id)).run();
+      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq19(agentSessions.projectId, project.id)).run();
       return { status: "reset" };
     }
   );
@@ -8856,7 +9391,7 @@ function formatAuditFactorScore(factor) {
 }
 
 // src/snapshot-service.ts
-var log17 = createLogger("Snapshot");
+var log19 = createLogger("Snapshot");
 var ANALYSIS_PROVIDER_PRIORITY = ["openai", "claude", "gemini", "perplexity", "local"];
 var SNAPSHOT_QUERY_COUNT = 6;
 var ProviderExecutionGate2 = class {
@@ -9002,7 +9537,7 @@ var SnapshotService = class {
       return mapAuditReport(report);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      log17.warn("audit.failed", { homepageUrl, error: message });
+      log19.warn("audit.failed", { homepageUrl, error: message });
       return {
         url: homepageUrl,
         finalUrl: homepageUrl,
@@ -9031,7 +9566,7 @@ var SnapshotService = class {
           queries: parsedQueries
         };
       } catch (err) {
-        log17.warn("profile.generation-failed", {
+        log19.warn("profile.generation-failed", {
           domain: ctx.domain,
           provider: ctx.analysisProvider.adapter.name,
           error: err instanceof Error ? err.message : String(err)
@@ -9173,7 +9708,7 @@ var SnapshotService = class {
         recommendedActions: uniqueStrings(parsed.recommendedActions ?? []).slice(0, 4)
       };
     } catch (err) {
-      log17.warn("response.analysis-failed", {
+      log19.warn("response.analysis-failed", {
         provider: ctx.analysisProvider.adapter.name,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -9455,7 +9990,7 @@ function clipText(value, length) {
 // src/server.ts
 var _require3 = createRequire3(import.meta.url);
 var { version: PKG_VERSION2 } = _require3("../package.json");
-var log18 = createLogger("Server");
+var log20 = createLogger("Server");
 var DEFAULT_QUOTA = {
   maxConcurrency: 2,
   maxRequestsPerMinute: 10,
@@ -9490,14 +10025,14 @@ function summarizeProviderConfig(config) {
   };
 }
 function hashApiKey(key) {
-  return crypto18.createHash("sha256").update(key).digest("hex");
+  return crypto20.createHash("sha256").update(key).digest("hex");
 }
 var DASHBOARD_SCRYPT_KEYLEN = 64;
 var DASHBOARD_SCRYPT_COST = 1 << 15;
 var DASHBOARD_SCRYPT_MAXMEM = 64 * 1024 * 1024;
 function hashDashboardPassword(password) {
-  const salt = crypto18.randomBytes(16);
-  const derived = crypto18.scryptSync(password, salt, DASHBOARD_SCRYPT_KEYLEN, {
+  const salt = crypto20.randomBytes(16);
+  const derived = crypto20.scryptSync(password, salt, DASHBOARD_SCRYPT_KEYLEN, {
     N: DASHBOARD_SCRYPT_COST,
     maxmem: DASHBOARD_SCRYPT_MAXMEM
   });
@@ -9518,18 +10053,18 @@ function verifyDashboardPassword(password, storedHash) {
     } catch {
       return { ok: false, needsRehash: false };
     }
-    const derived = crypto18.scryptSync(password, salt, expected.length, {
+    const derived = crypto20.scryptSync(password, salt, expected.length, {
       N: DASHBOARD_SCRYPT_COST,
       maxmem: DASHBOARD_SCRYPT_MAXMEM
     });
     if (derived.length !== expected.length) return { ok: false, needsRehash: false };
-    return { ok: crypto18.timingSafeEqual(derived, expected), needsRehash: false };
+    return { ok: crypto20.timingSafeEqual(derived, expected), needsRehash: false };
   }
   if (/^[a-f0-9]{64}$/i.test(storedHash)) {
     const candidate = Buffer.from(hashApiKey(password), "hex");
     const expected = Buffer.from(storedHash, "hex");
     if (candidate.length !== expected.length) return { ok: false, needsRehash: false };
-    const ok = crypto18.timingSafeEqual(candidate, expected);
+    const ok = crypto20.timingSafeEqual(candidate, expected);
     return { ok, needsRehash: ok };
   }
   return { ok: false, needsRehash: false };
@@ -9588,7 +10123,7 @@ function applyLegacyCredentials(rows, config) {
   }
   if (migratedGoogle > 0) {
     saveConfigPatch({ google: config.google });
-    log18.info("credentials.migrated", { type: "google", count: migratedGoogle });
+    log20.info("credentials.migrated", { type: "google", count: migratedGoogle });
   }
   let migratedGa4 = 0;
   for (const row of rows.ga4) {
@@ -9606,7 +10141,7 @@ function applyLegacyCredentials(rows, config) {
   }
   if (migratedGa4 > 0) {
     saveConfigPatch({ ga4: config.ga4 });
-    log18.info("credentials.migrated", { type: "ga4", count: migratedGa4 });
+    log20.info("credentials.migrated", { type: "ga4", count: migratedGa4 });
   }
 }
 function isLoopbackBindHost(host) {
@@ -9645,11 +10180,11 @@ async function createServer(opts) {
     applyLegacyCredentials(legacyRows, opts.config);
     dropLegacyCredentialColumns(opts.db);
   } catch (err) {
-    log18.warn("credentials.migration.failed", {
+    log20.warn("credentials.migration.failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
-  log18.info("providers.configured", { providers: Object.keys(providers).filter((k) => {
+  log20.info("providers.configured", { providers: Object.keys(providers).filter((k) => {
     const p = providers[k];
     return p?.apiKey || p?.baseUrl || p?.vertexProject;
   }) });
@@ -9698,7 +10233,7 @@ async function createServer(opts) {
     intelligenceService,
     (runId, projectId, result) => notifier.dispatchInsightWebhooks(runId, projectId, result),
     async (ctx) => {
-      const project = opts.db.select({ name: projects.name }).from(projects).where(eq18(projects.id, ctx.projectId)).get();
+      const project = opts.db.select({ name: projects.name }).from(projects).where(eq20(projects.id, ctx.projectId)).get();
       if (!project) return;
       let content;
       if (ctx.kind === RunKinds["aeo-discover-probe"]) {
@@ -9741,11 +10276,41 @@ async function createServer(opts) {
       app.log.error({ runId, err }, "GBP sync failed");
     });
   };
+  const runAdsSync = (runId, projectId) => {
+    executeAdsSync(opts.db, runId, projectId, { config: opts.config }).then(() => runCoordinator.onRunCompleted(runId, projectId)).catch((err) => {
+      app.log.error({ runId, err }, "Ads sync failed");
+    });
+  };
   const runSiteAudit = (runId, projectId, auditOpts) => {
     executeSiteAudit(opts.db, runId, projectId, auditOpts ?? {}).then(() => runCoordinator.onRunCompleted(runId, projectId)).catch((err) => {
       app.log.error({ runId, err }, "Site audit failed");
     });
   };
+  const adsCredentialStore = {
+    getConnection: (projectName) => {
+      return getOpenAiAdsConnection(opts.config, projectName);
+    },
+    upsertConnection: (connection) => {
+      const updated = upsertOpenAiAdsConnection(opts.config, connection);
+      saveConfigPatch(opts.config);
+      return updated;
+    },
+    removeConnection: (projectName) => {
+      const removed = removeOpenAiAdsConnection(opts.config, projectName);
+      if (removed) saveConfigPatch(opts.config);
+      return removed;
+    }
+  };
+  const verifyAdsAccount = async (apiKey) => {
+    const account = await getAdAccount(apiKey);
+    return {
+      id: account.id,
+      name: account.name,
+      status: account.status,
+      currencyCode: account.currency_code ?? null,
+      timezone: account.timezone ?? null
+    };
+  };
   const scheduler = new Scheduler(opts.db, {
     onRunCreated: (runId, projectId, providers2, location) => {
       jobRunner.executeRun(runId, projectId, providers2, location).catch((err) => {
@@ -9760,6 +10325,9 @@ async function createServer(opts) {
     onGbpSyncRequested: (runId, projectId) => {
       runGbpSync(runId, projectId);
     },
+    onAdsSyncRequested: (runId, projectId) => {
+      runAdsSync(runId, projectId);
+    },
     onDataRefreshRequested: (projectName) => {
       void refreshAllIntegrations(aeroClient, projectName);
     },
@@ -9770,9 +10338,9 @@ async function createServer(opts) {
           return null;
         });
         if (!probed) return;
-        const alreadySynced = opts.db.select().from(ccReleaseSyncs).where(and13(
-          eq18(ccReleaseSyncs.release, probed.release),
-          eq18(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
+        const alreadySynced = opts.db.select().from(ccReleaseSyncs).where(and14(
+          eq20(ccReleaseSyncs.release, probed.release),
+          eq20(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
         )).limit(1).get();
         if (alreadySynced) {
           app.log.info({ projectName, release: probed.release }, "Scheduled backlinks sync: already up to date, skipping");
@@ -9785,6 +10353,15 @@ async function createServer(opts) {
           );
         });
       })();
+      const project = opts.db.select().from(projects).where(eq20(projects.name, projectName)).get();
+      if (project && bingConnectionStore.getConnection(project.canonicalDomain)) {
+        aeroClient.backlinksBingSync(projectName).catch((err) => {
+          app.log.error(
+            { projectName, err: err instanceof Error ? err.message : String(err) },
+            "Scheduled Bing backlinks sync failed"
+          );
+        });
+      }
     },
     onSiteAuditRequested: (runId, projectId) => {
       runSiteAudit(runId, projectId);
@@ -9905,7 +10482,7 @@ async function createServer(opts) {
       return removed;
     }
   };
-  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto18.randomBytes(32).toString("hex");
+  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto20.randomBytes(32).toString("hex");
   const googleConnectionStore = {
     listConnections: (domain) => listGoogleConnections(opts.config, domain),
     getConnection: (domain, connectionType) => getGoogleConnection(opts.config, domain, connectionType),
@@ -9951,11 +10528,11 @@ async function createServer(opts) {
   const apiPrefix = basePath ? `${basePath}api/v1` : "/api/v1";
   if (opts.config.apiKey) {
     const keyHash = hashApiKey(opts.config.apiKey);
-    const existing = opts.db.select().from(apiKeys).where(eq18(apiKeys.keyHash, keyHash)).get();
+    const existing = opts.db.select().from(apiKeys).where(eq20(apiKeys.keyHash, keyHash)).get();
     if (!existing) {
       const prefix = opts.config.apiKey.slice(0, 12);
       opts.db.insert(apiKeys).values({
-        id: `key_${crypto18.randomBytes(8).toString("hex")}`,
+        id: `key_${crypto20.randomBytes(8).toString("hex")}`,
         name: "default",
         keyHash,
         keyPrefix: prefix,
@@ -9979,7 +10556,7 @@ async function createServer(opts) {
   };
   const createSession = (apiKeyId) => {
     pruneExpiredSessions();
-    const sessionId = crypto18.randomBytes(32).toString("hex");
+    const sessionId = crypto20.randomBytes(32).toString("hex");
     sessions.set(sessionId, {
       apiKeyId,
       expiresAt: Date.now() + SESSION_TTL_MS
@@ -10003,7 +10580,7 @@ async function createServer(opts) {
   };
   const getDefaultApiKey = () => {
     if (!opts.config.apiKey) return void 0;
-    return opts.db.select().from(apiKeys).where(eq18(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
+    return opts.db.select().from(apiKeys).where(eq20(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
   };
   const createPasswordSession = (reply) => {
     const key = getDefaultApiKey();
@@ -10024,7 +10601,7 @@ async function createServer(opts) {
     if (!header) return false;
     const parts = header.split(" ");
     if (parts.length !== 2 || parts[0] !== "Bearer") return false;
-    const key = opts.db.select().from(apiKeys).where(eq18(apiKeys.keyHash, hashApiKey(parts[1]))).get();
+    const key = opts.db.select().from(apiKeys).where(eq20(apiKeys.keyHash, hashApiKey(parts[1]))).get();
     return Boolean(key && !key.revokedAt);
   };
   app.get(apiPrefix + "/session", async (request, reply) => {
@@ -10078,12 +10655,12 @@ async function createServer(opts) {
       return reply.send({ authenticated: true });
     }
     if (apiKey) {
-      const key = opts.db.select().from(apiKeys).where(eq18(apiKeys.keyHash, hashApiKey(apiKey))).get();
+      const key = opts.db.select().from(apiKeys).where(eq20(apiKeys.keyHash, hashApiKey(apiKey))).get();
       if (!key || key.revokedAt) {
         const err2 = authInvalid();
         return reply.status(err2.statusCode).send(err2.toJSON());
       }
-      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq18(apiKeys.id, key.id)).run();
+      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq20(apiKeys.id, key.id)).run();
       const sessionId = createSession(key.id);
       reply.header("set-cookie", serializeSessionCookie({
         name: SESSION_COOKIE_NAME,
@@ -10216,6 +10793,11 @@ async function createServer(opts) {
     onGbpSyncRequested: (runId, projectId, syncOpts) => {
       runGbpSync(runId, projectId, syncOpts);
     },
+    adsCredentialStore,
+    verifyAdsAccount,
+    onAdsSyncRequested: (runId, projectId) => {
+      runAdsSync(runId, projectId);
+    },
     getBacklinksStatus: () => ({
       duckdbInstalled: isDuckdbInstalled(),
       duckdbVersion: readInstalledVersion() ?? void 0,
@@ -10237,7 +10819,7 @@ async function createServer(opts) {
         deps: {
           enqueueAutoExtract: ({ projectId, release: r }) => {
             const now = (/* @__PURE__ */ new Date()).toISOString();
-            const runId = crypto18.randomUUID();
+            const runId = crypto20.randomUUID();
             opts.db.insert(runs).values({
               id: runId,
               projectId,
@@ -10260,6 +10842,13 @@ async function createServer(opts) {
         app.log.error({ runId, err }, "Backlink extract failed");
       });
     },
+    onBingBacklinkSyncRequested: (runId, projectId) => {
+      executeBingBacklinkSync(opts.db, runId, projectId, {
+        resolveConnection: (domain) => bingConnectionStore.getConnection(domain)
+      }).catch((err) => {
+        app.log.error({ runId, err }, "Bing backlink sync failed");
+      });
+    },
     onDiscoveryRunRequested: (input) => {
       executeDiscoveryRun({
         db: opts.db,
@@ -10323,7 +10912,7 @@ async function createServer(opts) {
         ...inspectOpts,
         config: opts.config
       }).then(() => {
-        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq18(runs.id, runId)).get();
+        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq20(runs.id, runId)).get();
         if (finished?.status === RunStatuses.completed || finished?.status === RunStatuses.partial) {
           return maybeRefreshGscCoverage(opts.db, opts.config, projectId);
         }
@@ -10411,7 +11000,7 @@ async function createServer(opts) {
         const targetProjectIds = affectedProjectIds.length > 0 ? affectedProjectIds : [null];
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
         opts.db.insert(auditLog).values(targetProjectIds.map((projectId) => ({
-          id: crypto18.randomUUID(),
+          id: crypto20.randomUUID(),
           projectId,
           actor: "api",
           action: existing ? "provider.updated" : "provider.created",